PageRenderTime 60ms CodeModel.GetById 19ms RepoModel.GetById 0ms app.codeStats 1ms

/xmlParser.cpp

https://bitbucket.org/alan_cao/code123
C++ | 2888 lines | 2290 code | 228 blank | 370 comment | 470 complexity | 305cef3dec8429501ffd3f1e4dda9df3 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

    

  1. /**

    2. 

  2.  ****************************************************************************

    3. 

  3.  * <P> XML.c - implementation file for basic XML parser written in ANSI C++

    4. 

  4.  * for portability. It works by using recursion and a node tree for breaking

    5. 

  5.  * down the elements of an XML document.  </P>

    6. 

  6.  *

    7. 

  7.  * @version     V2.41

    8. 

  8.  * @author      Frank Vanden Berghen

    9. 

  9.  *

    10. 

  10.  * NOTE:

    11. 

  11.  *

    12. 

  12.  *   If you add "#define STRICT_PARSING", on the first line of this file

    13. 

  13.  *   the parser will see the following XML-stream:

    14. 

  14.  *      <a><b>some text</b><b>other text    </a>

    15. 

  15.  *   as an error. Otherwise, this tring will be equivalent to:

    16. 

  16.  *      <a><b>some text</b><b>other text</b></a>

    17. 

  17.  *

    18. 

  18.  * NOTE:

    19. 

  19.  *

    20. 

  20.  *   If you add "#define APPROXIMATE_PARSING" on the first line of this file

    21. 

  21.  *   the parser will see the following XML-stream:

    22. 

  22.  *     <data name="n1">

    23. 

  23.  *     <data name="n2">

    24. 

  24.  *     <data name="n3" />

    25. 

  25.  *   as equivalent to the following XML-stream:

    26. 

  26.  *     <data name="n1" />

    27. 

  27.  *     <data name="n2" />

    28. 

  28.  *     <data name="n3" />

    29. 

  29.  *   This can be useful for badly-formed XML-streams but prevent the use

    30. 

  30.  *   of the following XML-stream (problem is: tags at contiguous levels

    31. 

  31.  *   have the same names):

    32. 

  32.  *     <data name="n1">

    33. 

  33.  *        <data name="n2">

    34. 

  34.  *            <data name="n3" />

    35. 

  35.  *        </data>

    36. 

  36.  *     </data>

    37. 

  37.  *

    38. 

  38.  * NOTE:

    39. 

  39.  *

    40. 

  40.  *   If you add "#define _XMLPARSER_NO_MESSAGEBOX_" on the first line of this file

    41. 

  41.  *   the "openFileHelper" function will always display error messages inside the

    42. 

  42.  *   console instead of inside a message-box-window. Message-box-windows are

    43. 

  43.  *   available on windows 9x/NT/2000/XP/Vista only.

    44. 

  44.  *

    45. 

  45.  * Copyright (c) 2002, Business-Insight

    46. 

  46.  * <a href="http://www.Business-Insight.com">Business-Insight</a>

    47. 

  47.  * All rights reserved.

    48. 

  48.  * See the file "AFPL-license.txt" about the licensing terms

    49. 

  49.  *

    50. 

  50.  ****************************************************************************

    51. 

  51.  */

    52. 

  52. #ifndef _CRT_SECURE_NO_DEPRECATE

    53. 

  53. #define _CRT_SECURE_NO_DEPRECATE

    54. 

  54. #endif

    55. 

  55. #include "stdafx.h"

    56. 

  56. #include "xmlParser.h"

    57. 

  57. #ifdef _XMLWINDOWS

    58. 

  58. //#ifdef _DEBUG

    59. 

  59. //#define _CRTDBG_MAP_ALLOC

    60. 

  60. //#include <crtdbg.h>

    61. 

  61. //#endif

    62. 

  62. #define WIN32_LEAN_AND_MEAN

    63. 

  63. #include <Windows.h> // to have IsTextUnicode, MultiByteToWideChar, WideCharToMultiByte to handle unicode files

    64. 

  64.                      // to have "MessageBoxA" to display error messages for openFilHelper

    65. 

  65. #endif

    66. 

  66. 

    67. 

  67. #include <memory.h>

    68. 

  68. #include <assert.h>

    69. 

  69. #include <stdio.h>

    70. 

  70. #include <string.h>

    71. 

  71. #include <stdlib.h>

    72. 

  72. 

    73. 

  73. XMLCSTR XMLNode::getVersion() { return _CXML("v2.41"); }

    74. 

  74. void freeXMLString(XMLSTR t){if(t)free(t);}

    75. 

  75. 

    76. 

  76. static XMLNode::XMLCharEncoding characterEncoding=XMLNode::char_encoding_UTF8;

    77. 

  77. static char guessWideCharChars=1, dropWhiteSpace=1, removeCommentsInMiddleOfText=1;

    78. 

  78. 

    79. 

  79. inline int mmin( const int t1, const int t2 ) { return t1 < t2 ? t1 : t2; }

    80. 

  80. 

    81. 

  81. // You can modify the initialization of the variable "XMLClearTags" below

    82. 

  82. // to change the clearTags that are currently recognized by the library.

    83. 

  83. // The number on the second columns is the length of the string inside the

    84. 

  84. // first column. The "<!DOCTYPE" declaration must be the second in the list.

    85. 

  85. // The "<!--" declaration must be the third in the list.

    86. 

  86. typedef struct { XMLCSTR lpszOpen; int openTagLen; XMLCSTR lpszClose;} ALLXMLClearTag;

    87. 

  87. static ALLXMLClearTag XMLClearTags[] =

    88. 

  88. {

    89. 

  89.     {    _CXML("<![CDATA["),9,  _CXML("]]>")      },

    90. 

  90.     {    _CXML("<!DOCTYPE"),9,  _CXML(">")        },

    91. 

  91.     {    _CXML("<!--")     ,4,  _CXML("-->")      },

    92. 

  92.     {    _CXML("<PRE>")    ,5,  _CXML("</PRE>")   },

    93. 

  93. //  {    _CXML("<Script>") ,8,  _CXML("</Script>")},

    94. 

  94.     {    NULL              ,0,  NULL           }

    95. 

  95. };

    96. 

  96. 

    97. 

  97. // You can modify the initialization of the variable "XMLEntities" below

    98. 

  98. // to change the character entities that are currently recognized by the library.

    99. 

  99. // The number on the second columns is the length of the string inside the

    100. 

  100. // first column. Additionally, the syntaxes "&#xA0;" and "&#160;" are recognized.

    101. 

  101. typedef struct { XMLCSTR s; int l; XMLCHAR c;} XMLCharacterEntity;

    102. 

  102. static XMLCharacterEntity XMLEntities[] =

    103. 

  103. {

    104. 

  104.     { _CXML("&amp;" ), 5, _CXML('&' )},

    105. 

  105.     { _CXML("&lt;"  ), 4, _CXML('<' )},

    106. 

  106.     { _CXML("&gt;"  ), 4, _CXML('>' )},

    107. 

  107.     { _CXML("&quot;"), 6, _CXML('\"')},

    108. 

  108.     { _CXML("&apos;"), 6, _CXML('\'')},

    109. 

  109.     { NULL           , 0, '\0'    }

    110. 

  110. };

    111. 

  111. 

    112. 

  112. // When rendering the XMLNode to a string (using the "createXMLString" function),

    113. 

  113. // you can ask for a beautiful formatting. This formatting is using the

    114. 

  114. // following indentation character:

    115. 

  115. #define INDENTCHAR _CXML('\t')

    116. 

  116. 

    117. 

  117. // The following function parses the XML errors into a user friendly string.

    118. 

  118. // You can edit this to change the output language of the library to something else.

    119. 

  119. XMLCSTR XMLNode::getError(XMLError xerror)

    120. 

  120. {

    121. 

  121.     switch (xerror)

    122. 

  122.     {

    123. 

  123.     case eXMLErrorNone:                  return _CXML("No error");

    124. 

  124.     case eXMLErrorMissingEndTag:         return _CXML("Warning: Unmatched end tag");

    125. 

  125.     case eXMLErrorNoXMLTagFound:         return _CXML("Warning: No XML tag found");

    126. 

  126.     case eXMLErrorEmpty:                 return _CXML("Error: No XML data");

    127. 

  127.     case eXMLErrorMissingTagName:        return _CXML("Error: Missing start tag name");

    128. 

  128.     case eXMLErrorMissingEndTagName:     return _CXML("Error: Missing end tag name");

    129. 

  129.     case eXMLErrorUnmatchedEndTag:       return _CXML("Error: Unmatched end tag");

    130. 

  130.     case eXMLErrorUnmatchedEndClearTag:  return _CXML("Error: Unmatched clear tag end");

    131. 

  131.     case eXMLErrorUnexpectedToken:       return _CXML("Error: Unexpected token found");

    132. 

  132.     case eXMLErrorNoElements:            return _CXML("Error: No elements found");

    133. 

  133.     case eXMLErrorFileNotFound:          return _CXML("Error: File not found");

    134. 

  134.     case eXMLErrorFirstTagNotFound:      return _CXML("Error: First Tag not found");

    135. 

  135.     case eXMLErrorUnknownCharacterEntity:return _CXML("Error: Unknown character entity");

    136. 

  136.     case eXMLErrorCharacterCodeAbove255: return _CXML("Error: Character code above 255 is forbidden in MultiByte char mode.");

    137. 

  137.     case eXMLErrorCharConversionError:   return _CXML("Error: unable to convert between WideChar and MultiByte chars");

    138. 

  138.     case eXMLErrorCannotOpenWriteFile:   return _CXML("Error: unable to open file for writing");

    139. 

  139.     case eXMLErrorCannotWriteFile:       return _CXML("Error: cannot write into file");

    140. 

  140. 

    141. 

  141.     case eXMLErrorBase64DataSizeIsNotMultipleOf4: return _CXML("Warning: Base64-string length is not a multiple of 4");

    142. 

  142.     case eXMLErrorBase64DecodeTruncatedData:      return _CXML("Warning: Base64-string is truncated");

    143. 

  143.     case eXMLErrorBase64DecodeIllegalCharacter:   return _CXML("Error: Base64-string contains an illegal character");

    144. 

  144.     case eXMLErrorBase64DecodeBufferTooSmall:     return _CXML("Error: Base64 decode output buffer is too small");

    145. 

  145.     };

    146. 

  146.     return _CXML("Unknown");

    147. 

  147. }

    148. 

  148. 

    149. 

  149. /////////////////////////////////////////////////////////////////////////

    150. 

  150. //      Here start the abstraction layer to be OS-independent          //

    151. 

  151. /////////////////////////////////////////////////////////////////////////

    152. 

  152. 

    153. 

  153. // Here is an abstraction layer to access some common string manipulation functions.

    154. 

  154. // The abstraction layer is currently working for gcc, Microsoft Visual Studio 6.0,

    155. 

  155. // Microsoft Visual Studio .NET, CC (sun compiler) and Borland C++.

    156. 

  156. // If you plan to "port" the library to a new system/compiler, all you have to do is

    157. 

  157. // to edit the following lines.

    158. 

  158. #ifdef XML_NO_WIDE_CHAR

    159. 

  159. char myIsTextWideChar(const void *b, int len) { return FALSE; }

    160. 

  160. #else

    161. 

  161.     #if defined (UNDER_CE) || !defined(_XMLWINDOWS)

    162. 

  162.     char myIsTextWideChar(const void *b, int len) // inspired by the Wine API: RtlIsTextUnicode

    163. 

  163.     {

    164. 

  164. #ifdef sun

    165. 

  165.         // for SPARC processors: wchar_t* buffers must always be alligned, otherwise it's a char* buffer.

    166. 

  166.         if ((((unsigned long)b)%sizeof(wchar_t))!=0) return FALSE;

    167. 

  167. #endif

    168. 

  168.         const wchar_t *s=(const wchar_t*)b;

    169. 

  169. 

    170. 

  170.         // buffer too small:

    171. 

  171.         if (len<(int)sizeof(wchar_t)) return FALSE;

    172. 

  172. 

    173. 

  173.         // odd length test

    174. 

  174.         if (len&1) return FALSE;

    175. 

  175. 

    176. 

  176.         /* only checks the first 256 characters */

    177. 

  177.         len=mmin(256,len/sizeof(wchar_t));

    178. 

  178. 

    179. 

  179.         // Check for the special byte order:

    180. 

  180.         if (*((unsigned short*)s) == 0xFFFE) return TRUE;     // IS_TEXT_UNICODE_REVERSE_SIGNATURE;

    181. 

  181.         if (*((unsigned short*)s) == 0xFEFF) return TRUE;      // IS_TEXT_UNICODE_SIGNATURE

    182. 

  182. 

    183. 

  183.         // checks for ASCII characters in the UNICODE stream

    184. 

  184.         int i,stats=0;

    185. 

  185.         for (i=0; i<len; i++) if (s[i]<=(unsigned short)255) stats++;

    186. 

  186.         if (stats>len/2) return TRUE;

    187. 

  187. 

    188. 

  188.         // Check for UNICODE NULL chars

    189. 

  189.         for (i=0; i<len; i++) if (!s[i]) return TRUE;

    190. 

  190. 

    191. 

  191.         return FALSE;

    192. 

  192.     }

    193. 

  193.     #else

    194. 

  194.     char myIsTextWideChar(const void *b,int l) { return (char)IsTextUnicode((CONST LPVOID)b,l,NULL); };

    195. 

  195.     #endif

    196. 

  196. #endif

    197. 

  197. 

    198. 

  198. #ifdef _XMLWINDOWS

    199. 

  199. // for Microsoft Visual Studio 6.0 and Microsoft Visual Studio .NET and Borland C++ Builder 6.0

    200. 

  200.     #ifdef _XMLWIDECHAR

    201. 

  201.         wchar_t *myMultiByteToWideChar(const char *s, XMLNode::XMLCharEncoding ce)

    202. 

  202.         {

    203. 

  203.             int i;

    204. 

  204.             if (ce==XMLNode::char_encoding_UTF8) i=(int)MultiByteToWideChar(CP_UTF8,0             ,s,-1,NULL,0);

    205. 

  205.             else                            i=(int)MultiByteToWideChar(CP_ACP ,MB_PRECOMPOSED,s,-1,NULL,0);

    206. 

  206.             if (i<0) return NULL;

    207. 

  207.             wchar_t *d=(wchar_t *)malloc((i+1)*sizeof(XMLCHAR));

    208. 

  208.             if (ce==XMLNode::char_encoding_UTF8) i=(int)MultiByteToWideChar(CP_UTF8,0             ,s,-1,d,i);

    209. 

  209.             else                            i=(int)MultiByteToWideChar(CP_ACP ,MB_PRECOMPOSED,s,-1,d,i);

    210. 

  210.             d[i]=0;

    211. 

  211.             return d;

    212. 

  212.         }

    213. 

  213.         static inline FILE *xfopen(XMLCSTR filename,XMLCSTR mode) { return _wfopen(filename,mode); }

    214. 

  214.         static inline int xstrlen(XMLCSTR c)   { return (int)wcslen(c); }

    215. 

  215.         static inline int xstrnicmp(XMLCSTR c1, XMLCSTR c2, int l) { return _wcsnicmp(c1,c2,l);}

    216. 

  216.         static inline int xstrncmp(XMLCSTR c1, XMLCSTR c2, int l) { return wcsncmp(c1,c2,l);}

    217. 

  217.         static inline int xstricmp(XMLCSTR c1, XMLCSTR c2) { return _wcsicmp(c1,c2); }

    218. 

  218.         static inline XMLSTR xstrstr(XMLCSTR c1, XMLCSTR c2) { return (XMLSTR)wcsstr(c1,c2); }

    219. 

  219.         static inline XMLSTR xstrcpy(XMLSTR c1, XMLCSTR c2) { return (XMLSTR)wcscpy(c1,c2); }

    220. 

  220.     #else

    221. 

  221.         char *myWideCharToMultiByte(const wchar_t *s)

    222. 

  222.         {

    223. 

  223.             UINT codePage=CP_ACP; if (characterEncoding==XMLNode::char_encoding_UTF8) codePage=CP_UTF8;

    224. 

  224.             int i=(int)WideCharToMultiByte(codePage,  // code page

    225. 

  225.                 0,                       // performance and mapping flags

    226. 

  226.                 s,                       // wide-character string

    227. 

  227.                 -1,                       // number of chars in string

    228. 

  228.                 NULL,                       // buffer for new string

    229. 

  229.                 0,                       // size of buffer

    230. 

  230.                 NULL,                    // default for unmappable chars

    231. 

  231.                 NULL                     // set when default char used

    232. 

  232.                 );

    233. 

  233.             if (i<0) return NULL;

    234. 

  234.             char *d=(char*)malloc(i+1);

    235. 

  235.             WideCharToMultiByte(codePage,  // code page

    236. 

  236.                 0,                       // performance and mapping flags

    237. 

  237.                 s,                       // wide-character string

    238. 

  238.                 -1,                       // number of chars in string

    239. 

  239.                 d,                       // buffer for new string

    240. 

  240.                 i,                       // size of buffer

    241. 

  241.                 NULL,                    // default for unmappable chars

    242. 

  242.                 NULL                     // set when default char used

    243. 

  243.                 );

    244. 

  244.             d[i]=0;

    245. 

  245.             return d;

    246. 

  246.         }

    247. 

  247.         static inline FILE *xfopen(XMLCSTR filename,XMLCSTR mode) { return fopen(filename,mode); }

    248. 

  248.         static inline int xstrlen(XMLCSTR c)   { return (int)strlen(c); }

    249. 

  249.         #ifdef __BORLANDC__

    250. 

  250.             static inline int xstrnicmp(XMLCSTR c1, XMLCSTR c2, int l) { return strnicmp(c1,c2,l);}

    251. 

  251.             static inline int xstricmp(XMLCSTR c1, XMLCSTR c2) { return stricmp(c1,c2); }

    252. 

  252.         #else

    253. 

  253.             static inline int xstrnicmp(XMLCSTR c1, XMLCSTR c2, int l) { return _strnicmp(c1,c2,l);}

    254. 

  254.             static inline int xstricmp(XMLCSTR c1, XMLCSTR c2) { return _stricmp(c1,c2); }

    255. 

  255.         #endif

    256. 

  256.         static inline int xstrncmp(XMLCSTR c1, XMLCSTR c2, int l) { return strncmp(c1,c2,l);}

    257. 

  257.         static inline XMLSTR xstrstr(XMLCSTR c1, XMLCSTR c2) { return (XMLSTR)strstr(c1,c2); }

    258. 

  258.         static inline XMLSTR xstrcpy(XMLSTR c1, XMLCSTR c2) { return (XMLSTR)strcpy(c1,c2); }

    259. 

  259.     #endif

    260. 

  260. #else

    261. 

  261. // for gcc and CC

    262. 

  262.     #ifdef XML_NO_WIDE_CHAR

    263. 

  263.         char *myWideCharToMultiByte(const wchar_t *s) { return NULL; }

    264. 

  264.     #else

    265. 

  265.         char *myWideCharToMultiByte(const wchar_t *s)

    266. 

  266.         {

    267. 

  267.             const wchar_t *ss=s;

    268. 

  268.             int i=(int)wcsrtombs(NULL,&ss,0,NULL);

    269. 

  269.             if (i<0) return NULL;

    270. 

  270.             char *d=(char *)malloc(i+1);

    271. 

  271.             wcsrtombs(d,&s,i,NULL);

    272. 

  272.             d[i]=0;

    273. 

  273.             return d;

    274. 

  274.         }

    275. 

  275.     #endif

    276. 

  276.     #ifdef _XMLWIDECHAR

    277. 

  277.         wchar_t *myMultiByteToWideChar(const char *s, XMLNode::XMLCharEncoding ce)

    278. 

  278.         {

    279. 

  279.             const char *ss=s;

    280. 

  280.             int i=(int)mbsrtowcs(NULL,&ss,0,NULL);

    281. 

  281.             if (i<0) return NULL;

    282. 

  282.             wchar_t *d=(wchar_t *)malloc((i+1)*sizeof(wchar_t));

    283. 

  283.             mbsrtowcs(d,&s,i,NULL);

    284. 

  284.             d[i]=0;

    285. 

  285.             return d;

    286. 

  286.         }

    287. 

  287.         int xstrlen(XMLCSTR c)   { return wcslen(c); }

    288. 

  288.         #ifdef sun

    289. 

  289.         // for CC

    290. 

  290.            #include <widec.h>

    291. 

  291.            static inline int xstrnicmp(XMLCSTR c1, XMLCSTR c2, int l) { return wsncasecmp(c1,c2,l);}

    292. 

  292.            static inline int xstrncmp(XMLCSTR c1, XMLCSTR c2, int l) { return wsncmp(c1,c2,l);}

    293. 

  293.            static inline int xstricmp(XMLCSTR c1, XMLCSTR c2) { return wscasecmp(c1,c2); }

    294. 

  294.         #else

    295. 

  295.         static inline int xstrncmp(XMLCSTR c1, XMLCSTR c2, int l) { return wcsncmp(c1,c2,l);}

    296. 

  296.             #ifdef __linux__

    297. 

  297.             // for gcc/linux

    298. 

  298.             static inline int xstrnicmp(XMLCSTR c1, XMLCSTR c2, int l) { return wcsncasecmp(c1,c2,l);}

    299. 

  299.             static inline int xstricmp(XMLCSTR c1, XMLCSTR c2) { return wcscasecmp(c1,c2); }

    300. 

  300.             #else

    301. 

  301.             #include <wctype.h>

    302. 

  302.             // for gcc/non-linux (MacOS X 10.3, FreeBSD 6.0, NetBSD 3.0, OpenBSD 3.8, AIX 4.3.2, HP-UX 11, IRIX 6.5, OSF/1 5.1, Cygwin, mingw)

    303. 

  303.             static inline int xstricmp(XMLCSTR c1, XMLCSTR c2)

    304. 

  304.             {

    305. 

  305.                 wchar_t left,right;

    306. 

  306.                 do

    307. 

  307.                 {

    308. 

  308.                     left=towlower(*c1++); right=towlower(*c2++);

    309. 

  309.                 } while (left&&(left==right));

    310. 

  310.                 return (int)left-(int)right;

    311. 

  311.             }

    312. 

  312.             static inline int xstrnicmp(XMLCSTR c1, XMLCSTR c2, int l)

    313. 

  313.             {

    314. 

  314.                 wchar_t left,right;

    315. 

  315.                 while(l--)

    316. 

  316.                 {

    317. 

  317.                     left=towlower(*c1++); right=towlower(*c2++);

    318. 

  318.                     if ((!left)||(left!=right)) return (int)left-(int)right;

    319. 

  319.                 }

    320. 

  320.                 return 0;

    321. 

  321.             }

    322. 

  322.             #endif

    323. 

  323.         #endif

    324. 

  324.         static inline XMLSTR xstrstr(XMLCSTR c1, XMLCSTR c2) { return (XMLSTR)wcsstr(c1,c2); }

    325. 

  325.         static inline XMLSTR xstrcpy(XMLSTR c1, XMLCSTR c2) { return (XMLSTR)wcscpy(c1,c2); }

    326. 

  326.         static inline FILE *xfopen(XMLCSTR filename,XMLCSTR mode)

    327. 

  327.         {

    328. 

  328.             char *filenameAscii=myWideCharToMultiByte(filename);

    329. 

  329.             FILE *f;

    330. 

  330.             if (mode[0]==_CXML('r')) f=fopen(filenameAscii,"rb");

    331. 

  331.             else                     f=fopen(filenameAscii,"wb");

    332. 

  332.             free(filenameAscii);

    333. 

  333.             return f;

    334. 

  334.         }

    335. 

  335.     #else

    336. 

  336.         static inline FILE *xfopen(XMLCSTR filename,XMLCSTR mode) { return fopen(filename,mode); }

    337. 

  337.         static inline int xstrlen(XMLCSTR c)   { return strlen(c); }

    338. 

  338.         static inline int xstrnicmp(XMLCSTR c1, XMLCSTR c2, int l) { return strncasecmp(c1,c2,l);}

    339. 

  339.         static inline int xstrncmp(XMLCSTR c1, XMLCSTR c2, int l) { return strncmp(c1,c2,l);}

    340. 

  340.         static inline int xstricmp(XMLCSTR c1, XMLCSTR c2) { return strcasecmp(c1,c2); }

    341. 

  341.         static inline XMLSTR xstrstr(XMLCSTR c1, XMLCSTR c2) { return (XMLSTR)strstr(c1,c2); }

    342. 

  342.         static inline XMLSTR xstrcpy(XMLSTR c1, XMLCSTR c2) { return (XMLSTR)strcpy(c1,c2); }

    343. 

  343.     #endif

    344. 

  344.     static inline int _strnicmp(const char *c1,const char *c2, int l) { return strncasecmp(c1,c2,l);}

    345. 

  345. #endif

    346. 

  346. 

    347. 

  347. 

    348. 

  348. ///////////////////////////////////////////////////////////////////////////////

    349. 

  349. //            the "xmltoc,xmltob,xmltoi,xmltol,xmltof,xmltoa" functions      //

    350. 

  350. ///////////////////////////////////////////////////////////////////////////////

    351. 

  351. // These 6 functions are not used inside the XMLparser.

    352. 

  352. // There are only here as "convenience" functions for the user.

    353. 

  353. // If you don't need them, you can delete them without any trouble.

    354. 

  354. #ifdef _XMLWIDECHAR

    355. 

  355.     #ifdef _XMLWINDOWS

    356. 

  356.     // for Microsoft Visual Studio 6.0 and Microsoft Visual Studio .NET and Borland C++ Builder 6.0

    357. 

  357.         char    xmltob(XMLCSTR t,int     v){ if (t&&(*t)) return (char)_wtoi(t); return v; }

    358. 

  358.         int     xmltoi(XMLCSTR t,int     v){ if (t&&(*t)) return _wtoi(t); return v; }

    359. 

  359.         long    xmltol(XMLCSTR t,long    v){ if (t&&(*t)) return _wtol(t); return v; }

    360. 

  360.         double  xmltof(XMLCSTR t,double  v){ if (t&&(*t)) wscanf(t, "%f", &v); /*v=_wtof(t);*/ return v; }

    361. 

  361.     #else

    362. 

  362.         #ifdef sun

    363. 

  363.         // for CC

    364. 

  364.            #include <widec.h>

    365. 

  365.            char    xmltob(XMLCSTR t,int     v){ if (t) return (char)wstol(t,NULL,10); return v; }

    366. 

  366.            int     xmltoi(XMLCSTR t,int     v){ if (t) return (int)wstol(t,NULL,10); return v; }

    367. 

  367.            long    xmltol(XMLCSTR t,long    v){ if (t) return wstol(t,NULL,10); return v; }

    368. 

  368.         #else

    369. 

  369.         // for gcc

    370. 

  370.            char    xmltob(XMLCSTR t,int     v){ if (t) return (char)wcstol(t,NULL,10); return v; }

    371. 

  371.            int     xmltoi(XMLCSTR t,int     v){ if (t) return (int)wcstol(t,NULL,10); return v; }

    372. 

  372.            long    xmltol(XMLCSTR t,long    v){ if (t) return wcstol(t,NULL,10); return v; }

    373. 

  373.         #endif

    374. 

  374. 		double  xmltof(XMLCSTR t,double  v){ if (t&&(*t)) wscanf(t, "%f", &v); /*v=_wtof(t);*/ return v; }

    375. 

  375.     #endif

    376. 

  376. #else

    377. 

  377.     char    xmltob(XMLCSTR t,char    v){ if (t&&(*t)) return (char)atoi(t); return v; }

    378. 

  378.     int     xmltoi(XMLCSTR t,int     v){ if (t&&(*t)) return atoi(t); return v; }

    379. 

  379.     long    xmltol(XMLCSTR t,long    v){ if (t&&(*t)) return atol(t); return v; }

    380. 

  380.     double  xmltof(XMLCSTR t,double  v){ if (t&&(*t)) return atof(t); return v; }

    381. 

  381. #endif

    382. 

  382. XMLCSTR xmltoa(XMLCSTR t,      XMLCSTR v){ if (t)       return  t; return v; }

    383. 

  383. XMLCHAR xmltoc(XMLCSTR t,const XMLCHAR v){ if (t&&(*t)) return *t; return v; }

    384. 

  384. 

    385. 

  385. /////////////////////////////////////////////////////////////////////////

    386. 

  386. //                    the "openFileHelper" function                    //

    387. 

  387. /////////////////////////////////////////////////////////////////////////

    388. 

  388. 

    389. 

  389. // Since each application has its own way to report and deal with errors, you should modify & rewrite

    390. 

  390. // the following "openFileHelper" function to get an "error reporting mechanism" tailored to your needs.

    391. 

  391. XMLNode XMLNode::openFileHelper(XMLCSTR filename, XMLCSTR tag)

    392. 

  392. {

    393. 

  393.     // guess the value of the global parameter "characterEncoding"

    394. 

  394.     // (the guess is based on the first 200 bytes of the file).

    395. 

  395.     FILE *f=xfopen(filename,_CXML("rb"));

    396. 

  396.     if (f)

    397. 

  397.     {

    398. 

  398.         char bb[205];

    399. 

  399.         int l=(int)fread(bb,1,200,f);

    400. 

  400.         setGlobalOptions(guessCharEncoding(bb,l),guessWideCharChars,dropWhiteSpace,removeCommentsInMiddleOfText);

    401. 

  401.         fclose(f);

    402. 

  402.     }

    403. 

  403. 

    404. 

  404.     // parse the file

    405. 

  405.     XMLResults pResults;

    406. 

  406.     XMLNode xnode=XMLNode::parseFile(filename,tag,&pResults);

    407. 

  407. 

    408. 

  408.     // display error message (if any)

    409. 

  409.     if (pResults.error != eXMLErrorNone)

    410. 

  410.     {

    411. 

  411.         // create message

    412. 

  412.         char message[2000],*s1=(char*)"",*s3=(char*)""; XMLCSTR s2=_CXML("");

    413. 

  413.         if (pResults.error==eXMLErrorFirstTagNotFound) { s1=(char*)"First Tag should be '"; s2=tag; s3=(char*)"'.\n"; }

    414. 

  414.         sprintf(message,

    415. 

  415. #ifdef _XMLWIDECHAR

    416. 

  416.             "XML Parsing error inside file '%S'.\n%S\nAt line %i, column %i.\n%s%S%s"

    417. 

  417. #else

    418. 

  418.             "XML Parsing error inside file '%s'.\n%s\nAt line %i, column %i.\n%s%s%s"

    419. 

  419. #endif

    420. 

  420.             ,filename,XMLNode::getError(pResults.error),pResults.nLine,pResults.nColumn,s1,s2,s3);

    421. 

  421. 

    422. 

  422.         // display message

    423. 

  423. #if defined(_XMLWINDOWS) && !defined(UNDER_CE) && !defined(_XMLPARSER_NO_MESSAGEBOX_)

    424. 

  424.         MessageBoxA(NULL,message,"XML Parsing error",MB_OK|MB_ICONERROR|MB_TOPMOST);

    425. 

  425. #else

    426. 

  426.         printf("%s",message);

    427. 

  427. #endif

    428. 

  428.         exit(255);

    429. 

  429.     }

    430. 

  430.     return xnode;

    431. 

  431. }

    432. 

  432. 

    433. 

  433. /////////////////////////////////////////////////////////////////////////

    434. 

  434. //      Here start the core implementation of the XMLParser library    //

    435. 

  435. /////////////////////////////////////////////////////////////////////////

    436. 

  436. 

    437. 

  437. // You should normally not change anything below this point.

    438. 

  438. 

    439. 

  439. #ifndef _XMLWIDECHAR

    440. 

  440. // If "characterEncoding=ascii" then we assume that all characters have the same length of 1 byte.

    441. 

  441. // If "characterEncoding=UTF8" then the characters have different lengths (from 1 byte to 4 bytes).

    442. 

  442. // If "characterEncoding=ShiftJIS" then the characters have different lengths (from 1 byte to 2 bytes).

    443. 

  443. // This table is used as lookup-table to know the length of a character (in byte) based on the

    444. 

  444. // content of the first byte of the character.

    445. 

  445. // (note: if you modify this, you must always have XML_utf8ByteTable[0]=0 ).

    446. 

  446. static const char XML_utf8ByteTable[256] =

    447. 

  447. {

    448. 

  448.     //  0 1 2 3 4 5 6 7 8 9 a b c d e f

    449. 

  449.     0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x00

    450. 

  450.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x10

    451. 

  451.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x20

    452. 

  452.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x30

    453. 

  453.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x40

    454. 

  454.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x50

    455. 

  455.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x60

    456. 

  456.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x70 End of ASCII range

    457. 

  457.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x80 0x80 to 0xc1 invalid

    458. 

  458.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x90

    459. 

  459.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0xa0

    460. 

  460.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0xb0

    461. 

  461.     1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xc0 0xc2 to 0xdf 2 byte

    462. 

  462.     2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xd0

    463. 

  463.     3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,// 0xe0 0xe0 to 0xef 3 byte

    464. 

  464.     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

    465. 

  465. };

    466. 

  466. static const char XML_legacyByteTable[256] =

    467. 

  467. {

    468. 

  468.     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,

    469. 

  469.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

    470. 

  470.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

    471. 

  471.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

    472. 

  472.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

    473. 

  473.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1

    474. 

  474. };

    475. 

  475. static const char XML_sjisByteTable[256] =

    476. 

  476. {

    477. 

  477.     //  0 1 2 3 4 5 6 7 8 9 a b c d e f

    478. 

  478.     0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x00

    479. 

  479.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x10

    480. 

  480.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x20

    481. 

  481.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x30

    482. 

  482.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x40

    483. 

  483.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x50

    484. 

  484.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x60

    485. 

  485.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x70

    486. 

  486.     1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0x80 0x81 to 0x9F 2 bytes

    487. 

  487.     2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0x90

    488. 

  488.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0xa0

    489. 

  489.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0xb0

    490. 

  490.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0xc0

    491. 

  491.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0xd0

    492. 

  492.     2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xe0 0xe0 to 0xef 2 bytes

    493. 

  493.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 // 0xf0

    494. 

  494. };

    495. 

  495. static const char XML_gb2312ByteTable[256] =

    496. 

  496. {

    497. 

  497. //  0 1 2 3 4 5 6 7 8 9 a b c d e f

    498. 

  498.     0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x00

    499. 

  499.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x10

    500. 

  500.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x20

    501. 

  501.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x30

    502. 

  502.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x40

    503. 

  503.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x50

    504. 

  504.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x60

    505. 

  505.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x70

    506. 

  506.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x80

    507. 

  507.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x90

    508. 

  508.     1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xa0 0xa1 to 0xf7 2 bytes

    509. 

  509.     2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xb0

    510. 

  510.     2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xc0

    511. 

  511.     2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xd0

    512. 

  512.     2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xe0

    513. 

  513.     2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1 // 0xf0

    514. 

  514. };

    515. 

  515. static const char XML_gbk_big5_ByteTable[256] =

    516. 

  516. {

    517. 

  517.     //  0 1 2 3 4 5 6 7 8 9 a b c d e f

    518. 

  518.     0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x00

    519. 

  519.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x10

    520. 

  520.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x20

    521. 

  521.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x30

    522. 

  522.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x40

    523. 

  523.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x50

    524. 

  524.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x60

    525. 

  525.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x70

    526. 

  526.     1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0x80 0x81 to 0xfe 2 bytes

    527. 

  527.     2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0x90

    528. 

  528.     2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xa0

    529. 

  529.     2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xb0

    530. 

  530.     2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xc0

    531. 

  531.     2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xd0

    532. 

  532.     2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xe0

    533. 

  533.     2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1 // 0xf0

    534. 

  534. };

    535. 

  535. static const char *XML_ByteTable=(const char *)XML_utf8ByteTable; // the default is "characterEncoding=XMLNode::encoding_UTF8"

    536. 

  536. #endif

    537. 

  537. 

    538. 

  538. 

    539. 

  539. XMLNode XMLNode::emptyXMLNode;

    540. 

  540. XMLClear XMLNode::emptyXMLClear={ NULL, NULL, NULL};

    541. 

  541. XMLAttribute XMLNode::emptyXMLAttribute={ NULL, NULL};

    542. 

  542. 

    543. 

  543. // Enumeration used to decipher what type a token is

    544. 

  544. typedef enum XMLTokenTypeTag

    545. 

  545. {

    546. 

  546.     eTokenText = 0,

    547. 

  547.     eTokenQuotedText,

    548. 

  548.     eTokenTagStart,         /* "<"            */

    549. 

  549.     eTokenTagEnd,           /* "</"           */

    550. 

  550.     eTokenCloseTag,         /* ">"            */

    551. 

  551.     eTokenEquals,           /* "="            */

    552. 

  552.     eTokenDeclaration,      /* "<?"           */

    553. 

  553.     eTokenShortHandClose,   /* "/>"           */

    554. 

  554.     eTokenClear,

    555. 

  555.     eTokenError

    556. 

  556. } XMLTokenType;

    557. 

  557. 

    558. 

  558. // Main structure used for parsing XML

    559. 

  559. typedef struct XML

    560. 

  560. {

    561. 

  561.     XMLCSTR                lpXML;

    562. 

  562.     XMLCSTR                lpszText;

    563. 

  563.     int                    nIndex,nIndexMissigEndTag;

    564. 

  564.     enum XMLError          error;

    565. 

  565.     XMLCSTR                lpEndTag;

    566. 

  566.     int                    cbEndTag;

    567. 

  567.     XMLCSTR                lpNewElement;

    568. 

  568.     int                    cbNewElement;

    569. 

  569.     int                    nFirst;

    570. 

  570. } XML;

    571. 

  571. 

    572. 

  572. typedef struct

    573. 

  573. {

    574. 

  574.     ALLXMLClearTag *pClr;

    575. 

  575.     XMLCSTR     pStr;

    576. 

  576. } NextToken;

    577. 

  577. 

    578. 

  578. // Enumeration used when parsing attributes

    579. 

  579. typedef enum Attrib

    580. 

  580. {

    581. 

  581.     eAttribName = 0,

    582. 

  582.     eAttribEquals,

    583. 

  583.     eAttribValue

    584. 

  584. } Attrib;

    585. 

  585. 

    586. 

  586. // Enumeration used when parsing elements to dictate whether we are currently

    587. 

  587. // inside a tag

    588. 

  588. typedef enum Status

    589. 

  589. {

    590. 

  590.     eInsideTag = 0,

    591. 

  591.     eOutsideTag

    592. 

  592. } Status;

    593. 

  593. 

    594. 

  594. XMLError XMLNode::writeToFile(XMLCSTR filename, const char *encoding, char nFormat) const

    595. 

  595. {

    596. 

  596.     if (!d) return eXMLErrorNone;

    597. 

  597.     FILE *f=xfopen(filename,_CXML("wb"));

    598. 

  598.     if (!f) return eXMLErrorCannotOpenWriteFile;

    599. 

  599. #ifdef _XMLWIDECHAR

    600. 

  600.     unsigned char h[2]={ 0xFF, 0xFE };

    601. 

  601.     if (!fwrite(h,2,1,f)) return eXMLErrorCannotWriteFile;

    602. 

  602.     if ((!isDeclaration())&&((d->lpszName)||(!getChildNode().isDeclaration())))

    603. 

  603.     {

    604. 

  604.         if (!fwrite(L"<?xml version=\"1.0\" encoding=\"utf-16\"?>\n",sizeof(wchar_t)*40,1,f))

    605. 

  605.             return eXMLErrorCannotWriteFile;

    606. 

  606.     }

    607. 

  607. #else

    608. 

  608.     if ((!isDeclaration())&&((d->lpszName)||(!getChildNode().isDeclaration())))

    609. 

  609.     {

    610. 

  610.         if (characterEncoding==char_encoding_UTF8)

    611. 

  611.         {

    612. 

  612.             // header so that windows recognize the file as UTF-8:

    613. 

  613.             unsigned char h[3]={0xEF,0xBB,0xBF}; if (!fwrite(h,3,1,f)) return eXMLErrorCannotWriteFile;

    614. 

  614.             encoding="utf-8";

    615. 

  615.         } else if (characterEncoding==char_encoding_ShiftJIS) encoding="SHIFT-JIS";

    616. 

  616. 

    617. 

  617.         if (!encoding) encoding="ISO-8859-1";

    618. 

  618.         if (fprintf(f,"<?xml version=\"1.0\" encoding=\"%s\"?>\n",encoding)<0) return eXMLErrorCannotWriteFile;

    619. 

  619.     } else

    620. 

  620.     {

    621. 

  621.         if (characterEncoding==char_encoding_UTF8)

    622. 

  622.         {

    623. 

  623.             unsigned char h[3]={0xEF,0xBB,0xBF}; if (!fwrite(h,3,1,f)) return eXMLErrorCannotWriteFile;

    624. 

  624.         }

    625. 

  625.     }

    626. 

  626. #endif

    627. 

  627.     int i;

    628. 

  628.     XMLSTR t=createXMLString(nFormat,&i);

    629. 

  629.     if (!fwrite(t,sizeof(XMLCHAR)*i,1,f)) return eXMLErrorCannotWriteFile;

    630. 

  630.     if (fclose(f)!=0) return eXMLErrorCannotWriteFile;

    631. 

  631.     free(t);

    632. 

  632.     return eXMLErrorNone;

    633. 

  633. }

    634. 

  634. 

    635. 

  635. // Duplicate a given string.

    636. 

  636. XMLSTR stringDup(XMLCSTR lpszData, int cbData)

    637. 

  637. {

    638. 

  638.     if (lpszData==NULL) return NULL;

    639. 

  639. 

    640. 

  640.     XMLSTR lpszNew;

    641. 

  641.     if (cbData==-1) cbData=(int)xstrlen(lpszData);

    642. 

  642.     lpszNew = (XMLSTR)malloc((cbData+1) * sizeof(XMLCHAR));

    643. 

  643.     if (lpszNew)

    644. 

  644.     {

    645. 

  645.         memcpy(lpszNew, lpszData, (cbData) * sizeof(XMLCHAR));

    646. 

  646.         lpszNew[cbData] = (XMLCHAR)NULL;

    647. 

  647.     }

    648. 

  648.     return lpszNew;

    649. 

  649. }

    650. 

  650. 

    651. 

  651. XMLSTR ToXMLStringTool::toXMLUnSafe(XMLSTR dest,XMLCSTR source)

    652. 

  652. {

    653. 

  653.     XMLSTR dd=dest;

    654. 

  654.     XMLCHAR ch;

    655. 

  655.     XMLCharacterEntity *entity;

    656. 

  656.     while ((ch=*source))

    657. 

  657.     {

    658. 

  658.         entity=XMLEntities;

    659. 

  659.         do

    660. 

  660.         {

    661. 

  661.             if (ch==entity->c) {xstrcpy(dest,entity->s); dest+=entity->l; source++; goto out_of_loop1; }

    662. 

  662.             entity++;

    663. 

  663.         } while(entity->s);

    664. 

  664. #ifdef _XMLWIDECHAR

    665. 

  665.         *(dest++)=*(source++);

    666. 

  666. #else

    667. 

  667.         switch(XML_ByteTable[(unsigned char)ch])

    668. 

  668.         {

    669. 

  669.         case 4: *(dest++)=*(source++);

    670. 

  670.         case 3: *(dest++)=*(source++);

    671. 

  671.         case 2: *(dest++)=*(source++);

    672. 

  672.         case 1: *(dest++)=*(source++);

    673. 

  673.         }

    674. 

  674. #endif

    675. 

  675. out_of_loop1:

    676. 

  676.         ;

    677. 

  677.     }

    678. 

  678.     *dest=0;

    679. 

  679.     return dd;

    680. 

  680. }

    681. 

  681. 

    682. 

  682. // private (used while rendering):

    683. 

  683. int ToXMLStringTool::lengthXMLString(XMLCSTR source)

    684. 

  684. {

    685. 

  685.     int r=0;

    686. 

  686.     XMLCharacterEntity *entity;

    687. 

  687.     XMLCHAR ch;

    688. 

  688.     while ((ch=*source))

    689. 

  689.     {

    690. 

  690.         entity=XMLEntities;

    691. 

  691.         do

    692. 

  692.         {

    693. 

  693.             if (ch==entity->c) { r+=entity->l; source++; goto out_of_loop1; }

    694. 

  694.             entity++;

    695. 

  695.         } while(entity->s);

    696. 

  696. #ifdef _XMLWIDECHAR

    697. 

  697.         r++; source++;

    698. 

  698. #else

    699. 

  699.         ch=XML_ByteTable[(unsigned char)ch]; r+=ch; source+=ch;

    700. 

  700. #endif

    701. 

  701. out_of_loop1:

    702. 

  702.         ;

    703. 

  703.     }

    704. 

  704.     return r;

    705. 

  705. }

    706. 

  706. 

    707. 

  707. ToXMLStringTool::~ToXMLStringTool(){ freeBuffer(); }

    708. 

  708. void ToXMLStringTool::freeBuffer(){ if (buf) free(buf); buf=NULL; buflen=0; }

    709. 

  709. XMLSTR ToXMLStringTool::toXML(XMLCSTR source)

    710. 

  710. {

    711. 

  711.     if (!source) return _CXML("");

    712. 

  712.     int l=lengthXMLString(source)+1;

    713. 

  713.     if (l>buflen) { buflen=l; buf=(XMLSTR)realloc(buf,l*sizeof(XMLCHAR)); }

    714. 

  714.     return toXMLUnSafe(buf,source);

    715. 

  715. }

    716. 

  716. 

    717. 

  717. // private:

    718. 

  718. XMLSTR fromXMLString(XMLCSTR s, int lo, XML *pXML)

    719. 

  719. {

    720. 

  720.     // This function is the opposite of the function "toXMLString". It decodes the escape

    721. 

  721.     // sequences &amp;, &quot;, &apos;, &lt;, &gt; and replace them by the characters

    722. 

  722.     // &,",',<,>. This function is used internally by the XML Parser. All the calls to

    723. 

  723.     // the XML library will always gives you back "decoded" strings.

    724. 

  724.     //

    725. 

  725.     // in: string (s) and length (lo) of string

    726. 

  726.     // out:  new allocated string converted from xml

    727. 

  727.     if (!s) return NULL;

    728. 

  728. 

    729. 

  729.     int ll=0,j;

    730. 

  730.     XMLSTR d;

    731. 

  731.     XMLCSTR ss=s;

    732. 

  732.     XMLCharacterEntity *entity;

    733. 

  733.     while ((lo>0)&&(*s))

    734. 

  734.     {

    735. 

  735.         if (*s==_CXML('&'))

    736. 

  736.         {

    737. 

  737.             if ((lo>2)&&(s[1]==_CXML('#')))

    738. 

  738.             {

    739. 

  739.                 s+=2; lo-=2;

    740. 

  740.                 if ((*s==_CXML('X'))||(*s==_CXML('x'))) { s++; lo--; }

    741. 

  741.                 while ((*s)&&(*s!=_CXML(';'))&&((lo--)>0)) s++;

    742. 

  742.                 if (*s!=_CXML(';'))

    743. 

  743.                 {

    744. 

  744.                     pXML->error=eXMLErrorUnknownCharacterEntity;

    745. 

  745.                     return NULL;

    746. 

  746.                 }

    747. 

  747.                 s++; lo--;

    748. 

  748.             } else

    749. 

  749.             {

    750. 

  750.                 entity=XMLEntities;

    751. 

  751.                 do

    752. 

  752.                 {

    753. 

  753.                     if ((lo>=entity->l)&&(xstrnicmp(s,entity->s,entity->l)==0)) { s+=entity->l; lo-=entity->l; break; }

    754. 

  754.                     entity++;

    755. 

  755.                 } while(entity->s);

    756. 

  756.                 if (!entity->s)

    757. 

  757.                 {

    758. 

  758.                     pXML->error=eXMLErrorUnknownCharacterEntity;

    759. 

  759.                     return NULL;

    760. 

  760.                 }

    761. 

  761.             }

    762. 

  762.         } else

    763. 

  763.         {

    764. 

  764. #ifdef _XMLWIDECHAR

    765. 

  765.             s++; lo--;

    766. 

  766. #else

    767. 

  767.             j=XML_ByteTable[(unsigned char)*s]; s+=j; lo-=j; ll+=j-1;

    768. 

  768. #endif

    769. 

  769.         }

    770. 

  770.         ll++;

    771. 

  771.     }

    772. 

  772. 

    773. 

  773.     d=(XMLSTR)malloc((ll+1)*sizeof(XMLCHAR));

    774. 

  774.     s=d;

    775. 

  775.     while (ll-->0)

    776. 

  776.     {

    777. 

  777.         if (*ss==_CXML('&'))

    778. 

  778.         {

    779. 

  779.             if (ss[1]==_CXML('#'))

    780. 

  780.             {

    781. 

  781.                 ss+=2; j=0;

    782. 

  782.                 if ((*ss==_CXML('X'))||(*ss==_CXML('x')))

    783. 

  783.                 {

    784. 

  784.                     ss++;

    785. 

  785.                     while (*ss!=_CXML(';'))

    786. 

  786.                     {

    787. 

  787.                         if ((*ss>=_CXML('0'))&&(*ss<=_CXML('9'))) j=(j<<4)+*ss-_CXML('0');

    788. 

  788.                         else if ((*ss>=_CXML('A'))&&(*ss<=_CXML('F'))) j=(j<<4)+*ss-_CXML('A')+10;

    789. 

  789.                         else if ((*ss>=_CXML('a'))&&(*ss<=_CXML('f'))) j=(j<<4)+*ss-_CXML('a')+10;

    790. 

  790.                         else { free((void*)s); pXML->error=eXMLErrorUnknownCharacterEntity;return NULL;}

    791. 

  791.                         ss++;

    792. 

  792.                     }

    793. 

  793.                 } else

    794. 

  794.                 {

    795. 

  795.                     while (*ss!=_CXML(';'))

    796. 

  796.                     {

    797. 

  797.                         if ((*ss>=_CXML('0'))&&(*ss<=_CXML('9'))) j=(j*10)+*ss-_CXML('0');

    798. 

  798.                         else { free((void*)s); pXML->error=eXMLErrorUnknownCharacterEntity;return NULL;}

    799. 

  799.                         ss++;

    800. 

  800.                     }

    801. 

  801.                 }

    802. 

  802. #ifndef _XMLWIDECHAR

    803. 

  803.                 if (j>255) { free((void*)s); pXML->error=eXMLErrorCharacterCodeAbove255;return NULL;}

    804. 

  804. #endif

    805. 

  805.                 (*d++)=(XMLCHAR)j; ss++;

    806. 

  806.             } else

    807. 

  807.             {

    808. 

  808.                 entity=XMLEntities;

    809. 

  809.                 do

    810. 

  810.                 {

    811. 

  811.                     if (xstrnicmp(ss,entity->s,entity->l)==0) { *(d++)=entity->c; ss+=entity->l; break; }

    812. 

  812.                     entity++;

    813. 

  813.                 } while(entity->s);

    814. 

  814.             }

    815. 

  815.         } else

    816. 

  816.         {

    817. 

  817. #ifdef _XMLWIDECHAR

    818. 

  818.             *(d++)=*(ss++);

    819. 

  819. #else

    820. 

  820.             switch(XML_ByteTable[(unsigned char)*ss])

    821. 

  821.             {

    822. 

  822.             case 4: *(d++)=*(ss++); ll--;

    823. 

  823.             case 3: *(d++)=*(ss++); ll--;

    824. 

  824.             case 2: *(d++)=*(ss++); ll--;

    825. 

  825.             case 1: *(d++)=*(ss++);

    826. 

  826.             }

    827. 

  827. #endif

    828. 

  828.         }

    829. 

  829.     }

    830. 

  830.     *d=0;

    831. 

  831.     return (XMLSTR)s;

    832. 

  832. }

    833. 

  833. 

    834. 

  834. #define XML_isSPACECHAR(ch) ((ch==_CXML('\n'))||(ch==_CXML(' '))||(ch== _CXML('\t'))||(ch==_CXML('\r')))

    835. 

  835. 

    836. 

  836. // private:

    837. 

  837. char myTagCompare(XMLCSTR cclose, XMLCSTR copen)

    838. 

  838. // !!!! WARNING strange convention&:

    839. 

  839. // return 0 if equals

    840. 

  840. // return 1 if different

    841. 

  841. {

    842. 

  842.     if (!cclose) return 1;

    843. 

  843.     int l=(int)xstrlen(cclose);

    844. 

  844.     if (xstrnicmp(cclose, copen, l)!=0) return 1;

    845. 

  845.     const XMLCHAR c=copen[l];

    846. 

  846.     if (XML_isSPACECHAR(c)||

    847. 

  847.         (c==_CXML('/' ))||

    848. 

  848.         (c==_CXML('<' ))||

    849. 

  849.         (c==_CXML('>' ))||

    850. 

  850.         (c==_CXML('=' ))) return 0;

    851. 

  851.     return 1;

    852. 

  852. }

    853. 

  853. 

    854. 

  854. // Obtain the next character from the string.

    855. 

  855. static inline XMLCHAR getNextChar(XML *pXML)

    856. 

  856. {

    857. 

  857.     XMLCHAR ch = pXML->lpXML[pXML->nIndex];

    858. 

  858. #ifdef _XMLWIDECHAR

    859. 

  859.     if (ch!=0) pXML->nIndex++;

    860. 

  860. #else

    861. 

  861.     pXML->nIndex+=XML_ByteTable[(unsigned char)ch];

    862. 

  862. #endif

    863. 

  863.     return ch;

    864. 

  864. }

    865. 

  865. 

    866. 

  866. // Find the next token in a string.

    867. 

  867. // pcbToken contains the number of characters that have been read.

    868. 

  868. static NextToken GetNextToken(XML *pXML, int *pcbToken, enum XMLTokenTypeTag *pType)

    869. 

  869. {

    870. 

  870.     NextToken        result;

    871. 

  871.     XMLCHAR            ch;

    872. 

  872.     XMLCHAR            chTemp;

    873. 

  873.     int              indexStart,nFoundMatch,nIsText=FALSE;

    874. 

  874.     result.pClr=NULL; // prevent warning

    875. 

  875. 

    876. 

  876.     // Find next non-white space character

    877. 

  877.     do { indexStart=pXML->nIndex; ch=getNextChar(pXML); } while XML_isSPACECHAR(ch);

    878. 

  878. 

    879. 

  879.     if (ch)

    880. 

  880.     {

    881. 

  881.         // Cache the current string pointer

    882. 

  882.         result.pStr = &pXML->lpXML[indexStart];

    883. 

  883. 

    884. 

  884.         // First check whether the token is in the clear tag list (meaning it

    885. 

  885.         // does not need formatting).

    886. 

  886.         ALLXMLClearTag *ctag=XMLClearTags;

    887. 

  887.         do

    888. 

  888.         {

    889. 

  889.             if (xstrncmp(ctag->lpszOpen, result.pStr, ctag->openTagLen)==0)

    890. 

  890.             {

    891. 

  891.                 result.pClr=ctag;

    892. 

  892.                 pXML->nIndex+=ctag->openTagLen-1;

    893. 

  893.                 *pType=eTokenClear;

    894. 

  894.                 return result;

    895. 

  895.             }

    896. 

  896.             ctag++;

    897. 

  897.         } while(ctag->lpszOpen);

    898. 

  898. 

    899. 

  899.         // If we didn't find a clear tag then check for standard tokens

    900. 

  900.         switch(ch)

    901. 

  901.         {

    902. 

  902.         // Check for quotes

    903. 

  903.         case _CXML('\''):

    904. 

  904.         case _CXML('\"'):

    905. 

  905.             // Type of token

    906. 

  906.             *pType = eTokenQuotedText;

    907. 

  907.             chTemp = ch;

    908. 

  908. 

    909. 

  909.             // Set the size

    910. 

  910.             nFoundMatch = FALSE;

    911. 

  911. 

    912. 

  912.             // Search through the string to find a matching quote

    913. 

  913.             while((ch = getNextChar(pXML)))

    914. 

  914.             {

    915. 

  915.                 if (ch==chTemp) { nFoundMatch = TRUE; break; }

    916. 

  916.                 if (ch==_CXML('<')) break;

    917. 

  917.             }

    918. 

  918. 

    919. 

  919.             // If we failed to find a matching quote

    920. 

  920.             if (nFoundMatch == FALSE)

    921. 

  921.             {

    922. 

  922.                 pXML->nIndex=indexStart+1;

    923. 

  923.                 nIsText=TRUE;

    924. 

  924.                 break;

    925. 

  925.             }

    926. 

  926. 

    927. 

  927. //  4.02.2002

    928. 

  928. //            if (FindNonWhiteSpace(pXML)) pXML->nIndex--;

    929. 

  929. 

    930. 

  930.             break;

    931. 

  931. 

    932. 

  932.         // Equals (used with attribute values)

    933. 

  933.         case _CXML('='):

    934. 

  934.             *pType = eTokenEquals;

    935. 

  935.             break;

    936. 

  936. 

    937. 

  937.         // Close tag

    938. 

  938.         case _CXML('>'):

    939. 

  939.             *pType = eTokenCloseTag;

    940. 

  940.             break;

    941. 

  941. 

    942. 

  942.         // Check for tag start and tag end

    943. 

  943.         case _CXML('<'):

    944. 

  944. 

    945. 

  945.             // Peek at the next character to see if we have an end tag '</',

    946. 

  946.             // or an xml declaration '<?'

    947. 

  947.             chTemp = pXML->lpXML[pXML->nIndex];

    948. 

  948. 

    949. 

  949.             // If we have a tag end...

    950. 

  950.             if (chTemp == _CXML('/'))

    951. 

  951.             {

    952. 

  952.                 // Set the type and ensure we point at the next character

    953. 

  953.                 getNextChar(pXML);

    954. 

  954.                 *pType = eTokenTagEnd;

    955. 

  955.             }

    956. 

  956. 

    957. 

  957.             // If we have an XML declaration tag

    958. 

  958.             else if (chTemp == _CXML('?'))

    959. 

  959.             {

    960. 

  960. 

    961. 

  961.                 // Set the type and ensure we point at the next character

    962. 

  962.                 getNextChar(pXML);

    963. 

  963.                 *pType = eTokenDeclaration;

    964. 

  964.             }

    965. 

  965. 

    966. 

  966.             // Otherwise we must have a start tag

    967. 

  967.             else

    968. 

  968.             {

    969. 

  969.                 *pType = eTokenTagStart;

    970. 

  970.             }

    971. 

  971.             break;

    972. 

  972. 

    973. 

  973.         // Check to see if we have a short hand type end tag ('/>').

    974. 

  974.         case _CXML('/'):

    975. 

  975. 

    976. 

  976.             // Peek at the next character to see if we have a short end tag '/>'

    977. 

  977.             chTemp = pXML->lpXML[pXML->nIndex];

    978. 

  978. 

    979. 

  979.             // If we have a short hand end tag...

    980. 

  980.             if (chTemp == _CXML('>'))

    981. 

  981.             {

    982. 

  982.                 // Set the type and ensure we point at the next character

    983. 

  983.                 getNextChar(pXML);

    984. 

  984.                 *pType = eTokenShortHandClose;

    985. 

  985.                 break;

    986. 

  986.             }

    987. 

  987. 

    988. 

  988.             // If we haven't found a short hand closing tag then drop into the

    989. 

  989.             // text process

    990. 

  990. 

    991. 

  991.         // Other characters

    992. 

  992.         default:

    993. 

  993.             nIsText = TRUE;

    994. 

  994.         }

    995. 

  995. 

    996. 

  996.         // If this is a TEXT node

    997. 

  997.         if (nIsText)

    998. 

  998.         {

    999. 

  999.             // Indicate we are dealing with text

    1000. 

  1000.             *pType = eTokenText;

    1001. 

  1001.             while((ch = getNextChar(pXML)))

    1002. 

  1002.             {

    1003. 

  1003.                 if XML_isSPACECHAR(ch)

    1004. 

  1004.                 {

    1005. 

  1005.                     indexStart++; break;

    1006. 

  1006. 

    1007. 

  1007.                 } else if (ch==_CXML('/'))

    1008. 

  1008.                 {

    1009. 

  1009.                     // If we find a slash then this maybe text or a short hand end tag

    1010. 

  1010.                     // Peek at the next character to see it we have short hand end tag

    1011. 

  1011.                     ch=pXML->lpXML[pXML->nIndex];

    1012. 

  1012.                     // If we found a short hand end tag then we need to exit the loop

    1013. 

  1013.                     if (ch==_CXML('>')) { pXML->nIndex--; break; }

    1014. 

  1014. 

    1015. 

  1015.                 } else if ((ch==_CXML('<'))||(ch==_CXML('>'))||(ch==_CXML('=')))

    1016. 

  1016.                 {

    1017. 

  1017.                     pXML->nIndex--; break;

    1018. 

  1018.                 }

    1019. 

  1019.             }

    1020. 

  1020.         }

    1021. 

  1021.         *pcbToken = pXML->nIndex-indexStart;

    1022. 

  1022.     } else

    1023. 

  1023.     {

    1024. 

  1024.         // If we failed to obtain a valid character

    1025. 

  1025.         *pcbToken = 0;

    1026. 

  1026.         *pType = eTokenError;

    1027. 

  1027.         result.pStr=NULL;

    1028. 

  1028.     }

    1029. 

  1029. 

    1030. 

  1030.     return result;

    1031. 

  1031. }

    1032. 

  1032. 

    1033. 

  1033. XMLCSTR XMLNode::updateName_WOSD(XMLSTR lpszName)

    1034. 

  1034. {

    1035. 

  1035.     if (!d) { free(lpszName); return NULL; }

    1036. 

  1036.     if (d->lpszName&&(lpszName!=d->lpszName)) free((void*)d->lpszName);

    1037. 

  1037.     d->lpszName=lpszName;

    1038. 

  1038.     return lpszName;

    1039. 

  1039. }

    1040. 

  1040. 

    1041. 

  1041. // private:

    1042. 

  1042. XMLNode::XMLNode(struct XMLNodeDataTag *p){ d=p; (p->ref_count)++; }

    1043. 

  1043. XMLNode::XMLNode(XMLNodeData *pParent, XMLSTR lpszName, char isDeclaration)

    1044. 

  1044. {

    1045. 

  1045.     d=(XMLNodeData*)malloc(sizeof(XMLNodeData));

    1046. 

  1046.     d->ref_count=1;

    1047. 

  1047. 

    1048. 

  1048.     d->lpszName=NULL;

    1049. 

  1049.     d->nChild= 0;

    1050. 

  1050.     d->nText = 0;

    1051. 

  1051.     d->nClear = 0;

    1052. 

  1052.     d->nAttribute = 0;

    1053. 

  1053. 

    1054. 

  1054.     d->isDeclaration = isDeclaration;

    1055. 

  1055. 

    1056. 

  1056.     d->pParent = pParent;

    1057. 

  1057.     d->pChild= NULL;

    1058. 

  1058.     d->pText= NULL;

    1059. 

  1059.     d->pClear= NULL;

    1060. 

  1060.     d->pAttribute= NULL;

    1061. 

  1061.     d->pOrder= NULL;

    1062. 

  1062. 

    1063. 

  1063.     updateName_WOSD(lpszName);

    1064. 

  1064. }

    1065. 

  1065. 

    1066. 

  1066. XMLNode XMLNode::createXMLTopNode_WOSD(XMLSTR lpszName, char isDeclaration) { return XMLNode(NULL,lpszName,isDeclaration); }

    1067. 

  1067. XMLNode XMLNode::createXMLTopNode(XMLCSTR lpszName, char isDeclaration) { return XMLNode(NULL,stringDup(lpszName),isDeclaration); }

    1068. 

  1068. 

    1069. 

  1069. #define MEMORYINCREASE 50

    1070. 

  1070. 

    1071. 

  1071. static inline void myFree(void *p) { if (p) free(p); }

    1072. 

  1072. static inline void *myRealloc(void *p, int newsize, int memInc, int sizeofElem)

    1073. 

  1073. {

    1074. 

  1074.     if (p==NULL) { if (memInc) return malloc(memInc*sizeofElem); return malloc(sizeofElem); }

    1075. 

  1075.     if ((memInc==0)||((newsize%memInc)==0)) p=realloc(p,(newsize+memInc)*sizeofElem);

    1076. 

  1076. //    if (!p)

    1077. 

  1077. //    {

    1078. 

  1078. //        printf("XMLParser Error: Not enough memory! Aborting...\n"); exit(220);

    1079. 

  1079. //    }

    1080. 

  1080.     return p;

    1081. 

  1081. }

    1082. 

  1082. 

    1083. 

  1083. // private:

    1084. 

  1084. XMLElementPosition XMLNode::findPosition(XMLNodeData *d, int index, XMLElementType xxtype)

    1085. 

  1085. {

    1086. 

  1086.     if (index<0) return -1;

    1087. 

  1087.     int i=0,j=(int)((index<<2)+xxtype),*o=d->pOrder; while (o[i]!=j) i++; return i;

    1088. 

  1088. }

    1089. 

  1089. 

    1090. 

  1090. // private:

    1091. 

  1091. // update "order" information when deleting a content of a XMLNode

    1092. 

  1092. int XMLNode::removeOrderElement(XMLNodeData *d, XMLElementType t, int index)

    1093. 

  1093. {

    1094. 

  1094.     int n=d->nChild+d->nText+d->nClear, *o=d->pOrder,i=findPosition(d,index,t);

    1095. 

  1095.     memmove(o+i, o+i+1, (n-i)*sizeof(int));

    1096. 

  1096.     for (;i<n;i++)

    1097. 

  1097.         if ((o[i]&3)==(int)t) o[i]-=4;

    1098. 

  1098.     // We should normally do:

    1099. 

  1099.     // d->pOrder=(int)realloc(d->pOrder,n*sizeof(int));

    1100. 

  1100.     // but we skip reallocation because it's too time consuming.

    1101. 

  1101.     // Anyway, at the end, it will be free'd completely at once.

    1102. 

  1102.     return i;

    1103. 

  1103. }

    1104. 

  1104. 

    1105. 

  1105. void *XMLNode::addToOrder(int memoryIncrease,int *_pos, int nc, void *p, int size, XMLElementType xtype)

    1106. 

  1106. {

    1107. 

  1107.     //  in: *_pos is the position inside d->pOrder ("-1" means "EndOf")

    1108. 

  1108.     // out: *_pos is the index inside p

    1109. 

  1109.     p=myRealloc(p,(nc+1),memoryIncrease,size);

    1110. 

  1110.     int n=d->nChild+d->nText+d->nClear;

    1111. 

  1111.     d->pOrder=(int*)myRealloc(d->pOrder,n+1,memoryIncrease*3,sizeof(int));

    1112. 

  1112.     int pos=*_pos,*o=d->pOrder;

    1113. 

  1113. 

    1114. 

  1114.     if ((pos<0)||(pos>=n)) { *_pos=nc; o[n]=(int)((nc<<2)+xtype); return p; }

    1115. 

  1115. 

    1116. 

  1116.     int i=pos;

    1117. 

  1117.     memmove(o+i+1, o+i, (n-i)*sizeof(int));

    1118. 

  1118. 

    1119. 

  1119.     while ((pos<n)&&((o[pos]&3)!=(int)xtype)) pos++;

    1120. 

  1120.     if (pos==n) { *_pos=nc; o[n]=(int)((nc<<2)+xtype); return p; }

    1121. 

  1121. 

    1122. 

  1122.     o[i]=o[pos];

    1123. 

  1123.     for (i=pos+1;i<=n;i++) if ((o[i]&3)==(int)xtype) o[i]+=4;

    1124. 

  1124. 

    1125. 

  1125.     *_pos=pos=o[pos]>>2;

    1126. 

  1126.     memmove(((char*)p)+(pos+1)*size,((char*)p)+pos*size,(nc-pos)*size);

    1127. 

  1127. 

    1128. 

  1128.     return p;

    1129. 

  1129. }

    1130. 

  1130. 

    1131. 

  1131. // Add a child node to the given element.

    1132. 

  1132. XMLNode XMLNode::addChild_priv(int memoryIncrease, XMLSTR lpszName, char isDeclaration, int pos)

    1133. 

  1133. {

    1134. 

  1134.     if (!lpszName) return emptyXMLNode;

    1135. 

  1135.     d->pChild=(XMLNode*)addToOrder(memoryIncrease,&pos,d->nChild,d->pChild,sizeof(XMLNode),eNodeChild);

    1136. 

  1136.     d->pChild[pos].d=NULL;

    1137. 

  1137.     d->pChild[pos]=XMLNode(d,lpszName,isDeclaration);

    1138. 

  1138.     d->nChild++;

    1139. 

  1139.     return d->pChild[pos];

    1140. 

  1140. }

    1141. 

  1141. 

    1142. 

  1142. // Add an attribute to an element.

    1143. 

  1143. XMLAttribute *XMLNode::addAttribute_priv(int memoryIncrease,XMLSTR lpszName, XMLSTR lpszValuev)

    1144. 

  1144. {

    1145. 

  1145.     if (!lpszName) return &emptyXMLAttribute;

    1146. 

  1146.     if (!d) { myFree(lpszName); myFree(lpszValuev); return &emptyXMLAttribute; }

    1147. 

  1147.     int nc=d->nAttribute;

    1148. 

  1148.     d->pAttribute=(XMLAttribute*)myRealloc(d->pAttribute,(nc+1),memoryIncrease,sizeof(XMLAttribute));

    1149. 

  1149.     XMLAttribute *pAttr=d->pAttribute+nc;

    1150. 

  1150.     pAttr->lpszName = lpszName;

    1151. 

  1151.     pAttr->lpszValue = lpszValuev;

    1152. 

  1152.     d->nAttribute++;

    1153. 

  1153.     return pAttr;

    1154. 

  1154. }

    1155. 

  1155. 

    1156. 

  1156. // Add text to the element.

    1157. 

  1157. XMLCSTR XMLNode::addText_priv(int memoryIncrease, XMLSTR lpszValue, int pos)

    1158. 

  1158. {

    1159. 

  1159.     if (!lpszValue) return NULL;

    1160. 

  1160.     if (!d) { myFree(lpszValue); return NULL; }

    1161. 

  1161.     d->pText=(XMLCSTR*)addToOrder(memoryIncrease,&pos,d->nText,d->pText,sizeof(XMLSTR),eNodeText);

    1162. 

  1162.     d->pText[pos]=lpszValue;

    1163. 

  1163.     d->nText++;

    1164. 

  1164.     return lpszValue;

    1165. 

  1165. }

    1166. 

  1166. 

    1167. 

  1167. // Add clear (unformatted) text to the element.

    1168. 

  1168. XMLClear *XMLNode::addClear_priv(int memoryIncrease, XMLSTR lpszValue, XMLCSTR lpszOpen, XMLCSTR lpszClose, int pos)

    1169. 

  1169. {

    1170. 

  1170.     if (!lpszValue) return &emptyXMLClear;

    1171. 

  1171.     if (!d) { myFree(lpszValue); return &emptyXMLClear; }

    1172. 

  1172.     d->pClear=(XMLClear *)addToOrder(memoryIncrease,&pos,d->nClear,d->pClear,sizeof(XMLClear),eNodeClear);

    1173. 

  1173.     XMLClear *pNewClear=d->pClear+pos;

    1174. 

  1174.     pNewClear->lpszValue = lpszValue;

    1175. 

  1175.     if (!lpszOpen) lpszOpen=XMLClearTags->lpszOpen;

    1176. 

  1176.     if (!lpszClose) lpszClose=XMLClearTags->lpszClose;

    1177. 

  1177.     pNewClear->lpszOpenTag = lpszOpen;

    1178. 

  1178.     pNewClear->lpszCloseTag = lpszClose;

    1179. 

  1179.     d->nClear++;

    1180. 

  1180.     return pNewClear;

    1181. 

  1181. }

    1182. 

  1182. 

    1183. 

  1183. // private:

    1184. 

  1184. // Parse a clear (unformatted) type node.

    1185. 

  1185. char XMLNode::parseClearTag(void *px, void *_pClear)

    1186. 

  1186. {

    1187. 

  1187.     XML *pXML=(XML *)px;

    1188. 

  1188.     ALLXMLClearTag pClear=*((ALLXMLClearTag*)_pClear);

    1189. 

  1189.     int cbTemp=0;

    1190. 

  1190.     XMLCSTR lpszTemp=NULL;

    1191. 

  1191.     XMLCSTR lpXML=&pXML->lpXML[pXML->nIndex];

    1192. 

  1192.     static XMLCSTR docTypeEnd=_CXML("]>");

    1193. 

  1193. 

    1194. 

  1194.     // Find the closing tag

    1195. 

  1195.     // Seems the <!DOCTYPE need a better treatment so lets handle it

    1196. 

  1196.     if (pClear.lpszOpen==XMLClearTags[1].lpszOpen)

    1197. 

  1197.     {

    1198. 

  1198.         XMLCSTR pCh=lpXML;

    1199. 

  1199.         while (*pCh)

    1200. 

  1200.         {

    1201. 

  1201.             if (*pCh==_CXML('<')) { pClear.lpszClose=docTypeEnd; lpszTemp=xstrstr(lpXML,docTypeEnd); break; }

    1202. 

  1202.             else if (*pCh==_CXML('>')) { lpszTemp=pCh; break; }

    1203. 

  1203. #ifdef _XMLWIDECHAR

    1204. 

  1204.             pCh++;

    1205. 

  1205. #else

    1206. 

  1206.             pCh+=XML_ByteTable[(unsigned char)(*pCh)];

    1207. 

  1207. #endif

    1208. 

  1208.         }

    1209. 

  1209.     } else lpszTemp=xstrstr(lpXML, pClear.lpszClose);

    1210. 

  1210. 

    1211. 

  1211.     if (lpszTemp)

    1212. 

  1212.     {

    1213. 

  1213.         // Cache the size and increment the index

    1214. 

  1214.         cbTemp = (int)(lpszTemp - lpXML);

    1215. 

  1215. 

    1216. 

  1216.         pXML->nIndex += cbTemp+(int)xstrlen(pClear.lpszClose);

    1217. 

  1217. 

    1218. 

  1218.         // Add the clear node to the current element

    1219. 

  1219.         addClear_priv(MEMORYINCREASE,stringDup(lpXML,cbTemp), pClear.lpszOpen, pClear.lpszClose,-1);

    1220. 

  1220.         return 0;

    1221. 

  1221.     }

    1222. 

  1222. 

    1223. 

  1223.     // If we failed to find the end tag

    1224. 

  1224.     pXML->error = eXMLErrorUnmatchedEndClearTag;

    1225. 

  1225.     return 1;

    1226. 

  1226. }

    1227. 

  1227. 

    1228. 

  1228. void XMLNode::exactMemory(XMLNodeData *d)

    1229. 

  1229. {

    1230. 

  1230.     if (d->pOrder)     d->pOrder=(int*)realloc(d->pOrder,(d->nChild+d->nText+d->nClear)*sizeof(int));

    1231. 

  1231.     if (d->pChild)     d->pChild=(XMLNode*)realloc(d->pChild,d->nChild*sizeof(XMLNode));

    1232. 

  1232.     if (d->pAttribute) d->pAttribute=(XMLAttribute*)realloc(d->pAttribute,d->nAttribute*sizeof(XMLAttribute));

    1233. 

  1233.     if (d->pText)      d->pText=(XMLCSTR*)realloc(d->pText,d->nText*sizeof(XMLSTR));

    1234. 

  1234.     if (d->pClear)     d->pClear=(XMLClear *)realloc(d->pClear,d->nClear*sizeof(XMLClear));

    1235. 

  1235. }

    1236. 

  1236. 

    1237. 

  1237. char XMLNode::maybeAddTxT(void *pa, XMLCSTR tokenPStr)

    1238. 

  1238. {

    1239. 

  1239.     XML *pXML=(XML *)pa;

    1240. 

  1240.     XMLCSTR lpszText=pXML->lpszText;

    1241. 

  1241.     if (!lpszText) return 0;

    1242. 

  1242.     if (dropWhiteSpace) while (XML_isSPACECHAR(*lpszText)&&(lpszText!=tokenPStr)) lpszText++;

    1243. 

  1243.     int cbText = (int)(tokenPStr - lpszText);

    1244. 

  1244.     if (!cbText) { pXML->lpszText=NULL; return 0; }

    1245. 

  1245.     if (dropWhiteSpace) { cbText--; while ((cbText)&&XML_isSPACECHAR(lpszText[cbText])) cbText--; cbText++; }

    1246. 

  1246.     if (!cbText) { pXML->lpszText=NULL; return 0; }

    1247. 

  1247.     XMLSTR lpt=fromXMLString(lpszText,cbText,pXML);

    1248. 

  1248.     if (!lpt) return 1;

    1249. 

  1249.     pXML->lpszText=NULL;

    1250. 

  1250.     if (removeCommentsInMiddleOfText && d->nText && d->nClear)

    1251. 

  1251.     {

    1252. 

  1252.         // if the previous insertion was a comment (<!-- -->) AND

    1253. 

  1253.         // if the previous previous insertion was a text then, delete the comment and append the text

    1254. 

  1254.         int n=d->nChild+d->nText+d->nClear-1,*o=d->pOrder;

    1255. 

  1255.         if (((o[n]&3)==eNodeClear)&&((o[n-1]&3)==eNodeText))

    1256. 

  1256.         {

    1257. 

  1257.             int i=o[n]>>2;

    1258. 

  1258.             if (d->pClear[i].lpszOpenTag==XMLClearTags[2].lpszOpen)

    1259. 

  1259.             {

    1260. 

  1260.                 deleteClear(i);

    1261. 

  1261.                 i=o[n-1]>>2;

    1262. 

  1262.                 n=xstrlen(d->pText[i]);

    1263. 

  1263.                 int n2=xstrlen(lpt)+1;

    1264. 

  1264.                 d->pText[i]=(XMLSTR)realloc((void*)d->pText[i],(n+n2)*sizeof(XMLCHAR));

    1265. 

  1265.                 if (!d->pText[i]) return 1;

    1266. 

  1266.                 memcpy((void*)(d->pText[i]+n),lpt,n2*sizeof(XMLCHAR));

    1267. 

  1267.                 free(lpt);

    1268. 

  1268.                 return 0;

    1269. 

  1269.             }

    1270. 

  1270.         }

    1271. 

  1271.     }

    1272. 

  1272.     addText_priv(MEMORYINCREASE,lpt,-1);

    1273. 

  1273.     return 0;

    1274. 

  1274. }

    1275. 

  1275. // private:

    1276. 

  1276. // Recursively parse an XML element.

    1277. 

  1277. int XMLNode::Par…
    1278.

Large files files are truncated, but you can click here to view the full file