MRPT  1.9.9
xmlParser.cpp
Go to the documentation of this file.
1 /* +------------------------------------------------------------------------+
2  | Mobile Robot Programming Toolkit (MRPT) |
3  | http://www.mrpt.org/ |
4  | |
5  | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file |
6  | See: http://www.mrpt.org/Authors - All rights reserved. |
7  | Released under BSD License. See details in http://www.mrpt.org/License |
8  +------------------------------------------------------------------------+ */
9 
10 #ifndef _CRT_SECURE_NO_DEPRECATE
11 #define _CRT_SECURE_NO_DEPRECATE
12 #endif
13 #undef _UNICODE // JLBC
14 #include "xmlParser.h"
15 #ifdef _XMLWINDOWS
16 #define WIN32_LEAN_AND_MEAN
17 #include <Windows.h> // to have IsTextUnicode, MultiByteToWideChar, WideCharToMultiByte to handle unicode files
18 // to have "MessageBoxA" to display error messages for openFilHelper
19 #endif
20 
21 #include <memory.h>
22 #include <cassert>
23 #include <cstdio>
24 #include <cstring>
25 #include <cstdlib>
26 
27 XMLCSTR XMLNode::getVersion() { return _CXML("v2.39"); }
28 void freeXMLString(XMLSTR t)
29 {
30  if (t) free(t);
31 }
32 
33 static XMLNode::XMLCharEncoding characterEncoding = XMLNode::char_encoding_UTF8;
34 static char guessWideCharChars = 1, dropWhiteSpace = 1,
35  removeCommentsInMiddleOfText = 1;
36 
37 inline int mmin(const int t1, const int t2) { return t1 < t2 ? t1 : t2; }
38 // You can modify the initialization of the variable "XMLClearTags" below
39 // to change the clearTags that are currently recognized by the library.
40 // The number on the second columns is the length of the string inside the
41 // first column. The "<!DOCTYPE" declaration must be the second in the list.
42 // The "<!--" declaration must be the third in the list.
43 typedef struct
44 {
45  XMLCSTR lpszOpen;
46  int openTagLen;
47  XMLCSTR lpszClose;
48 } ALLXMLClearTag;
49 static ALLXMLClearTag XMLClearTags[] = {
50  {_CXML("<![CDATA["), 9, _CXML("]]>")},
51  {_CXML("<!DOCTYPE"), 9, _CXML(">")},
52  {_CXML("<!--"), 4, _CXML("-->")},
53  {_CXML("<PRE>"), 5, _CXML("</PRE>")},
54  // { _CXML("<Script>") ,8, _CXML("</Script>")},
55  {nullptr, 0, nullptr}};
56 
57 // You can modify the initialization of the variable "XMLEntities" below
58 // to change the character entities that are currently recognized by the
59 // library.
60 // The number on the second columns is the length of the string inside the
61 // first column. Additionally, the syntaxes "&#xA0;" and "&#160;" are
62 // recognized.
63 typedef struct
64 {
65  XMLCSTR s;
66  int l;
67  XMLCHAR c;
68 } XMLCharacterEntity;
69 static XMLCharacterEntity XMLEntities[] = {
70  {_CXML("&amp;"), 5, _CXML('&')}, {_CXML("&lt;"), 4, _CXML('<')},
71  {_CXML("&gt;"), 4, _CXML('>')}, {_CXML("&quot;"), 6, _CXML('\"')},
72  {_CXML("&apos;"), 6, _CXML('\'')}, {nullptr, 0, '\0'}};
73 
74 // When rendering the XMLNode to a string (using the "createXMLString"
75 // function),
76 // you can ask for a beautiful formatting. This formatting is using the
77 // following indentation character:
78 #define INDENTCHAR _CXML('\t')
79 
80 // The following function parses the XML errors into a user friendly string.
81 // You can edit this to change the output language of the library to something
82 // else.
83 XMLCSTR XMLNode::getError(XMLError xerror)
84 {
85  switch (xerror)
86  {
87  case eXMLErrorNone:
88  return _CXML("No error");
89  case eXMLErrorMissingEndTag:
90  return _CXML("Warning: Unmatched end tag");
91  case eXMLErrorNoXMLTagFound:
92  return _CXML("Warning: No XML tag found");
93  case eXMLErrorEmpty:
94  return _CXML("Error: No XML data");
95  case eXMLErrorMissingTagName:
96  return _CXML("Error: Missing start tag name");
97  case eXMLErrorMissingEndTagName:
98  return _CXML("Error: Missing end tag name");
99  case eXMLErrorUnmatchedEndTag:
100  return _CXML("Error: Unmatched end tag");
101  case eXMLErrorUnmatchedEndClearTag:
102  return _CXML("Error: Unmatched clear tag end");
103  case eXMLErrorUnexpectedToken:
104  return _CXML("Error: Unexpected token found");
105  case eXMLErrorNoElements:
106  return _CXML("Error: No elements found");
107  case eXMLErrorFileNotFound:
108  return _CXML("Error: File not found");
109  case eXMLErrorFirstTagNotFound:
110  return _CXML("Error: First Tag not found");
111  case eXMLErrorUnknownCharacterEntity:
112  return _CXML("Error: Unknown character entity");
113  case eXMLErrorCharacterCodeAbove255:
114  return _CXML(
115  "Error: Character code above 255 is forbidden in MultiByte "
116  "char mode.");
117  case eXMLErrorCharConversionError:
118  return _CXML(
119  "Error: unable to convert between WideChar and MultiByte "
120  "chars");
121  case eXMLErrorCannotOpenWriteFile:
122  return _CXML("Error: unable to open file for writing");
123  case eXMLErrorCannotWriteFile:
124  return _CXML("Error: cannot write into file");
125 
126  case eXMLErrorBase64DataSizeIsNotMultipleOf4:
127  return _CXML(
128  "Warning: Base64-string length is not a multiple of 4");
129  case eXMLErrorBase64DecodeTruncatedData:
130  return _CXML("Warning: Base64-string is truncated");
131  case eXMLErrorBase64DecodeIllegalCharacter:
132  return _CXML("Error: Base64-string contains an illegal character");
133  case eXMLErrorBase64DecodeBufferTooSmall:
134  return _CXML("Error: Base64 decode output buffer is too small");
135  };
136  return _CXML("Unknown");
137 }
138 
139 /////////////////////////////////////////////////////////////////////////
140 // Here start the abstraction layer to be OS-independent //
141 /////////////////////////////////////////////////////////////////////////
142 
143 // Here is an abstraction layer to access some common string manipulation
144 // functions.
145 // The abstraction layer is currently working for gcc, Microsoft Visual Studio
146 // 6.0,
147 // Microsoft Visual Studio .NET, CC (sun compiler) and Borland C++.
148 // If you plan to "port" the library to a new system/compiler, all you have to
149 // do is
150 // to edit the following lines.
151 #ifdef XML_NO_WIDE_CHAR
152 char myIsTextWideChar(const void* b, int len) { return FALSE; }
153 #else
154 #if defined(UNDER_CE) || !defined(_XMLWINDOWS)
155 char myIsTextWideChar(
156  const void* b, int len) // inspired by the Wine API: RtlIsTextUnicode
157 {
158 #ifdef sun
159  // for SPARC processors: wchar_t* buffers must always be alligned, otherwise
160  // it's a char* buffer.
161  if ((((unsigned long)b) % sizeof(wchar_t)) != 0) return FALSE;
162 #endif
163  const wchar_t* s = (const wchar_t*)b;
164 
165  // buffer too small:
166  if (len < (int)sizeof(wchar_t)) return FALSE;
167 
168  // odd length test
169  if (len & 1) return FALSE;
170 
171  /* only checks the first 256 characters */
172  len = mmin(256, len / sizeof(wchar_t));
173 
174  // Check for the special byte order:
175  if (*((unsigned short*)s) == 0xFFFE)
176  return TRUE; // IS_TEXT_UNICODE_REVERSE_SIGNATURE;
177  if (*((unsigned short*)s) == 0xFEFF)
178  return TRUE; // IS_TEXT_UNICODE_SIGNATURE
179 
180  // checks for ASCII characters in the UNICODE stream
181  int i, stats = 0;
182  for (i = 0; i < len; i++)
183  if (s[i] <= (unsigned short)255) stats++;
184  if (stats > len / 2) return TRUE;
185 
186  // Check for UNICODE nullptr chars
187  for (i = 0; i < len; i++)
188  if (!s[i]) return TRUE;
189 
190  return FALSE;
191 }
192 #else
193 char myIsTextWideChar(const void* b, int l)
194 {
195  return (char)IsTextUnicode((CONST LPVOID)b, l, nullptr);
196 }
197 #endif
198 #endif
199 
200 #ifdef _XMLWINDOWS
201 // for Microsoft Visual Studio 6.0 and Microsoft Visual Studio .NET and Borland
202 // C++ Builder 6.0
203 #ifdef _XMLWIDECHAR
204 wchar_t* myMultiByteToWideChar(const char* s, XMLNode::XMLCharEncoding ce)
205 {
206  int i;
207  if (ce == XMLNode::char_encoding_UTF8)
208  i = (int)MultiByteToWideChar(CP_UTF8, 0, s, -1, nullptr, 0);
209  else
210  i = (int)MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, s, -1, nullptr, 0);
211  if (i < 0) return nullptr;
212  wchar_t* d = (wchar_t*)malloc((i + 1) * sizeof(XMLCHAR));
213  if (ce == XMLNode::char_encoding_UTF8)
214  i = (int)MultiByteToWideChar(CP_UTF8, 0, s, -1, d, i);
215  else
216  i = (int)MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, s, -1, d, i);
217  d[i] = 0;
218  return d;
219 }
220 static inline FILE* xfopen(XMLCSTR filename, XMLCSTR mode)
221 {
222  return _wfopen(filename, mode);
223 }
224 static inline int xstrlen(XMLCSTR c) { return (int)wcslen(c); }
225 static inline int xstrnicmp(XMLCSTR c1, XMLCSTR c2, int l)
226 {
227  return _wcsnicmp(c1, c2, l);
228 }
229 static inline int xstrncmp(XMLCSTR c1, XMLCSTR c2, int l)
230 {
231  return wcsncmp(c1, c2, l);
232 }
233 static inline int xstricmp(XMLCSTR c1, XMLCSTR c2) { return _wcsicmp(c1, c2); }
234 static inline XMLSTR xstrstr(XMLCSTR c1, XMLCSTR c2)
235 {
236  return (XMLSTR)wcsstr(c1, c2);
237 }
238 static inline XMLSTR xstrcpy(XMLSTR c1, XMLCSTR c2)
239 {
240  return (XMLSTR)wcscpy(c1, c2);
241 }
242 #else
243 char* myWideCharToMultiByte(const wchar_t* s)
244 {
245  UINT codePage = CP_ACP;
246  if (characterEncoding == XMLNode::char_encoding_UTF8) codePage = CP_UTF8;
247  int i = (int)WideCharToMultiByte(
248  codePage, // code page
249  0, // performance and mapping flags
250  s, // wide-character string
251  -1, // number of chars in string
252  nullptr, // buffer for new string
253  0, // size of buffer
254  nullptr, // default for unmappable chars
255  nullptr // set when default char used
256  );
257  if (i < 0) return nullptr;
258  char* d = (char*)malloc(i + 1);
259  WideCharToMultiByte(
260  codePage, // code page
261  0, // performance and mapping flags
262  s, // wide-character string
263  -1, // number of chars in string
264  d, // buffer for new string
265  i, // size of buffer
266  nullptr, // default for unmappable chars
267  nullptr // set when default char used
268  );
269  d[i] = 0;
270  return d;
271 }
272 static inline FILE* xfopen(XMLCSTR filename, XMLCSTR mode)
273 {
274  return fopen(filename, mode);
275 }
276 static inline int xstrlen(XMLCSTR c) { return (int)strlen(c); }
277 #ifdef __BORLANDC__
278 static inline int xstrnicmp(XMLCSTR c1, XMLCSTR c2, int l)
279 {
280  return strnicmp(c1, c2, l);
281 }
282 static inline int xstricmp(XMLCSTR c1, XMLCSTR c2) { return stricmp(c1, c2); }
283 #else
284 static inline int xstrnicmp(XMLCSTR c1, XMLCSTR c2, int l)
285 {
286  return _strnicmp(c1, c2, l);
287 }
288 static inline int xstricmp(XMLCSTR c1, XMLCSTR c2) { return _stricmp(c1, c2); }
289 #endif
290 static inline int xstrncmp(XMLCSTR c1, XMLCSTR c2, int l)
291 {
292  return strncmp(c1, c2, l);
293 }
294 static inline XMLSTR xstrstr(XMLCSTR c1, XMLCSTR c2)
295 {
296  return (XMLSTR)strstr(c1, c2);
297 }
298 static inline XMLSTR xstrcpy(XMLSTR c1, XMLCSTR c2)
299 {
300  return (XMLSTR)strcpy(c1, c2);
301 }
302 #endif
303 #else
304 // for gcc and CC
305 #ifdef XML_NO_WIDE_CHAR
306 char* myWideCharToMultiByte(const wchar_t* s) { return nullptr; }
307 #else
308 char* myWideCharToMultiByte(const wchar_t* s)
309 {
310  const wchar_t* ss = s;
311  int i = (int)wcsrtombs(nullptr, &ss, 0, nullptr);
312  if (i < 0) return nullptr;
313  char* d = (char*)malloc(i + 1);
314  wcsrtombs(d, &s, i, nullptr);
315  d[i] = 0;
316  return d;
317 }
318 #endif
319 #ifdef _XMLWIDECHAR
320 wchar_t* myMultiByteToWideChar(const char* s, XMLNode::XMLCharEncoding ce)
321 {
322  const char* ss = s;
323  int i = (int)mbsrtowcs(nullptr, &ss, 0, nullptr);
324  if (i < 0) return nullptr;
325  wchar_t* d = (wchar_t*)malloc((i + 1) * sizeof(wchar_t));
326  mbsrtowcs(d, &s, i, nullptr);
327  d[i] = 0;
328  return d;
329 }
330 int xstrlen(XMLCSTR c) { return wcslen(c); }
331 #ifdef sun
332 // for CC
333 #include <widec.h>
334 static inline int xstrnicmp(XMLCSTR c1, XMLCSTR c2, int l)
335 {
336  return wsncasecmp(c1, c2, l);
337 }
338 static inline int xstrncmp(XMLCSTR c1, XMLCSTR c2, int l)
339 {
340  return wsncmp(c1, c2, l);
341 }
342 static inline int xstricmp(XMLCSTR c1, XMLCSTR c2) { return wscasecmp(c1, c2); }
343 #else
344 // for gcc
345 static inline int xstrnicmp(XMLCSTR c1, XMLCSTR c2, int l)
346 {
347  return wcsncasecmp(c1, c2, l);
348 }
349 static inline int xstrncmp(XMLCSTR c1, XMLCSTR c2, int l)
350 {
351  return wcsncmp(c1, c2, l);
352 }
353 static inline int xstricmp(XMLCSTR c1, XMLCSTR c2)
354 {
355  return wcscasecmp(c1, c2);
356 }
357 #endif
358 static inline XMLSTR xstrstr(XMLCSTR c1, XMLCSTR c2)
359 {
360  return (XMLSTR)wcsstr(c1, c2);
361 }
362 static inline XMLSTR xstrcpy(XMLSTR c1, XMLCSTR c2)
363 {
364  return (XMLSTR)wcscpy(c1, c2);
365 }
366 static inline FILE* xfopen(XMLCSTR filename, XMLCSTR mode)
367 {
368  char* filenameAscii = myWideCharToMultiByte(filename);
369  FILE* f;
370  if (mode[0] == _CXML('r'))
371  f = fopen(filenameAscii, "rb");
372  else
373  f = fopen(filenameAscii, "wb");
374  free(filenameAscii);
375  return f;
376 }
377 #else
378 static inline FILE* xfopen(XMLCSTR filename, XMLCSTR mode)
379 {
380  return fopen(filename, mode);
381 }
382 static inline int xstrlen(XMLCSTR c) { return strlen(c); }
383 static inline int xstrnicmp(XMLCSTR c1, XMLCSTR c2, int l)
384 {
385  return strncasecmp(c1, c2, l);
386 }
387 static inline int xstrncmp(XMLCSTR c1, XMLCSTR c2, int l)
388 {
389  return strncmp(c1, c2, l);
390 }
391 static inline int xstricmp(XMLCSTR c1, XMLCSTR c2)
392 {
393  return strcasecmp(c1, c2);
394 }
395 static inline XMLSTR xstrstr(XMLCSTR c1, XMLCSTR c2)
396 {
397  return (XMLSTR)strstr(c1, c2);
398 }
399 static inline XMLSTR xstrcpy(XMLSTR c1, XMLCSTR c2)
400 {
401  return (XMLSTR)strcpy(c1, c2);
402 }
403 #endif
404 #ifdef __clang__
405 #pragma clang diagnostic push
406 #pragma clang diagnostic ignored "-Wunused-function"
407 static inline int _strnicmp(const char* c1, const char* c2, int l)
408 {
409  return strncasecmp(c1, c2, l);
410 }
411 #pragma clang diagnostic pop
412 #endif
413 #endif
414 
415 ///////////////////////////////////////////////////////////////////////////////
416 // the "xmltoc,xmltob,xmltoi,xmltol,xmltof,xmltoa" functions //
417 ///////////////////////////////////////////////////////////////////////////////
418 // These 6 functions are not used inside the XMLparser.
419 // There are only here as "convenience" functions for the user.
420 // If you don't need them, you can delete them without any trouble.
421 #ifdef _XMLWIDECHAR
422 #ifdef _XMLWINDOWS
423 // for Microsoft Visual Studio 6.0 and Microsoft Visual Studio .NET and Borland
424 // C++ Builder 6.0
425 char xmltob(XMLCSTR t, int v)
426 {
427  if (t && (*t)) return (char)_wtoi(t);
428  return v;
429 }
430 int xmltoi(XMLCSTR t, int v)
431 {
432  if (t && (*t)) return _wtoi(t);
433  return v;
434 }
435 long xmltol(XMLCSTR t, long v)
436 {
437  if (t && (*t)) return _wtol(t);
438  return v;
439 }
440 double xmltof(XMLCSTR t, double v)
441 {
442  if (t && (*t)) wscanf(t, "%f", &v); /*v=_wtof(t);*/
443  return v;
444 }
445 #else
446 #ifdef sun
447 // for CC
448 #include <widec.h>
449 char xmltob(XMLCSTR t, int v)
450 {
451  if (t) return (char)wstol(t, nullptr, 10);
452  return v;
453 }
454 int xmltoi(XMLCSTR t, int v)
455 {
456  if (t) return (int)wstol(t, nullptr, 10);
457  return v;
458 }
459 long xmltol(XMLCSTR t, long v)
460 {
461  if (t) return wstol(t, nullptr, 10);
462  return v;
463 }
464 #else
465 // for gcc
466 char xmltob(XMLCSTR t, int v)
467 {
468  if (t) return (char)wcstol(t, nullptr, 10);
469  return v;
470 }
471 int xmltoi(XMLCSTR t, int v)
472 {
473  if (t) return (int)wcstol(t, nullptr, 10);
474  return v;
475 }
476 long xmltol(XMLCSTR t, long v)
477 {
478  if (t) return wcstol(t, nullptr, 10);
479  return v;
480 }
481 #endif
482 double xmltof(XMLCSTR t, double v)
483 {
484  if (t && (*t)) wscanf(t, "%f", &v); /*v=_wtof(t);*/
485  return v;
486 }
487 #endif
488 #else
489 char xmltob(XMLCSTR t, char v)
490 {
491  if (t && (*t)) return (char)atoi(t);
492  return v;
493 }
494 int xmltoi(XMLCSTR t, int v)
495 {
496  if (t && (*t)) return atoi(t);
497  return v;
498 }
499 long xmltol(XMLCSTR t, long v)
500 {
501  if (t && (*t)) return atol(t);
502  return v;
503 }
504 double xmltof(XMLCSTR t, double v)
505 {
506  if (t && (*t)) return atof(t);
507  return v;
508 }
509 #endif
510 XMLCSTR xmltoa(XMLCSTR t, XMLCSTR v)
511 {
512  if (t) return t;
513  return v;
514 }
515 XMLCHAR xmltoc(XMLCSTR t, XMLCHAR v)
516 {
517  if (t && (*t)) return *t;
518  return v;
519 }
520 
521 /////////////////////////////////////////////////////////////////////////
522 // the "openFileHelper" function //
523 /////////////////////////////////////////////////////////////////////////
524 
525 // Since each application has its own way to report and deal with errors, you
526 // should modify & rewrite
527 // the following "openFileHelper" function to get an "error reporting mechanism"
528 // tailored to your needs.
529 XMLNode XMLNode::openFileHelper(XMLCSTR filename, XMLCSTR tag)
530 {
531  // guess the value of the global parameter "characterEncoding"
532  // (the guess is based on the first 200 bytes of the file).
533  FILE* f = xfopen(filename, _CXML("rb"));
534  if (f)
535  {
536  char bb[205];
537  int l = (int)fread(bb, 1, 200, f);
538  setGlobalOptions(
539  guessCharEncoding(bb, l), guessWideCharChars, dropWhiteSpace,
540  removeCommentsInMiddleOfText);
541  fclose(f);
542  }
543 
544  // parse the file
545  XMLResults pResults;
546  XMLNode xnode = XMLNode::parseFile(filename, tag, &pResults);
547 
548  // display error message (if any)
549  if (pResults.error != eXMLErrorNone)
550  {
551  // create message
552  char message[2000], *s1 = (char *)"", *s3 = (char *)"";
553  XMLCSTR s2 = _CXML("");
554  if (pResults.error == eXMLErrorFirstTagNotFound)
555  {
556  s1 = (char*)"First Tag should be '";
557  s2 = tag;
558  s3 = (char*)"'.\n";
559  }
560  sprintf(
561  message,
562 #ifdef _XMLWIDECHAR
563  "XML Parsing error inside file '%S'.\n%S\nAt line %i, column "
564  "%i.\n%s%S%s"
565 #else
566  "XML Parsing error inside file '%s'.\n%s\nAt line %i, column "
567  "%i.\n%s%s%s"
568 #endif
569  ,
570  filename, XMLNode::getError(pResults.error), pResults.nLine,
571  pResults.nColumn, s1, s2, s3);
572 
573 // display message
574 #if defined(_XMLWINDOWS) && !defined(UNDER_CE) && \
575  !defined(_XMLPARSER_NO_MESSAGEBOX_)
576  MessageBoxA(
577  nullptr, message, "XML Parsing error",
578  MB_OK | MB_ICONERROR | MB_TOPMOST);
579 #else
580  printf("%s", message);
581 #endif
582  // exit(255);
583  }
584  return xnode;
585 }
586 
587 /////////////////////////////////////////////////////////////////////////
588 // Here start the core implementation of the XMLParser library //
589 /////////////////////////////////////////////////////////////////////////
590 
591 // You should normally not change anything below this point.
592 
593 #ifndef _XMLWIDECHAR
594 // If "characterEncoding=ascii" then we assume that all characters have the same
595 // length of 1 byte.
596 // If "characterEncoding=UTF8" then the characters have different lengths (from
597 // 1 byte to 4 bytes).
598 // If "characterEncoding=ShiftJIS" then the characters have different lengths
599 // (from 1 byte to 2 bytes).
600 // This table is used as lookup-table to know the length of a character (in
601 // byte) based on the
602 // content of the first byte of the character.
603 // (note: if you modify this, you must always have XML_utf8ByteTable[0]=0 ).
604 static const char XML_utf8ByteTable[256] = {
605  // 0 1 2 3 4 5 6 7 8 9 a b c d e f
606  0, 1, 1, 1, 1, 1, 1, 1,
607  1, 1, 1, 1, 1, 1, 1, 1, // 0x00
608  1, 1, 1, 1, 1, 1, 1, 1,
609  1, 1, 1, 1, 1, 1, 1, 1, // 0x10
610  1, 1, 1, 1, 1, 1, 1, 1,
611  1, 1, 1, 1, 1, 1, 1, 1, // 0x20
612  1, 1, 1, 1, 1, 1, 1, 1,
613  1, 1, 1, 1, 1, 1, 1, 1, // 0x30
614  1, 1, 1, 1, 1, 1, 1, 1,
615  1, 1, 1, 1, 1, 1, 1, 1, // 0x40
616  1, 1, 1, 1, 1, 1, 1, 1,
617  1, 1, 1, 1, 1, 1, 1, 1, // 0x50
618  1, 1, 1, 1, 1, 1, 1, 1,
619  1, 1, 1, 1, 1, 1, 1, 1, // 0x60
620  1, 1, 1, 1, 1, 1, 1, 1,
621  1, 1, 1, 1, 1, 1, 1, 1, // 0x70 End of ASCII range
622  1, 1, 1, 1, 1, 1, 1, 1,
623  1, 1, 1, 1, 1, 1, 1, 1, // 0x80 0x80 to 0xc1 invalid
624  1, 1, 1, 1, 1, 1, 1, 1,
625  1, 1, 1, 1, 1, 1, 1, 1, // 0x90
626  1, 1, 1, 1, 1, 1, 1, 1,
627  1, 1, 1, 1, 1, 1, 1, 1, // 0xa0
628  1, 1, 1, 1, 1, 1, 1, 1,
629  1, 1, 1, 1, 1, 1, 1, 1, // 0xb0
630  1, 1, 2, 2, 2, 2, 2, 2,
631  2, 2, 2, 2, 2, 2, 2, 2, // 0xc0 0xc2 to 0xdf 2 byte
632  2, 2, 2, 2, 2, 2, 2, 2,
633  2, 2, 2, 2, 2, 2, 2, 2, // 0xd0
634  3, 3, 3, 3, 3, 3, 3, 3,
635  3, 3, 3, 3, 3, 3, 3, 3, // 0xe0 0xe0 to 0xef 3 byte
636  4, 4, 4, 4, 4, 1, 1, 1,
637  1, 1, 1, 1, 1, 1, 1, 1 // 0xf0 0xf0 to 0xf4 4 byte, 0xf5 and higher invalid
638 };
639 static const char XML_legacyByteTable[256] = {
640  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
641  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
642  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
643  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
644  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
645  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
646  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
647  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
648  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
649  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
650  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
651 static const char XML_sjisByteTable[256] = {
652  // 0 1 2 3 4 5 6 7 8 9 a b c d e f
653  0, 1, 1, 1, 1, 1, 1, 1,
654  1, 1, 1, 1, 1, 1, 1, 1, // 0x00
655  1, 1, 1, 1, 1, 1, 1, 1,
656  1, 1, 1, 1, 1, 1, 1, 1, // 0x10
657  1, 1, 1, 1, 1, 1, 1, 1,
658  1, 1, 1, 1, 1, 1, 1, 1, // 0x20
659  1, 1, 1, 1, 1, 1, 1, 1,
660  1, 1, 1, 1, 1, 1, 1, 1, // 0x30
661  1, 1, 1, 1, 1, 1, 1, 1,
662  1, 1, 1, 1, 1, 1, 1, 1, // 0x40
663  1, 1, 1, 1, 1, 1, 1, 1,
664  1, 1, 1, 1, 1, 1, 1, 1, // 0x50
665  1, 1, 1, 1, 1, 1, 1, 1,
666  1, 1, 1, 1, 1, 1, 1, 1, // 0x60
667  1, 1, 1, 1, 1, 1, 1, 1,
668  1, 1, 1, 1, 1, 1, 1, 1, // 0x70
669  1, 2, 2, 2, 2, 2, 2, 2,
670  2, 2, 2, 2, 2, 2, 2, 2, // 0x80 0x81 to 0x9F 2 bytes
671  2, 2, 2, 2, 2, 2, 2, 2,
672  2, 2, 2, 2, 2, 2, 2, 2, // 0x90
673  1, 1, 1, 1, 1, 1, 1, 1,
674  1, 1, 1, 1, 1, 1, 1, 1, // 0xa0
675  1, 1, 1, 1, 1, 1, 1, 1,
676  1, 1, 1, 1, 1, 1, 1, 1, // 0xb0
677  1, 1, 1, 1, 1, 1, 1, 1,
678  1, 1, 1, 1, 1, 1, 1, 1, // 0xc0
679  1, 1, 1, 1, 1, 1, 1, 1,
680  1, 1, 1, 1, 1, 1, 1, 1, // 0xd0
681  2, 2, 2, 2, 2, 2, 2, 2,
682  2, 2, 2, 2, 2, 2, 2, 2, // 0xe0 0xe0 to 0xef 2 bytes
683  1, 1, 1, 1, 1, 1, 1, 1,
684  1, 1, 1, 1, 1, 1, 1, 1 // 0xf0
685 };
686 static const char XML_gb2312ByteTable[256] = {
687  // 0 1 2 3 4 5 6 7 8 9 a b c d e f
688  0, 1, 1, 1, 1, 1, 1, 1,
689  1, 1, 1, 1, 1, 1, 1, 1, // 0x00
690  1, 1, 1, 1, 1, 1, 1, 1,
691  1, 1, 1, 1, 1, 1, 1, 1, // 0x10
692  1, 1, 1, 1, 1, 1, 1, 1,
693  1, 1, 1, 1, 1, 1, 1, 1, // 0x20
694  1, 1, 1, 1, 1, 1, 1, 1,
695  1, 1, 1, 1, 1, 1, 1, 1, // 0x30
696  1, 1, 1, 1, 1, 1, 1, 1,
697  1, 1, 1, 1, 1, 1, 1, 1, // 0x40
698  1, 1, 1, 1, 1, 1, 1, 1,
699  1, 1, 1, 1, 1, 1, 1, 1, // 0x50
700  1, 1, 1, 1, 1, 1, 1, 1,
701  1, 1, 1, 1, 1, 1, 1, 1, // 0x60
702  1, 1, 1, 1, 1, 1, 1, 1,
703  1, 1, 1, 1, 1, 1, 1, 1, // 0x70
704  1, 1, 1, 1, 1, 1, 1, 1,
705  1, 1, 1, 1, 1, 1, 1, 1, // 0x80
706  1, 1, 1, 1, 1, 1, 1, 1,
707  1, 1, 1, 1, 1, 1, 1, 1, // 0x90
708  1, 2, 2, 2, 2, 2, 2, 2,
709  2, 2, 2, 2, 2, 2, 2, 2, // 0xa0 0xa1 to 0xf7 2 bytes
710  2, 2, 2, 2, 2, 2, 2, 2,
711  2, 2, 2, 2, 2, 2, 2, 2, // 0xb0
712  2, 2, 2, 2, 2, 2, 2, 2,
713  2, 2, 2, 2, 2, 2, 2, 2, // 0xc0
714  2, 2, 2, 2, 2, 2, 2, 2,
715  2, 2, 2, 2, 2, 2, 2, 2, // 0xd0
716  2, 2, 2, 2, 2, 2, 2, 2,
717  2, 2, 2, 2, 2, 2, 2, 2, // 0xe0
718  2, 2, 2, 2, 2, 2, 2, 2,
719  1, 1, 1, 1, 1, 1, 1, 1 // 0xf0
720 };
721 static const char XML_gbk_big5_ByteTable[256] = {
722  // 0 1 2 3 4 5 6 7 8 9 a b c d e f
723  0, 1, 1, 1, 1, 1, 1, 1,
724  1, 1, 1, 1, 1, 1, 1, 1, // 0x00
725  1, 1, 1, 1, 1, 1, 1, 1,
726  1, 1, 1, 1, 1, 1, 1, 1, // 0x10
727  1, 1, 1, 1, 1, 1, 1, 1,
728  1, 1, 1, 1, 1, 1, 1, 1, // 0x20
729  1, 1, 1, 1, 1, 1, 1, 1,
730  1, 1, 1, 1, 1, 1, 1, 1, // 0x30
731  1, 1, 1, 1, 1, 1, 1, 1,
732  1, 1, 1, 1, 1, 1, 1, 1, // 0x40
733  1, 1, 1, 1, 1, 1, 1, 1,
734  1, 1, 1, 1, 1, 1, 1, 1, // 0x50
735  1, 1, 1, 1, 1, 1, 1, 1,
736  1, 1, 1, 1, 1, 1, 1, 1, // 0x60
737  1, 1, 1, 1, 1, 1, 1, 1,
738  1, 1, 1, 1, 1, 1, 1, 1, // 0x70
739  1, 2, 2, 2, 2, 2, 2, 2,
740  2, 2, 2, 2, 2, 2, 2, 2, // 0x80 0x81 to 0xfe 2 bytes
741  2, 2, 2, 2, 2, 2, 2, 2,
742  2, 2, 2, 2, 2, 2, 2, 2, // 0x90
743  2, 2, 2, 2, 2, 2, 2, 2,
744  2, 2, 2, 2, 2, 2, 2, 2, // 0xa0
745  2, 2, 2, 2, 2, 2, 2, 2,
746  2, 2, 2, 2, 2, 2, 2, 2, // 0xb0
747  2, 2, 2, 2, 2, 2, 2, 2,
748  2, 2, 2, 2, 2, 2, 2, 2, // 0xc0
749  2, 2, 2, 2, 2, 2, 2, 2,
750  2, 2, 2, 2, 2, 2, 2, 2, // 0xd0
751  2, 2, 2, 2, 2, 2, 2, 2,
752  2, 2, 2, 2, 2, 2, 2, 2, // 0xe0
753  2, 2, 2, 2, 2, 2, 2, 2,
754  2, 2, 2, 2, 2, 2, 2, 1 // 0xf0
755 };
756 static const char* XML_ByteTable =
757  (const char*)XML_utf8ByteTable; // the default is
758 // "characterEncoding=XMLNode::encoding_UTF8"
759 #endif
760 
761 XMLNode XMLNode::emptyXMLNode;
762 XMLClear XMLNode::emptyXMLClear = {nullptr, nullptr, nullptr};
763 XMLAttribute XMLNode::emptyXMLAttribute = {nullptr, nullptr};
764 
765 // Enumeration used to decipher what type a token is
766 typedef enum XMLTokenTypeTag {
767  eTokenText = 0,
768  eTokenQuotedText,
769  eTokenTagStart, /* "<" */
770  eTokenTagEnd, /* "</" */
771  eTokenCloseTag, /* ">" */
772  eTokenEquals, /* "=" */
773  eTokenDeclaration, /* "<?" */
774  eTokenShortHandClose, /* "/>" */
775  eTokenClear,
776  eTokenError
777 } XMLTokenType;
778 
779 // Main structure used for parsing XML
780 typedef struct XML
781 {
782  XMLCSTR lpXML;
783  XMLCSTR lpszText;
784  int nIndex, nIndexMissigEndTag;
785  enum XMLError error;
786  XMLCSTR lpEndTag;
787  int cbEndTag;
788  XMLCSTR lpNewElement;
789  int cbNewElement;
790  int nFirst;
791 } XML;
792 
793 typedef struct
794 {
795  ALLXMLClearTag* pClr;
796  XMLCSTR pStr;
797 } NextToken;
798 
799 // Enumeration used when parsing attributes
800 using Attrib = enum Attrib { eAttribName = 0, eAttribEquals, eAttribValue };
801 
802 // Enumeration used when parsing elements to dictate whether we are currently
803 // inside a tag
804 using Status = enum Status { eInsideTag = 0, eOutsideTag };
805 
806 XMLError XMLNode::writeToFile(
807  XMLCSTR filename, const char* encoding, char nFormat) const
808 {
809  if (!d) return eXMLErrorNone;
810  FILE* f = xfopen(filename, _CXML("wb"));
811  if (!f) return eXMLErrorCannotOpenWriteFile;
812 #ifdef _XMLWIDECHAR
813  unsigned char h[2] = {0xFF, 0xFE};
814  if (!fwrite(h, 2, 1, f)) return eXMLErrorCannotWriteFile;
815  if ((!isDeclaration()) &&
816  ((d->lpszName) || (!getChildNode().isDeclaration())))
817  {
818  if (!fwrite(
819  L"<?xml version=\"1.0\" encoding=\"utf-16\"?>\n",
820  sizeof(wchar_t) * 40, 1, f))
821  return eXMLErrorCannotWriteFile;
822  }
823 #else
824  if ((!isDeclaration()) &&
825  ((d->lpszName) || (!getChildNode().isDeclaration())))
826  {
827  if (characterEncoding == char_encoding_UTF8)
828  {
829  // header so that windows recognize the file as UTF-8:
830  unsigned char h[3] = {0xEF, 0xBB, 0xBF};
831  if (!fwrite(h, 3, 1, f)) return eXMLErrorCannotWriteFile;
832  encoding = "utf-8";
833  }
834  else if (characterEncoding == char_encoding_ShiftJIS)
835  encoding = "SHIFT-JIS";
836 
837  if (!encoding) encoding = "ISO-8859-1";
838  if (fprintf(f, "<?xml version=\"1.0\" encoding=\"%s\"?>\n", encoding) <
839  0)
840  return eXMLErrorCannotWriteFile;
841  }
842  else
843  {
844  if (characterEncoding == char_encoding_UTF8)
845  {
846  unsigned char h[3] = {0xEF, 0xBB, 0xBF};
847  if (!fwrite(h, 3, 1, f)) return eXMLErrorCannotWriteFile;
848  }
849  }
850 #endif
851  int i;
852  XMLSTR t = createXMLString(nFormat, &i);
853  if (!fwrite(t, sizeof(XMLCHAR) * i, 1, f)) return eXMLErrorCannotWriteFile;
854  if (fclose(f) != 0) return eXMLErrorCannotWriteFile;
855  free(t);
856  return eXMLErrorNone;
857 }
858 
859 // Duplicate a given string.
860 XMLSTR stringDup(XMLCSTR lpszData, int cbData)
861 {
862  if (lpszData == nullptr) return nullptr;
863 
864  XMLSTR lpszNew;
865  if (cbData == -1) cbData = (int)xstrlen(lpszData);
866  lpszNew = (XMLSTR)malloc((cbData + 1) * sizeof(XMLCHAR));
867  if (lpszNew)
868  {
869  memcpy(lpszNew, lpszData, (cbData) * sizeof(XMLCHAR));
870  lpszNew[cbData] = (XMLCHAR)NULL;
871  }
872  return lpszNew;
873 }
874 
875 XMLSTR ToXMLStringTool::toXMLUnSafe(XMLSTR dest, XMLCSTR source)
876 {
877  XMLSTR dd = dest;
878  XMLCHAR ch;
879  XMLCharacterEntity* entity;
880  while ((ch = *source) != '\0')
881  {
882  entity = XMLEntities;
883  do
884  {
885  if (ch == entity->c)
886  {
887  xstrcpy(dest, entity->s);
888  dest += entity->l;
889  source++;
890  goto out_of_loop1;
891  }
892  entity++;
893  } while (entity->s);
894 #ifdef _XMLWIDECHAR
895  *(dest++) = *(source++);
896 #else
897  switch (XML_ByteTable[(unsigned char)ch])
898  {
899  case 4:
900  *(dest++) = *(source++);
901  /*FALLTHROUGH*/
902  case 3:
903  *(dest++) = *(source++);
904  /*FALLTHROUGH*/
905  case 2:
906  *(dest++) = *(source++);
907  /*FALLTHROUGH*/
908  case 1:
909  *(dest++) = *(source++);
910  /*FALLTHROUGH*/
911  }
912 #endif
913  out_of_loop1:;
914  }
915  *dest = 0;
916  return dd;
917 }
918 
919 // private (used while rendering):
920 int ToXMLStringTool::lengthXMLString(XMLCSTR source)
921 {
922  int r = 0;
923  XMLCharacterEntity* entity;
924  XMLCHAR ch;
925  while ((ch = *source) != '\0')
926  {
927  entity = XMLEntities;
928  do
929  {
930  if (ch == entity->c)
931  {
932  r += entity->l;
933  source++;
934  goto out_of_loop1;
935  }
936  entity++;
937  } while (entity->s);
938 #ifdef _XMLWIDECHAR
939  r++;
940  source++;
941 #else
942  ch = XML_ByteTable[(unsigned char)ch];
943  r += ch;
944  source += ch;
945 #endif
946  out_of_loop1:;
947  }
948  return r;
949 }
950 
951 ToXMLStringTool::~ToXMLStringTool() { freeBuffer(); }
952 void ToXMLStringTool::freeBuffer()
953 {
954  if (buf) free(buf);
955  buf = nullptr;
956  buflen = 0;
957 }
958 XMLSTR ToXMLStringTool::toXML(XMLCSTR source)
959 {
960  int l = lengthXMLString(source) + 1;
961  if (l > buflen)
962  {
963  buflen = l;
964  buf = (XMLSTR)realloc(buf, l * sizeof(XMLCHAR));
965  }
966  return toXMLUnSafe(buf, source);
967 }
968 
969 // private:
970 XMLSTR fromXMLString(XMLCSTR s, int lo, XML* pXML)
971 {
972  // This function is the opposite of the function "toXMLString". It decodes
973  // the escape
974  // sequences &amp;, &quot;, &apos;, &lt;, &gt; and replace them by the
975  // characters
976  // &,",',<,>. This function is used internally by the XML Parser. All the
977  // calls to
978  // the XML library will always gives you back "decoded" strings.
979  //
980  // in: string (s) and length (lo) of string
981  // out: new allocated string converted from xml
982  if (!s) return nullptr;
983 
984  int ll = 0, j;
985  XMLSTR d;
986  XMLCSTR ss = s;
987  XMLCharacterEntity* entity;
988  while ((lo > 0) && (*s))
989  {
990  if (*s == _CXML('&'))
991  {
992  if ((lo > 2) && (s[1] == _CXML('#')))
993  {
994  s += 2;
995  lo -= 2;
996  if ((*s == _CXML('X')) || (*s == _CXML('x')))
997  {
998  s++;
999  lo--;
1000  }
1001  while ((*s) && (*s != _CXML(';')) && ((lo--) > 0)) s++;
1002  if (*s != _CXML(';'))
1003  {
1004  pXML->error = eXMLErrorUnknownCharacterEntity;
1005  return nullptr;
1006  }
1007  s++;
1008  lo--;
1009  }
1010  else
1011  {
1012  entity = XMLEntities;
1013  do
1014  {
1015  if ((lo >= entity->l) &&
1016  (xstrnicmp(s, entity->s, entity->l) == 0))
1017  {
1018  s += entity->l;
1019  lo -= entity->l;
1020  break;
1021  }
1022  entity++;
1023  } while (entity->s);
1024  if (!entity->s)
1025  {
1026  pXML->error = eXMLErrorUnknownCharacterEntity;
1027  return nullptr;
1028  }
1029  }
1030  }
1031  else
1032  {
1033 #ifdef _XMLWIDECHAR
1034  s++;
1035  lo--;
1036 #else
1037  j = XML_ByteTable[(unsigned char)*s];
1038  s += j;
1039  lo -= j;
1040  ll += j - 1;
1041 #endif
1042  }
1043  ll++;
1044  }
1045 
1046  d = (XMLSTR)malloc((ll + 1) * sizeof(XMLCHAR));
1047  s = d;
1048  while (ll-- > 0)
1049  {
1050  if (*ss == _CXML('&'))
1051  {
1052  if (ss[1] == _CXML('#'))
1053  {
1054  ss += 2;
1055  j = 0;
1056  if ((*ss == _CXML('X')) || (*ss == _CXML('x')))
1057  {
1058  ss++;
1059  while (*ss != _CXML(';'))
1060  {
1061  if ((*ss >= _CXML('0')) && (*ss <= _CXML('9')))
1062  j = (j << 4) + *ss - _CXML('0');
1063  else if ((*ss >= _CXML('A')) && (*ss <= _CXML('F')))
1064  j = (j << 4) + *ss - _CXML('A') + 10;
1065  else if ((*ss >= _CXML('a')) && (*ss <= _CXML('f')))
1066  j = (j << 4) + *ss - _CXML('a') + 10;
1067  else
1068  {
1069  free((void*)s);
1070  pXML->error = eXMLErrorUnknownCharacterEntity;
1071  return nullptr;
1072  }
1073  ss++;
1074  }
1075  }
1076  else
1077  {
1078  while (*ss != _CXML(';'))
1079  {
1080  if ((*ss >= _CXML('0')) && (*ss <= _CXML('9')))
1081  j = (j * 10) + *ss - _CXML('0');
1082  else
1083  {
1084  free((void*)s);
1085  pXML->error = eXMLErrorUnknownCharacterEntity;
1086  return nullptr;
1087  }
1088  ss++;
1089  }
1090  }
1091 #ifndef _XMLWIDECHAR
1092  if (j > 255)
1093  {
1094  free((void*)s);
1095  pXML->error = eXMLErrorCharacterCodeAbove255;
1096  return nullptr;
1097  }
1098 #endif
1099  (*d++) = (XMLCHAR)j;
1100  ss++;
1101  }
1102  else
1103  {
1104  entity = XMLEntities;
1105  do
1106  {
1107  if (xstrnicmp(ss, entity->s, entity->l) == 0)
1108  {
1109  *(d++) = entity->c;
1110  ss += entity->l;
1111  break;
1112  }
1113  entity++;
1114  } while (entity->s);
1115  }
1116  }
1117  else
1118  {
1119 #ifdef _XMLWIDECHAR
1120  *(d++) = *(ss++);
1121 #else
1122  switch (XML_ByteTable[(unsigned char)*ss])
1123  {
1124  case 4:
1125  *(d++) = *(ss++);
1126  ll--;
1127  /*FALLTHROUGH*/
1128  case 3:
1129  *(d++) = *(ss++);
1130  ll--;
1131  /*FALLTHROUGH*/
1132  case 2:
1133  *(d++) = *(ss++);
1134  ll--;
1135  /*FALLTHROUGH*/
1136  case 1:
1137  *(d++) = *(ss++);
1138  /*FALLTHROUGH*/
1139  }
1140 #endif
1141  }
1142  }
1143  *d = 0;
1144  return (XMLSTR)s;
1145 }
1146 
1147 #define XML_isSPACECHAR(ch) \
1148  ((ch == _CXML('\n')) || (ch == _CXML(' ')) || (ch == _CXML('\t')) || \
1149  (ch == _CXML('\r')))
1150 
1151 // private:
1152 char myTagCompare(XMLCSTR cclose, XMLCSTR copen)
1153 // !!!! WARNING strange convention&:
1154 // return 0 if equals
1155 // return 1 if different
1156 {
1157  if (!cclose) return 1;
1158  int l = (int)xstrlen(cclose);
1159  if (xstrnicmp(cclose, copen, l) != 0) return 1;
1160  const XMLCHAR c = copen[l];
1161  if (XML_isSPACECHAR(c) || (c == _CXML('/')) || (c == _CXML('<')) ||
1162  (c == _CXML('>')) || (c == _CXML('=')))
1163  return 0;
1164  return 1;
1165 }
1166 
1167 // Obtain the next character from the string.
1168 static inline XMLCHAR getNextChar(XML* pXML)
1169 {
1170  XMLCHAR ch = pXML->lpXML[pXML->nIndex];
1171 #ifdef _XMLWIDECHAR
1172  if (ch != 0) pXML->nIndex++;
1173 #else
1174  pXML->nIndex += XML_ByteTable[(unsigned char)ch];
1175 #endif
1176  return ch;
1177 }
1178 
1179 // Find the next token in a string.
1180 // pcbToken contains the number of characters that have been read.
1181 static NextToken GetNextToken(
1182  XML* pXML, int* pcbToken, enum XMLTokenTypeTag* pType)
1183 {
1184  NextToken result;
1185  XMLCHAR ch;
1186  XMLCHAR chTemp;
1187  int indexStart, nFoundMatch, nIsText = FALSE;
1188  result.pClr = nullptr; // prevent warning
1189 
1190  // Find next non-white space character
1191  do
1192  {
1193  indexStart = pXML->nIndex;
1194  ch = getNextChar(pXML);
1195  } while XML_isSPACECHAR(ch);
1196 
1197  if (ch)
1198  {
1199  // Cache the current string pointer
1200  result.pStr = &pXML->lpXML[indexStart];
1201 
1202  // First check whether the token is in the clear tag list (meaning it
1203  // does not need formatting).
1204  ALLXMLClearTag* ctag = XMLClearTags;
1205  do
1206  {
1207  if (xstrncmp(ctag->lpszOpen, result.pStr, ctag->openTagLen) == 0)
1208  {
1209  result.pClr = ctag;
1210  pXML->nIndex += ctag->openTagLen - 1;
1211  *pType = eTokenClear;
1212  return result;
1213  }
1214  ctag++;
1215  } while (ctag->lpszOpen);
1216 
1217  // If we didn't find a clear tag then check for standard tokens
1218  switch (ch)
1219  {
1220  // Check for quotes
1221  case _CXML('\''):
1222  case _CXML('\"'):
1223  // Type of token
1224  *pType = eTokenQuotedText;
1225  chTemp = ch;
1226 
1227  // Set the size
1228  nFoundMatch = FALSE;
1229 
1230  // Search through the string to find a matching quote
1231  while ((ch = getNextChar(pXML)))
1232  {
1233  if (ch == chTemp)
1234  {
1235  nFoundMatch = TRUE;
1236  break;
1237  }
1238  if (ch == _CXML('<')) break;
1239  }
1240 
1241  // If we failed to find a matching quote
1242  if (nFoundMatch == FALSE)
1243  {
1244  pXML->nIndex = indexStart + 1;
1245  nIsText = TRUE;
1246  break;
1247  }
1248 
1249  // 4.02.2002
1250  // if (FindNonWhiteSpace(pXML)) pXML->nIndex--;
1251 
1252  break;
1253 
1254  // Equals (used with attribute values)
1255  case _CXML('='):
1256  *pType = eTokenEquals;
1257  break;
1258 
1259  // Close tag
1260  case _CXML('>'):
1261  *pType = eTokenCloseTag;
1262  break;
1263 
1264  // Check for tag start and tag end
1265  case _CXML('<'):
1266 
1267  // Peek at the next character to see if we have an end tag '</',
1268  // or an xml declaration '<?'
1269  chTemp = pXML->lpXML[pXML->nIndex];
1270 
1271  // If we have a tag end...
1272  if (chTemp == _CXML('/'))
1273  {
1274  // Set the type and ensure we point at the next character
1275  getNextChar(pXML);
1276  *pType = eTokenTagEnd;
1277  }
1278 
1279  // If we have an XML declaration tag
1280  else if (chTemp == _CXML('?'))
1281  {
1282  // Set the type and ensure we point at the next character
1283  getNextChar(pXML);
1284  *pType = eTokenDeclaration;
1285  }
1286 
1287  // Otherwise we must have a start tag
1288  else
1289  {
1290  *pType = eTokenTagStart;
1291  }
1292  break;
1293 
1294  // Check to see if we have a short hand type end tag ('/>').
1295  case _CXML('/'):
1296 
1297  // Peek at the next character to see if we have a short end tag
1298  // '/>'
1299  chTemp = pXML->lpXML[pXML->nIndex];
1300 
1301  // If we have a short hand end tag...
1302  if (chTemp == _CXML('>'))
1303  {
1304  // Set the type and ensure we point at the next character
1305  getNextChar(pXML);
1306  *pType = eTokenShortHandClose;
1307  break;
1308  }
1309  /*FALLTHROUGH*/
1310 
1311  // If we haven't found a short hand closing tag then drop into the
1312  // text process
1313 
1314  // Other characters
1315  default:
1316  nIsText = TRUE;
1317  }
1318 
1319  // If this is a TEXT node
1320  if (nIsText)
1321  {
1322  // Indicate we are dealing with text
1323  *pType = eTokenText;
1324  while ((ch = getNextChar(pXML)))
1325  {
1326  if
1327  XML_isSPACECHAR(ch)
1328  {
1329  indexStart++;
1330  break;
1331  }
1332  else if (ch == _CXML('/'))
1333  {
1334  // If we find a slash then this maybe text or a short hand
1335  // end tag
1336  // Peek at the next character to see it we have short hand
1337  // end tag
1338  ch = pXML->lpXML[pXML->nIndex];
1339  // If we found a short hand end tag then we need to exit the
1340  // loop
1341  if (ch == _CXML('>'))
1342  {
1343  pXML->nIndex--;
1344  break;
1345  }
1346  }
1347  else if (
1348  (ch == _CXML('<')) || (ch == _CXML('>')) ||
1349  (ch == _CXML('=')))
1350  {
1351  pXML->nIndex--;
1352  break;
1353  }
1354  }
1355  }
1356  *pcbToken = pXML->nIndex - indexStart;
1357  }
1358  else
1359  {
1360  // If we failed to obtain a valid character
1361  *pcbToken = 0;
1362  *pType = eTokenError;
1363  result.pStr = nullptr;
1364  }
1365 
1366  return result;
1367 }
1368 
1369 XMLCSTR XMLNode::updateName_WOSD(XMLSTR lpszName)
1370 {
1371  if (!d)
1372  {
1373  free(lpszName);
1374  return nullptr;
1375  }
1376  if (d->lpszName && (lpszName != d->lpszName)) free((void*)d->lpszName);
1377  d->lpszName = lpszName;
1378  return lpszName;
1379 }
1380 
1381 // private:
1382 XMLNode::XMLNode(struct XMLNodeDataTag* p)
1383 {
1384  d = p;
1385  (p->ref_count)++;
1386 }
1387 XMLNode::XMLNode(XMLNodeData* pParent, XMLSTR lpszName, char isDeclaration)
1388 {
1389  d = (XMLNodeData*)malloc(sizeof(XMLNodeData));
1390  d->ref_count = 1;
1391 
1392  d->lpszName = nullptr;
1393  d->nChild = 0;
1394  d->nText = 0;
1395  d->nClear = 0;
1396  d->nAttribute = 0;
1397 
1398  d->isDeclaration = isDeclaration;
1399 
1400  d->pParent = pParent;
1401  d->pChild = nullptr;
1402  d->pText = nullptr;
1403  d->pClear = nullptr;
1404  d->pAttribute = nullptr;
1405  d->pOrder = nullptr;
1406 
1407  updateName_WOSD(lpszName);
1408 }
1409 
1410 XMLNode XMLNode::createXMLTopNode_WOSD(XMLSTR lpszName, char isDeclaration)
1411 {
1412  return XMLNode(nullptr, lpszName, isDeclaration);
1413 }
1414 XMLNode XMLNode::createXMLTopNode(XMLCSTR lpszName, char isDeclaration)
1415 {
1416  return XMLNode(nullptr, stringDup(lpszName), isDeclaration);
1417 }
1418 
1419 #define MEMORYINCREASE 50
1420 
1421 static inline void myFree(void* p)
1422 {
1423  if (p) free(p);
1424 }
1425 static inline void* myRealloc(void* p, int newsize, int memInc, int sizeofElem)
1426 {
1427  if (p == nullptr)
1428  {
1429  if (memInc) return malloc(memInc * sizeofElem);
1430  return malloc(sizeofElem);
1431  }
1432  if ((memInc == 0) || ((newsize % memInc) == 0))
1433  p = realloc(p, (newsize + memInc) * sizeofElem);
1434  // if (!p)
1435  // {
1436  // printf("XMLParser Error: Not enough memory! Aborting...\n");
1437  // exit(220);
1438  // }
1439  return p;
1440 }
1441 
1442 // private:
1443 XMLElementPosition XMLNode::findPosition(
1444  XMLNodeData* d, int index, XMLElementType xxtype)
1445 {
1446  if (index < 0) return -1;
1447  int i = 0, j = (int)((index << 2) + xxtype), *o = d->pOrder;
1448  while (o[i] != j) i++;
1449  return i;
1450 }
1451 
1452 // private:
1453 // update "order" information when deleting a content of a XMLNode
1454 int XMLNode::removeOrderElement(XMLNodeData* d, XMLElementType t, int index)
1455 {
1456  int n = d->nChild + d->nText + d->nClear, *o = d->pOrder,
1457  i = findPosition(d, index, t);
1458  memmove(o + i, o + i + 1, (n - i) * sizeof(int));
1459  for (; i < n; i++)
1460  if ((o[i] & 3) == (int)t) o[i] -= 4;
1461  // We should normally do:
1462  // d->pOrder=(int)realloc(d->pOrder,n*sizeof(int));
1463  // but we skip reallocation because it's too time consuming.
1464  // Anyway, at the end, it will be free'd completely at once.
1465  return i;
1466 }
1467 
1468 void* XMLNode::addToOrder(
1469  int memoryIncrease, int* _pos, int nc, void* p, int size,
1470  XMLElementType xtype)
1471 {
1472  // in: *_pos is the position inside d->pOrder ("-1" means "EndOf")
1473  // out: *_pos is the index inside p
1474  p = myRealloc(p, (nc + 1), memoryIncrease, size);
1475  int n = d->nChild + d->nText + d->nClear;
1476  d->pOrder =
1477  (int*)myRealloc(d->pOrder, n + 1, memoryIncrease * 3, sizeof(int));
1478  int pos = *_pos, *o = d->pOrder;
1479 
1480  if ((pos < 0) || (pos >= n))
1481  {
1482  *_pos = nc;
1483  o[n] = (int)((nc << 2) + xtype);
1484  return p;
1485  }
1486 
1487  int i = pos;
1488  memmove(o + i + 1, o + i, (n - i) * sizeof(int));
1489 
1490  while ((pos < n) && ((o[pos] & 3) != (int)xtype)) pos++;
1491  if (pos == n)
1492  {
1493  *_pos = nc;
1494  o[n] = (int)((nc << 2) + xtype);
1495  return p;
1496  }
1497 
1498  o[i] = o[pos];
1499  for (i = pos + 1; i <= n; i++)
1500  if ((o[i] & 3) == (int)xtype) o[i] += 4;
1501 
1502  *_pos = pos = o[pos] >> 2;
1503  memmove(
1504  ((char*)p) + (pos + 1) * size, ((char*)p) + pos * size,
1505  (nc - pos) * size);
1506 
1507  return p;
1508 }
1509 
1510 // Add a child node to the given element.
1511 XMLNode XMLNode::addChild_priv(
1512  int memoryIncrease, XMLSTR lpszName, char isDeclaration, int pos)
1513 {
1514  if (!lpszName) return emptyXMLNode;
1515  d->pChild = (XMLNode*)addToOrder(
1516  memoryIncrease, &pos, d->nChild, d->pChild, sizeof(XMLNode),
1517  eNodeChild);
1518  d->pChild[pos].d = nullptr;
1519  d->pChild[pos] = XMLNode(d, lpszName, isDeclaration);
1520  d->nChild++;
1521  return d->pChild[pos];
1522 }
1523 
1524 // Add an attribute to an element.
1525 XMLAttribute* XMLNode::addAttribute_priv(
1526  int memoryIncrease, XMLSTR lpszName, XMLSTR lpszValuev)
1527 {
1528  if (!lpszName) return &emptyXMLAttribute;
1529  if (!d)
1530  {
1531  myFree(lpszName);
1532  myFree(lpszValuev);
1533  return &emptyXMLAttribute;
1534  }
1535  int nc = d->nAttribute;
1536  d->pAttribute = (XMLAttribute*)myRealloc(
1537  d->pAttribute, (nc + 1), memoryIncrease, sizeof(XMLAttribute));
1538  XMLAttribute* pAttr = d->pAttribute + nc;
1539  pAttr->lpszName = lpszName;
1540  pAttr->lpszValue = lpszValuev;
1541  d->nAttribute++;
1542  return pAttr;
1543 }
1544 
1545 // Add text to the element.
1546 XMLCSTR XMLNode::addText_priv(int memoryIncrease, XMLSTR lpszValue, int pos)
1547 {
1548  if (!lpszValue) return nullptr;
1549  if (!d)
1550  {
1551  myFree(lpszValue);
1552  return nullptr;
1553  }
1554  d->pText = (XMLCSTR*)addToOrder(
1555  memoryIncrease, &pos, d->nText, d->pText, sizeof(XMLSTR), eNodeText);
1556  d->pText[pos] = lpszValue;
1557  d->nText++;
1558  return lpszValue;
1559 }
1560 
1561 // Add clear (unformatted) text to the element.
1562 XMLClear* XMLNode::addClear_priv(
1563  int memoryIncrease, XMLSTR lpszValue, XMLCSTR lpszOpen, XMLCSTR lpszClose,
1564  int pos)
1565 {
1566  if (!lpszValue) return &emptyXMLClear;
1567  if (!d)
1568  {
1569  myFree(lpszValue);
1570  return &emptyXMLClear;
1571  }
1572  d->pClear = (XMLClear*)addToOrder(
1573  memoryIncrease, &pos, d->nClear, d->pClear, sizeof(XMLClear),
1574  eNodeClear);
1575  XMLClear* pNewClear = d->pClear + pos;
1576  pNewClear->lpszValue = lpszValue;
1577  if (!lpszOpen) lpszOpen = XMLClearTags->lpszOpen;
1578  if (!lpszClose) lpszClose = XMLClearTags->lpszClose;
1579  pNewClear->lpszOpenTag = lpszOpen;
1580  pNewClear->lpszCloseTag = lpszClose;
1581  d->nClear++;
1582  return pNewClear;
1583 }
1584 
1585 // private:
1586 // Parse a clear (unformatted) type node.
1587 char XMLNode::parseClearTag(void* px, void* _pClear)
1588 {
1589  XML* pXML = (XML*)px;
1590  ALLXMLClearTag pClear = *((ALLXMLClearTag*)_pClear);
1591  int cbTemp = 0;
1592  XMLCSTR lpszTemp = nullptr;
1593  XMLCSTR lpXML = &pXML->lpXML[pXML->nIndex];
1594  static XMLCSTR docTypeEnd = _CXML("]>");
1595 
1596  // Find the closing tag
1597  // Seems the <!DOCTYPE need a better treatment so lets handle it
1598  if (pClear.lpszOpen == XMLClearTags[1].lpszOpen)
1599  {
1600  XMLCSTR pCh = lpXML;
1601  while (*pCh)
1602  {
1603  if (*pCh == _CXML('<'))
1604  {
1605  pClear.lpszClose = docTypeEnd;
1606  lpszTemp = xstrstr(lpXML, docTypeEnd);
1607  break;
1608  }
1609  else if (*pCh == _CXML('>'))
1610  {
1611  lpszTemp = pCh;
1612  break;
1613  }
1614 #ifdef _XMLWIDECHAR
1615  pCh++;
1616 #else
1617  pCh += XML_ByteTable[(unsigned char)(*pCh)];
1618 #endif
1619  }
1620  }
1621  else
1622  lpszTemp = xstrstr(lpXML, pClear.lpszClose);
1623 
1624  if (lpszTemp)
1625  {
1626  // Cache the size and increment the index
1627  cbTemp = (int)(lpszTemp - lpXML);
1628 
1629  pXML->nIndex += cbTemp + (int)xstrlen(pClear.lpszClose);
1630 
1631  // Add the clear node to the current element
1632  addClear_priv(
1633  MEMORYINCREASE, stringDup(lpXML, cbTemp), pClear.lpszOpen,
1634  pClear.lpszClose, -1);
1635  return 0;
1636  }
1637 
1638  // If we failed to find the end tag
1639  pXML->error = eXMLErrorUnmatchedEndClearTag;
1640  return 1;
1641 }
1642 
1643 void XMLNode::exactMemory(XMLNodeData* d)
1644 {
1645  if (d->pOrder)
1646  d->pOrder = (int*)realloc(
1647  d->pOrder, (d->nChild + d->nText + d->nClear) * sizeof(int));
1648  if (d->pChild)
1649  d->pChild = (XMLNode*)realloc(d->pChild, d->nChild * sizeof(XMLNode));
1650  if (d->pAttribute)
1651  d->pAttribute = (XMLAttribute*)realloc(
1652  d->pAttribute, d->nAttribute * sizeof(XMLAttribute));
1653  if (d->pText)
1654  d->pText = (XMLCSTR*)realloc(d->pText, d->nText * sizeof(XMLSTR));
1655  if (d->pClear)
1656  d->pClear = (XMLClear*)realloc(d->pClear, d->nClear * sizeof(XMLClear));
1657 }
1658 
1659 char XMLNode::maybeAddTxT(void* pa, XMLCSTR tokenPStr)
1660 {
1661  XML* pXML = (XML*)pa;
1662  XMLCSTR lpszText = pXML->lpszText;
1663  if (!lpszText) return 0;
1664  if (dropWhiteSpace)
1665  while (XML_isSPACECHAR(*lpszText) && (lpszText != tokenPStr))
1666  lpszText++;
1667  int cbText = (int)(tokenPStr - lpszText);
1668  if (!cbText)
1669  {
1670  pXML->lpszText = nullptr;
1671  return 0;
1672  }
1673  if (dropWhiteSpace)
1674  {
1675  cbText--;
1676  while ((cbText) && XML_isSPACECHAR(lpszText[cbText])) cbText--;
1677  cbText++;
1678  }
1679  if (!cbText)
1680  {
1681  pXML->lpszText = nullptr;
1682  return 0;
1683  }
1684  XMLSTR lpt = fromXMLString(lpszText, cbText, pXML);
1685  if (!lpt) return 1;
1686  pXML->lpszText = nullptr;
1687  if (removeCommentsInMiddleOfText && d->nText && d->nClear)
1688  {
1689  // if the previous insertion was a comment (<!-- -->) AND
1690  // if the previous previous insertion was a text then, delete the
1691  // comment and append the text
1692  int n = d->nChild + d->nText + d->nClear - 1, *o = d->pOrder;
1693  if (((o[n] & 3) == eNodeClear) && ((o[n - 1] & 3) == eNodeText))
1694  {
1695  int i = o[n] >> 2;
1696  if (d->pClear[i].lpszOpenTag == XMLClearTags[2].lpszOpen)
1697  {
1698  deleteClear(i);
1699  i = o[n - 1] >> 2;
1700  n = xstrlen(d->pText[i]);
1701  int n2 = xstrlen(lpt) + 1;
1702  d->pText[i] = (XMLSTR)realloc(
1703  (void*)d->pText[i], (n + n2) * sizeof(XMLCHAR));
1704  if (!d->pText[i]) return 1;
1705  memcpy((void*)(d->pText[i] + n), lpt, n2 * sizeof(XMLCHAR));
1706  free(lpt);
1707  return 0;
1708  }
1709  }
1710  }
1711  addText_priv(MEMORYINCREASE, lpt, -1);
1712  return 0;
1713 }
1714 // private:
1715 // Recursively parse an XML element.
1716 int XMLNode::ParseXMLElement(void* pa)
1717 {
1718  XML* pXML = (XML*)pa;
1719  int cbToken;
1720  enum XMLTokenTypeTag xtype;
1721  NextToken token;
1722  XMLCSTR lpszTemp = nullptr;
1723  int cbTemp = 0;
1724  char nDeclaration;
1725  XMLNode pNew;
1726  enum Status status; // inside or outside a tag
1727  enum Attrib attrib = eAttribName;
1728 
1729  assert(pXML);
1730 
1731  // If this is the first call to the function
1732  if (pXML->nFirst)
1733  {
1734  // Assume we are outside of a tag definition
1735  pXML->nFirst = FALSE;
1736  status = eOutsideTag;
1737  }
1738  else
1739  {
1740  // If this is not the first call then we should only be called when
1741  // inside a tag.
1742  status = eInsideTag;
1743  }
1744 
1745  // Iterate through the tokens in the document
1746  for (;;)
1747  {
1748  // Obtain the next token
1749  token = GetNextToken(pXML, &cbToken, &xtype);
1750 
1751  if (xtype != eTokenError)
1752  {
1753  // Check the current status
1754  switch (status)
1755  {
1756  // If we are outside of a tag definition
1757  case eOutsideTag:
1758 
1759  // Check what type of token we obtained
1760  switch (xtype)
1761  {
1762  // If we have found text or quoted text
1763  case eTokenText:
1764  case eTokenCloseTag: /* '>' */
1765  case eTokenShortHandClose: /* '/>' */
1766  case eTokenQuotedText:
1767  case eTokenEquals:
1768  break;
1769 
1770  // If we found a start tag '<' and declarations '<?'
1771  case eTokenTagStart:
1772  case eTokenDeclaration:
1773 
1774  // Cache whether this new element is a declaration
1775  // or not
1776  nDeclaration = (xtype == eTokenDeclaration);
1777 
1778  // If we have node text then add this to the element
1779  if (maybeAddTxT(pXML, token.pStr)) return FALSE;
1780 
1781  // Find the name of the tag
1782  token = GetNextToken(pXML, &cbToken, &xtype);
1783 
1784  // Return an error if we couldn't obtain the next
1785  // token or
1786  // it wasnt text
1787  if (xtype != eTokenText)
1788  {
1789  pXML->error = eXMLErrorMissingTagName;
1790  return FALSE;
1791  }
1792 
1793 // If we found a new element which is the same as this
1794 // element then we need to pass this back to the caller..
1795 
1796 #ifdef APPROXIMATE_PARSING
1797  if (d->lpszName &&
1798  myTagCompare(d->lpszName, token.pStr) == 0)
1799  {
1800  // Indicate to the caller that it needs to
1801  // create a
1802  // new element.
1803  pXML->lpNewElement = token.pStr;
1804  pXML->cbNewElement = cbToken;
1805  return TRUE;
1806  }
1807  else
1808 #endif
1809  {
1810  // If the name of the new element differs from
1811  // the name of
1812  // the current element we need to add the new
1813  // element to
1814  // the current one and recurse
1815  pNew = addChild_priv(
1816  MEMORYINCREASE,
1817  stringDup(token.pStr, cbToken),
1818  nDeclaration, -1);
1819 
1820  while (!pNew.isEmpty())
1821  {
1822  // Callself to process the new node. If we
1823  // return
1824  // FALSE this means we dont have any more
1825  // processing to do...
1826 
1827  if (!pNew.ParseXMLElement(pXML))
1828  return FALSE;
1829  else
1830  {
1831  // If the call to recurse this function
1832  // evented in a end tag specified in XML
1833  // then
1834  // we need to unwind the calls to this
1835  // function until we find the
1836  // appropriate node
1837  // (the element name and end tag name
1838  // must
1839  // match)
1840  if (pXML->cbEndTag)
1841  {
1842  // If we are back at the root node
1843  // then we
1844  // have an unmatched end tag
1845  if (!d->lpszName)
1846  {
1847  pXML->error =
1848  eXMLErrorUnmatchedEndTag;
1849  return FALSE;
1850  }
1851 
1852  // If the end tag matches the name
1853  // of this
1854  // element then we only need to
1855  // unwind
1856  // once more...
1857 
1858  if (myTagCompare(
1859  d->lpszName,
1860  pXML->lpEndTag) == 0)
1861  {
1862  pXML->cbEndTag = 0;
1863  }
1864 
1865  return TRUE;
1866  }
1867  else if (pXML->cbNewElement)
1868  {
1869  // If the call indicated a new
1870  // element is to
1871  // be created on THIS element.
1872 
1873  // If the name of this element
1874  // matches the
1875  // name of the element we need to
1876  // create
1877  // then we need to return to the
1878  // caller
1879  // and let it process the element.
1880 
1881  if (myTagCompare(
1882  d->lpszName,
1883  pXML->lpNewElement) == 0)
1884  {
1885  return TRUE;
1886  }
1887 
1888  // Add the new element and recurse
1889  pNew = addChild_priv(
1890  MEMORYINCREASE,
1891  stringDup(
1892  pXML->lpNewElement,
1893  pXML->cbNewElement),
1894  0, -1);
1895  pXML->cbNewElement = 0;
1896  }
1897  else
1898  {
1899  // If we didn't have a new element
1900  // to create
1901  pNew = emptyXMLNode;
1902  }
1903  }
1904  }
1905  }
1906  break;
1907 
1908  // If we found an end tag
1909  case eTokenTagEnd:
1910 
1911  // If we have node text then add this to the element
1912  if (maybeAddTxT(pXML, token.pStr)) return FALSE;
1913 
1914  // Find the name of the end tag
1915  token = GetNextToken(pXML, &cbTemp, &xtype);
1916 
1917  // The end tag should be text
1918  if (xtype != eTokenText)
1919  {
1920  pXML->error = eXMLErrorMissingEndTagName;
1921  return FALSE;
1922  }
1923  lpszTemp = token.pStr;
1924 
1925  // After the end tag we should find a closing tag
1926  token = GetNextToken(pXML, &cbToken, &xtype);
1927  if (xtype != eTokenCloseTag)
1928  {
1929  pXML->error = eXMLErrorMissingEndTagName;
1930  return FALSE;
1931  }
1932  pXML->lpszText = pXML->lpXML + pXML->nIndex;
1933 
1934  // We need to return to the previous caller. If the
1935  // name
1936  // of the tag cannot be found we need to keep
1937  // returning to
1938  // caller until we find a match
1939  if (myTagCompare(d->lpszName, lpszTemp) != 0)
1940 #ifdef STRICT_PARSING
1941  {
1942  pXML->error = eXMLErrorUnmatchedEndTag;
1943  pXML->nIndexMissigEndTag = pXML->nIndex;
1944  return FALSE;
1945  }
1946 #else
1947  {
1948  pXML->error = eXMLErrorMissingEndTag;
1949  pXML->nIndexMissigEndTag = pXML->nIndex;
1950  pXML->lpEndTag = lpszTemp;
1951  pXML->cbEndTag = cbTemp;
1952  }
1953 #endif
1954 
1955  // Return to the caller
1956  exactMemory(d);
1957  return TRUE;
1958 
1959  // If we found a clear (unformatted) token
1960  case eTokenClear:
1961  // If we have node text then add this to the element
1962  if (maybeAddTxT(pXML, token.pStr)) return FALSE;
1963  if (parseClearTag(pXML, token.pClr)) return FALSE;
1964  pXML->lpszText = pXML->lpXML + pXML->nIndex;
1965  break;
1966 
1967  default:
1968  break;
1969  }
1970  break;
1971 
1972  // If we are inside a tag definition we need to search for
1973  // attributes
1974  case eInsideTag:
1975 
1976  // Check what part of the attribute (name, equals, value) we
1977  // are looking for.
1978  switch (attrib)
1979  {
1980  // If we are looking for a new attribute
1981  case eAttribName:
1982 
1983  // Check what the current token type is
1984  switch (xtype)
1985  {
1986  // If the current type is text...
1987  // Eg. 'attribute'
1988  case eTokenText:
1989  // Cache the token then indicate that we are
1990  // next to
1991  // look for the equals
1992  lpszTemp = token.pStr;
1993  cbTemp = cbToken;
1994  attrib = eAttribEquals;
1995  break;
1996 
1997  // If we found a closing tag...
1998  // Eg. '>'
1999  case eTokenCloseTag:
2000  // We are now outside the tag
2001  status = eOutsideTag;
2002  pXML->lpszText = pXML->lpXML + pXML->nIndex;
2003  break;
2004 
2005  // If we found a short hand '/>' closing tag
2006  // then we can
2007  // return to the caller
2008  case eTokenShortHandClose:
2009  exactMemory(d);
2010  pXML->lpszText = pXML->lpXML + pXML->nIndex;
2011  return TRUE;
2012 
2013  // Errors...
2014  case eTokenQuotedText: /* '"SomeText"' */
2015  case eTokenTagStart: /* '<' */
2016  case eTokenTagEnd: /* '</' */
2017  case eTokenEquals: /* '=' */
2018  case eTokenDeclaration: /* '<?' */
2019  case eTokenClear:
2020  pXML->error = eXMLErrorUnexpectedToken;
2021  return FALSE;
2022  default:
2023  break;
2024  }
2025  break;
2026 
2027  // If we are looking for an equals
2028  case eAttribEquals:
2029  // Check what the current token type is
2030  switch (xtype)
2031  {
2032  // If the current type is text...
2033  // Eg. 'Attribute AnotherAttribute'
2034  case eTokenText:
2035  // Add the unvalued attribute to the list
2036  addAttribute_priv(
2037  MEMORYINCREASE,
2038  stringDup(lpszTemp, cbTemp), nullptr);
2039  // Cache the token then indicate. We are
2040  // next to
2041  // look for the equals attribute
2042  lpszTemp = token.pStr;
2043  cbTemp = cbToken;
2044  break;
2045 
2046  // If we found a closing tag 'Attribute >' or a
2047  // short hand
2048  // closing tag 'Attribute />'
2049  case eTokenShortHandClose:
2050  case eTokenCloseTag:
2051  // If we are a declaration element '<?' then
2052  // we need
2053  // to remove extra closing '?' if it exists
2054  pXML->lpszText = pXML->lpXML + pXML->nIndex;
2055 
2056  if (d->isDeclaration &&
2057  (lpszTemp[cbTemp - 1]) == _CXML('?'))
2058  {
2059  cbTemp--;
2060  if (d->pParent && d->pParent->pParent)
2061  xtype = eTokenShortHandClose;
2062  }
2063 
2064  if (cbTemp)
2065  {
2066  // Add the unvalued attribute to the
2067  // list
2068  addAttribute_priv(
2069  MEMORYINCREASE,
2070  stringDup(lpszTemp, cbTemp),
2071  nullptr);
2072  }
2073 
2074  // If this is the end of the tag then return
2075  // to the caller
2076  if (xtype == eTokenShortHandClose)
2077  {
2078  exactMemory(d);
2079  return TRUE;
2080  }
2081 
2082  // We are now outside the tag
2083  status = eOutsideTag;
2084  break;
2085 
2086  // If we found the equals token...
2087  // Eg. 'Attribute ='
2088  case eTokenEquals:
2089  // Indicate that we next need to search for
2090  // the value
2091  // for the attribute
2092  attrib = eAttribValue;
2093  break;
2094 
2095  // Errors...
2096  case eTokenQuotedText: /* 'Attribute
2097  "InvalidAttr"'*/
2098  case eTokenTagStart: /* 'Attribute <' */
2099  case eTokenTagEnd: /* 'Attribute </' */
2100  case eTokenDeclaration: /* 'Attribute <?' */
2101  case eTokenClear:
2102  pXML->error = eXMLErrorUnexpectedToken;
2103  return FALSE;
2104  default:
2105  break;
2106  }
2107  break;
2108 
2109  // If we are looking for an attribute value
2110  case eAttribValue:
2111  // Check what the current token type is
2112  switch (xtype)
2113  {
2114  // If the current type is text or quoted text...
2115  // Eg. 'Attribute = "Value"' or 'Attribute =
2116  // Value' or
2117  // 'Attribute = 'Value''.
2118  case eTokenText:
2119  case eTokenQuotedText:
2120  // If we are a declaration element '<?' then
2121  // we need
2122  // to remove extra closing '?' if it exists
2123  if (d->isDeclaration &&
2124  (token.pStr[cbToken - 1]) == _CXML('?'))
2125  {
2126  cbToken--;
2127  }
2128 
2129  if (cbTemp)
2130  {
2131  // Add the valued attribute to the list
2132  if (xtype == eTokenQuotedText)
2133  {
2134  token.pStr++;
2135  cbToken -= 2;
2136  }
2137  XMLSTR attrVal = (XMLSTR)token.pStr;
2138  if (attrVal)
2139  {
2140  attrVal = fromXMLString(
2141  attrVal, cbToken, pXML);
2142  if (!attrVal) return FALSE;
2143  }
2144  addAttribute_priv(
2145  MEMORYINCREASE,
2146  stringDup(lpszTemp, cbTemp),
2147  attrVal);
2148  }
2149 
2150  // Indicate we are searching for a new
2151  // attribute
2152  attrib = eAttribName;
2153  break;
2154 
2155  // Errors...
2156  case eTokenTagStart: /* 'Attr = <' */
2157  case eTokenTagEnd: /* 'Attr = </' */
2158  case eTokenCloseTag: /* 'Attr = >' */
2159  case eTokenShortHandClose: /* "Attr = />" */
2160  case eTokenEquals: /* 'Attr = =' */
2161  case eTokenDeclaration: /* 'Attr = <?' */
2162  case eTokenClear:
2163  pXML->error = eXMLErrorUnexpectedToken;
2164  return FALSE;
2165  break;
2166  default:
2167  break;
2168  }
2169  }
2170  }
2171  }
2172  // If we failed to obtain the next token
2173  else
2174  {
2175  if ((!d->isDeclaration) && (d->pParent))
2176  {
2177 #ifdef STRICT_PARSING
2178  pXML->error = eXMLErrorUnmatchedEndTag;
2179 #else
2180  pXML->error = eXMLErrorMissingEndTag;
2181 #endif
2182  pXML->nIndexMissigEndTag = pXML->nIndex;
2183  }
2184  maybeAddTxT(pXML, pXML->lpXML + pXML->nIndex);
2185  return FALSE;
2186  }
2187  }
2188 }
2189 
2190 // Count the number of lines and columns in an XML string.
2191 static void CountLinesAndColumns(XMLCSTR lpXML, int nUpto, XMLResults* pResults)
2192 {
2193  XMLCHAR ch;
2194  assert(lpXML);
2195  assert(pResults);
2196 
2197  struct XML xml = {lpXML, lpXML, 0, 0, eXMLErrorNone,
2198  nullptr, 0, nullptr, 0, TRUE};
2199 
2200  pResults->nLine = 1;
2201  pResults->nColumn = 1;
2202  while (xml.nIndex < nUpto)
2203  {
2204  ch = getNextChar(&xml);
2205  if (ch != _CXML('\n'))
2206  pResults->nColumn++;
2207  else
2208  {
2209  pResults->nLine++;
2210  pResults->nColumn = 1;
2211  }
2212  }
2213 }
2214 
2215 // Parse XML and return the root element.
2216 XMLNode XMLNode::parseString(XMLCSTR lpszXML, XMLCSTR tag, XMLResults* pResults)
2217 {
2218  if (!lpszXML)
2219  {
2220  if (pResults)
2221  {
2222  pResults->error = eXMLErrorNoElements;
2223  pResults->nLine = 0;
2224  pResults->nColumn = 0;
2225  }
2226  return emptyXMLNode;
2227  }
2228 
2229  XMLNode xnode(nullptr, nullptr, FALSE);
2230  struct XML xml = {lpszXML, lpszXML, 0, 0, eXMLErrorNone,
2231  nullptr, 0, nullptr, 0, TRUE};
2232 
2233  // Create header element
2234  xnode.ParseXMLElement(&xml);
2235  enum XMLError error = xml.error;
2236  if (!xnode.nChildNode()) error = eXMLErrorNoXMLTagFound;
2237  if ((xnode.nChildNode() == 1) && (xnode.nElement() == 1))
2238  xnode = xnode.getChildNode(); // skip the empty node
2239 
2240  // If no error occurred
2241  if ((error == eXMLErrorNone) || (error == eXMLErrorMissingEndTag) ||
2242  (error == eXMLErrorNoXMLTagFound))
2243  {
2244  XMLCSTR name = xnode.getName();
2245  if (tag && (*tag) && ((!name) || (xstricmp(name, tag))))
2246  {
2247  xnode = xnode.getChildNode(tag);
2248  if (xnode.isEmpty())
2249  {
2250  if (pResults)
2251  {
2252  pResults->error = eXMLErrorFirstTagNotFound;
2253  pResults->nLine = 0;
2254  pResults->nColumn = 0;
2255  }
2256  return emptyXMLNode;
2257  }
2258  }
2259  }
2260  else
2261  {
2262  // Cleanup: this will destroy all the nodes
2263  xnode = emptyXMLNode;
2264  }
2265 
2266  // If we have been given somewhere to place results
2267  if (pResults)
2268  {
2269  pResults->error = error;
2270 
2271  // If we have an error
2272  if (error != eXMLErrorNone)
2273  {
2274  if (error == eXMLErrorMissingEndTag)
2275  xml.nIndex = xml.nIndexMissigEndTag;
2276  // Find which line and column it starts on.
2277  CountLinesAndColumns(xml.lpXML, xml.nIndex, pResults);
2278  }
2279  }
2280  return xnode;
2281 }
2282 
2283 XMLNode XMLNode::parseFile(XMLCSTR filename, XMLCSTR tag, XMLResults* pResults)
2284 {
2285  if (pResults)
2286  {
2287  pResults->nLine = 0;
2288  pResults->nColumn = 0;
2289  }
2290  FILE* f = xfopen(filename, _CXML("rb"));
2291  if (f == nullptr)
2292  {
2293  if (pResults) pResults->error = eXMLErrorFileNotFound;
2294  return emptyXMLNode;
2295  }
2296  fseek(f, 0, SEEK_END);
2297  int l = ftell(f), headerSz = 0;
2298  if (!l)
2299  {
2300  if (pResults) pResults->error = eXMLErrorEmpty;
2301  fclose(f);
2302  return emptyXMLNode;
2303  }
2304  fseek(f, 0, SEEK_SET);
2305  unsigned char* buf = (unsigned char*)malloc(l + 4);
2306  int really_read = (int)fread(buf, 1, l, f); // JLBC
2307  if (really_read != l) buf[0] = '\0';
2308  fclose(f);
2309  buf[l] = 0;
2310  buf[l + 1] = 0;
2311  buf[l + 2] = 0;
2312  buf[l + 3] = 0;
2313 #ifdef _XMLWIDECHAR
2314  if (guessWideCharChars)
2315  {
2316  if (!myIsTextWideChar(buf, l))
2317  {
2318  XMLNode::XMLCharEncoding ce = XMLNode::char_encoding_legacy;
2319  if ((buf[0] == 0xef) && (buf[1] == 0xbb) && (buf[2] == 0xbf))
2320  {
2321  headerSz = 3;
2322  ce = XMLNode::char_encoding_UTF8;
2323  }
2324  XMLSTR b2 =
2325  myMultiByteToWideChar((const char*)(buf + headerSz), ce);
2326  free(buf);
2327  buf = (unsigned char*)b2;
2328  headerSz = 0;
2329  }
2330  else
2331  {
2332  if ((buf[0] == 0xef) && (buf[1] == 0xff)) headerSz = 2;
2333  if ((buf[0] == 0xff) && (buf[1] == 0xfe)) headerSz = 2;
2334  }
2335  }
2336 #else
2337  if (guessWideCharChars)
2338  {
2339  if (myIsTextWideChar(buf, l))
2340  {
2341  if ((buf[0] == 0xef) && (buf[1] == 0xff)) headerSz = 2;
2342  if ((buf[0] == 0xff) && (buf[1] == 0xfe)) headerSz = 2;
2343  char* b2 = myWideCharToMultiByte((const wchar_t*)(buf + headerSz));
2344  free(buf);
2345  buf = (unsigned char*)b2;
2346  headerSz = 0;
2347  }
2348  else
2349  {
2350  if ((buf[0] == 0xef) && (buf[1] == 0xbb) && (buf[2] == 0xbf))
2351  headerSz = 3;
2352  }
2353  }
2354 #endif
2355 
2356  if (!buf)
2357  {
2358  if (pResults) pResults->error = eXMLErrorCharConversionError;
2359  return emptyXMLNode;
2360  }
2361  XMLNode x = parseString((XMLSTR)(buf + headerSz), tag, pResults);
2362  free(buf);
2363  return x;
2364 }
2365 
2366 static inline void charmemset(XMLSTR dest, XMLCHAR c, int l)
2367 {
2368  while (l--) *(dest++) = c;
2369 }
2370 // private:
2371 // Creates an user friendly XML string from a given element with
2372 // appropriate white space and carriage returns.
2373 //
2374 // This recurses through all subnodes then adds contents of the nodes to the
2375 // string.
2376 int XMLNode::CreateXMLStringR(
2377  XMLNodeData* pEntry, XMLSTR lpszMarker, int nFormat)
2378 {
2379  int nResult = 0;
2380  int cb = nFormat < 0 ? 0 : nFormat;
2381  int cbElement;
2382  int nChildFormat = -1;
2383  int nElementI = pEntry->nChild + pEntry->nText + pEntry->nClear;
2384  int i, j;
2385  if ((nFormat >= 0) && (nElementI == 1) && (pEntry->nText == 1) &&
2386  (!pEntry->isDeclaration))
2387  nFormat = -2;
2388 
2389  assert(pEntry);
2390 
2391 #define LENSTR(lpsz) (lpsz ? xstrlen(lpsz) : 0)
2392 
2393  // If the element has no name then assume this is the head node.
2394  cbElement = (int)LENSTR(pEntry->lpszName);
2395 
2396  if (cbElement)
2397  {
2398  // "<elementname "
2399  if (lpszMarker)
2400  {
2401  if (cb) charmemset(lpszMarker, INDENTCHAR, cb);
2402  nResult = cb;
2403  lpszMarker[nResult++] = _CXML('<');
2404  if (pEntry->isDeclaration) lpszMarker[nResult++] = _CXML('?');
2405  xstrcpy(&lpszMarker[nResult], pEntry->lpszName);
2406  nResult += cbElement;
2407  lpszMarker[nResult++] = _CXML(' ');
2408  }
2409  else
2410  {
2411  nResult += cbElement + 2 + cb;
2412  if (pEntry->isDeclaration) nResult++;
2413  }
2414 
2415  // Enumerate attributes and add them to the string
2416  XMLAttribute* pAttr = pEntry->pAttribute;
2417  for (i = 0; i < pEntry->nAttribute; i++)
2418  {
2419  // "Attrib
2420  cb = (int)LENSTR(pAttr->lpszName);
2421  if (cb)
2422  {
2423  if (lpszMarker) xstrcpy(&lpszMarker[nResult], pAttr->lpszName);
2424  nResult += cb;
2425  // "Attrib=Value "
2426  if (pAttr->lpszValue)
2427  {
2428  cb =
2429  (int)ToXMLStringTool::lengthXMLString(pAttr->lpszValue);
2430  if (lpszMarker)
2431  {
2432  lpszMarker[nResult] = _CXML('=');
2433  lpszMarker[nResult + 1] = _CXML('"');
2434  if (cb)
2435  ToXMLStringTool::toXMLUnSafe(
2436  &lpszMarker[nResult + 2], pAttr->lpszValue);
2437  lpszMarker[nResult + cb + 2] = _CXML('"');
2438  }
2439  nResult += cb + 3;
2440  }
2441  if (lpszMarker) lpszMarker[nResult] = _CXML(' ');
2442  nResult++;
2443  }
2444  pAttr++;
2445  }
2446 
2447  if (pEntry->isDeclaration)
2448  {
2449  if (lpszMarker)
2450  {
2451  lpszMarker[nResult - 1] = _CXML('?');
2452  lpszMarker[nResult] = _CXML('>');
2453  }
2454  nResult++;
2455  if (nFormat != -1)
2456  {
2457  if (lpszMarker) lpszMarker[nResult] = _CXML('\n');
2458  nResult++;
2459  }
2460  }
2461  else
2462  // If there are child nodes we need to terminate the start tag
2463  if (nElementI)
2464  {
2465  if (lpszMarker) lpszMarker[nResult - 1] = _CXML('>');
2466  if (nFormat >= 0)
2467  {
2468  if (lpszMarker) lpszMarker[nResult] = _CXML('\n');
2469  nResult++;
2470  }
2471  }
2472  else
2473  nResult--;
2474  }
2475 
2476  // Calculate the child format for when we recurse. This is used to
2477  // determine the number of spaces used for prefixes.
2478  if (nFormat != -1)
2479  {
2480  if (cbElement && (!pEntry->isDeclaration))
2481  nChildFormat = nFormat + 1;
2482  else
2483  nChildFormat = nFormat;
2484  }
2485 
2486  // Enumerate through remaining children
2487  for (i = 0; i < nElementI; i++)
2488  {
2489  j = pEntry->pOrder[i];
2490  switch ((XMLElementType)(j & 3))
2491  {
2492  // Text nodes
2493  case eNodeText:
2494  {
2495  // "Text"
2496  XMLCSTR pChild = pEntry->pText[j >> 2];
2497  cb = (int)ToXMLStringTool::lengthXMLString(pChild);
2498  if (cb)
2499  {
2500  if (nFormat >= 0)
2501  {
2502  if (lpszMarker)
2503  {
2504  charmemset(
2505  &lpszMarker[nResult], INDENTCHAR, nFormat + 1);
2506  ToXMLStringTool::toXMLUnSafe(
2507  &lpszMarker[nResult + nFormat + 1], pChild);
2508  lpszMarker[nResult + nFormat + 1 + cb] =
2509  _CXML('\n');
2510  }
2511  nResult += cb + nFormat + 2;
2512  }
2513  else
2514  {
2515  if (lpszMarker)
2516  ToXMLStringTool::toXMLUnSafe(
2517  &lpszMarker[nResult], pChild);
2518  nResult += cb;
2519  }
2520  }
2521  break;
2522  }
2523 
2524  // Clear type nodes
2525  case eNodeClear:
2526  {
2527  XMLClear* pChild = pEntry->pClear + (j >> 2);
2528  // "OpenTag"
2529  cb = (int)LENSTR(pChild->lpszOpenTag);
2530  if (cb)
2531  {
2532  if (nFormat != -1)
2533  {
2534  if (lpszMarker)
2535  {
2536  charmemset(
2537  &lpszMarker[nResult], INDENTCHAR, nFormat + 1);
2538  xstrcpy(
2539  &lpszMarker[nResult + nFormat + 1],
2540  pChild->lpszOpenTag);
2541  }
2542  nResult += cb + nFormat + 1;
2543  }
2544  else
2545  {
2546  if (lpszMarker)
2547  xstrcpy(&lpszMarker[nResult], pChild->lpszOpenTag);
2548  nResult += cb;
2549  }
2550  }
2551 
2552  // "OpenTag Value"
2553  cb = (int)LENSTR(pChild->lpszValue);
2554  if (cb)
2555  {
2556  if (lpszMarker)
2557  xstrcpy(&lpszMarker[nResult], pChild->lpszValue);
2558  nResult += cb;
2559  }
2560 
2561  // "OpenTag Value CloseTag"
2562  cb = (int)LENSTR(pChild->lpszCloseTag);
2563  if (cb)
2564  {
2565  if (lpszMarker)
2566  xstrcpy(&lpszMarker[nResult], pChild->lpszCloseTag);
2567  nResult += cb;
2568  }
2569 
2570  if (nFormat != -1)
2571  {
2572  if (lpszMarker) lpszMarker[nResult] = _CXML('\n');
2573  nResult++;
2574  }
2575  break;
2576  }
2577 
2578  // Element nodes
2579  case eNodeChild:
2580  {
2581  // Recursively add child nodes
2582  nResult += CreateXMLStringR(
2583  pEntry->pChild[j >> 2].d,
2584  lpszMarker ? lpszMarker + nResult : 0, nChildFormat);
2585  break;
2586  }
2587  default:
2588  break;
2589  }
2590  }
2591 
2592  if ((cbElement) && (!pEntry->isDeclaration))
2593  {
2594  // If we have child entries we need to use long XML notation for
2595  // closing the element - "<elementname>blah blah blah</elementname>"
2596  if (nElementI)
2597  {
2598  // "</elementname>\0"
2599  if (lpszMarker)
2600  {
2601  if (nFormat >= 0)
2602  {
2603  charmemset(&lpszMarker[nResult], INDENTCHAR, nFormat);
2604  nResult += nFormat;
2605  }
2606 
2607  lpszMarker[nResult] = _CXML('<');
2608  lpszMarker[nResult + 1] = _CXML('/');
2609  nResult += 2;
2610  xstrcpy(&lpszMarker[nResult], pEntry->lpszName);
2611  nResult += cbElement;
2612 
2613  lpszMarker[nResult] = _CXML('>');
2614  if (nFormat == -1)
2615  nResult++;
2616  else
2617  {
2618  lpszMarker[nResult + 1] = _CXML('\n');
2619  nResult += 2;
2620  }
2621  }
2622  else
2623  {
2624  if (nFormat >= 0)
2625  nResult += cbElement + 4 + nFormat;
2626  else if (nFormat == -1)
2627  nResult += cbElement + 3;
2628  else
2629  nResult += cbElement + 4;
2630  }
2631  }
2632  else
2633  {
2634  // If there are no children we can use shorthand XML notation -
2635  // "<elementname/>"
2636  // "/>\0"
2637  if (lpszMarker)
2638  {
2639  lpszMarker[nResult] = _CXML('/');
2640  lpszMarker[nResult + 1] = _CXML('>');
2641  if (nFormat != -1) lpszMarker[nResult + 2] = _CXML('\n');
2642  }
2643  nResult += nFormat == -1 ? 2 : 3;
2644  }
2645  }
2646 
2647  return nResult;
2648 }
2649 
2650 #undef LENSTR
2651 
2652 // Create an XML string
2653 // @param int nFormat - 0 if no formatting is required
2654 // otherwise nonzero for formatted text
2655 // with carriage returns and indentation.
2656 // @param int *pnSize - [out] pointer to the size of the
2657 // returned string not including the
2658 // nullptr terminator.
2659 // @return XMLSTR - Allocated XML string, you must free
2660 // this with free().
2661 XMLSTR XMLNode::createXMLString(int nFormat, int* pnSize) const
2662 {
2663  if (!d)
2664  {
2665  if (pnSize) *pnSize = 0;
2666  return nullptr;
2667  }
2668 
2669  XMLSTR lpszResult = nullptr;
2670  int cbStr;
2671 
2672  // Recursively Calculate the size of the XML string
2673  if (!dropWhiteSpace) nFormat = 0;
2674  nFormat = nFormat ? 0 : -1;
2675  cbStr = CreateXMLStringR(d, 0, nFormat);
2676  // Alllocate memory for the XML string + the nullptr terminator and
2677  // create the recursively XML string.
2678  lpszResult = (XMLSTR)malloc((cbStr + 1) * sizeof(XMLCHAR));
2679  CreateXMLStringR(d, lpszResult, nFormat);
2680  lpszResult[cbStr] = _CXML('\0');
2681  if (pnSize) *pnSize = cbStr;
2682  return lpszResult;
2683 }
2684 
2685 int XMLNode::detachFromParent(XMLNodeData* d)
2686 {
2687  XMLNode* pa = d->pParent->pChild;
2688  int i = 0;
2689  while (((void*)(pa[i].d)) != ((void*)d)) i++;
2690  d->pParent->nChild--;
2691  if (d->pParent->nChild)
2692  memmove(pa + i, pa + i + 1, (d->pParent->nChild - i) * sizeof(XMLNode));
2693  else
2694  {
2695  free(pa);
2696  d->pParent->pChild = nullptr;
2697  }
2698  return removeOrderElement(d->pParent, eNodeChild, i);
2699 }
2700 
2701 XMLNode::~XMLNode()
2702 {
2703  if (!d) return;
2704  d->ref_count--;
2705  emptyTheNode(0);
2706 }
2707 void XMLNode::deleteNodeContent()
2708 {
2709  if (!d) return;
2710  if (d->pParent)
2711  {
2712  detachFromParent(d);
2713  d->pParent = nullptr;
2714  d->ref_count--;
2715  }
2716  emptyTheNode(1);
2717 }
2718 void XMLNode::emptyTheNode(char force)
2719 {
2720  XMLNodeData* dd = d; // warning: must stay this way!
2721  if ((dd->ref_count == 0) || force)
2722  {
2723  if (d->pParent) detachFromParent(d);
2724  int i;
2725  XMLNode* pc;
2726  for (i = 0; i < dd->nChild; i++)
2727  {
2728  pc = dd->pChild + i;
2729  pc->d->pParent = nullptr;
2730  pc->d->ref_count--;
2731  pc->emptyTheNode(force);
2732  }
2733  myFree(dd->pChild);
2734  for (i = 0; i < dd->nText; i++) free((void*)dd->pText[i]);
2735  myFree(dd->pText);
2736  for (i = 0; i < dd->nClear; i++) free((void*)dd->pClear[i].lpszValue);
2737  myFree(dd->pClear);
2738  for (i = 0; i < dd->nAttribute; i++)
2739  {
2740  free((void*)dd->pAttribute[i].lpszName);
2741  if (dd->pAttribute[i].lpszValue)
2742  free((void*)dd->pAttribute[i].lpszValue);
2743  }
2744  myFree(dd->pAttribute);
2745  myFree(dd->pOrder);
2746  myFree((void*)dd->lpszName);
2747  dd->nChild = 0;
2748  dd->nText = 0;
2749  dd->nClear = 0;
2750  dd->nAttribute = 0;
2751  dd->pChild = nullptr;
2752  dd->pText = nullptr;
2753  dd->pClear = nullptr;
2754  dd->pAttribute = nullptr;
2755  dd->pOrder = nullptr;
2756  dd->lpszName = nullptr;
2757  dd->pParent = nullptr;
2758  }
2759  if (dd->ref_count == 0)
2760  {
2761  free(dd);
2762  d = nullptr;
2763  }
2764 }
2765 
2766 XMLNode& XMLNode::operator=(const XMLNode& A)
2767 {
2768  // shallow copy
2769  if (this != &A)
2770  {
2771  if (d)
2772  {
2773  d->ref_count--;
2774  emptyTheNode(0);
2775  }
2776  d = A.d;
2777  if (d) (d->ref_count)++;
2778  }
2779  return *this;
2780 }
2781 
2782 XMLNode::XMLNode(const XMLNode& A)
2783 {
2784  // shallow copy
2785  d = A.d;
2786  if (d) (d->ref_count)++;
2787 }
2788 
2789 XMLNode XMLNode::deepCopy() const
2790 {
2791  if (!d) return XMLNode::emptyXMLNode;
2792  XMLNode x(nullptr, stringDup(d->lpszName), d->isDeclaration);
2793  XMLNodeData* p = x.d;
2794  int n = d->nAttribute;
2795  if (n)
2796  {
2797  p->nAttribute = n;
2798  p->pAttribute = (XMLAttribute*)malloc(n * sizeof(XMLAttribute));
2799  while (n--)
2800  {
2801  p->pAttribute[n].lpszName = stringDup(d->pAttribute[n].lpszName);
2802  p->pAttribute[n].lpszValue = stringDup(d->pAttribute[n].lpszValue);
2803  }
2804  }
2805  if (d->pOrder)
2806  {
2807  n = (d->nChild + d->nText + d->nClear) * sizeof(int);
2808  p->pOrder = (int*)malloc(n);
2809  memcpy(p->pOrder, d->pOrder, n);
2810  }
2811  n = d->nText;
2812  if (n)
2813  {
2814  p->nText = n;
2815  p->pText = (XMLCSTR*)malloc(n * sizeof(XMLCSTR));
2816  while (n--) p->pText[n] = stringDup(d->pText[n]);
2817  }
2818  n = d->nClear;
2819  if (n)
2820  {
2821  p->nClear = n;
2822  p->pClear = (XMLClear*)malloc(n * sizeof(XMLClear));
2823  while (n--)
2824  {
2825  p->pClear[n].lpszCloseTag = d->pClear[n].lpszCloseTag;
2826  p->pClear[n].lpszOpenTag = d->pClear[n].lpszOpenTag;
2827  p->pClear[n].lpszValue = stringDup(d->pClear[n].lpszValue);
2828  }
2829  }
2830  n = d->nChild;
2831  if (n)
2832  {
2833  p->nChild = n;
2834  p->pChild = (XMLNode*)malloc(n * sizeof(XMLNode));
2835  while (n--)
2836  {
2837  p->pChild[n].d = nullptr;
2838  p->pChild[n] = d->pChild[n].deepCopy();
2839  p->pChild[n].d->pParent = p;
2840  }
2841  }
2842  return x;
2843 }
2844 
2845 XMLNode XMLNode::addChild(XMLNode childNode, int pos)
2846 {
2847  XMLNodeData* dc = childNode.d;
2848  if ((!dc) || (!d)) return childNode;
2849  if (!dc->lpszName)
2850  {
2851  // this is a root node: todo: correct fix
2852  int j = pos;
2853  while (dc->nChild)
2854  {
2855  addChild(dc->pChild[0], j);
2856  if (pos >= 0) j++;
2857  }
2858  return childNode;
2859  }
2860  if (dc->pParent)
2861  {
2862  if ((detachFromParent(dc) <= pos) && (dc->pParent == d)) pos--;
2863  }
2864  else
2865  dc->ref_count++;
2866  dc->pParent = d;
2867  // int nc=d->nChild;
2868  // d->pChild=(XMLNode*)myRealloc(d->pChild,(nc+1),memoryIncrease,sizeof(XMLNode));
2869  d->pChild = (XMLNode*)addToOrder(
2870  0, &pos, d->nChild, d->pChild, sizeof(XMLNode), eNodeChild);
2871  d->pChild[pos].d = dc;
2872  d->nChild++;
2873  return childNode;
2874 }
2875 
2876 void XMLNode::deleteAttribute(int i)
2877 {
2878  if ((!d) || (i < 0) || (i >= d->nAttribute)) return;
2879  d->nAttribute--;
2880  XMLAttribute* p = d->pAttribute + i;
2881  free((void*)p->lpszName);
2882  if (p->lpszValue) free((void*)p->lpszValue);
2883  if (d->nAttribute)
2884  memmove(p, p + 1, (d->nAttribute - i) * sizeof(XMLAttribute));
2885  else
2886  {
2887  free(p);
2888  d->pAttribute = nullptr;
2889  }
2890 }
2891 
2892 void XMLNode::deleteAttribute(XMLAttribute* a)
2893 {
2894  if (a) deleteAttribute(a->lpszName);
2895 }
2896 void XMLNode::deleteAttribute(XMLCSTR lpszName)
2897 {
2898  int j = 0;
2899  getAttribute(lpszName, &j);
2900  if (j) deleteAttribute(j - 1);
2901 }
2902 
2903 XMLAttribute* XMLNode::updateAttribute_WOSD(
2904  XMLSTR lpszNewValue, XMLSTR lpszNewName, int i)
2905 {
2906  if (!d)
2907  {
2908  if (lpszNewValue) free(lpszNewValue);
2909  if (lpszNewName) free(lpszNewName);
2910  return nullptr;
2911  }
2912  if (i >= d->nAttribute)
2913  {
2914  if (lpszNewName) return addAttribute_WOSD(lpszNewName, lpszNewValue);
2915  return nullptr;
2916  }
2917  XMLAttribute* p = d->pAttribute + i;
2918  if (p->lpszValue && p->lpszValue != lpszNewValue) free((void*)p->lpszValue);
2919  p->lpszValue = lpszNewValue;
2920  if (lpszNewName && p->lpszName != lpszNewName)
2921  {
2922  free((void*)p->lpszName);
2923  p->lpszName = lpszNewName;
2924  };
2925  return p;
2926 }
2927 
2928 XMLAttribute* XMLNode::updateAttribute_WOSD(
2929  XMLAttribute* newAttribute, XMLAttribute* oldAttribute)
2930 {
2931  if (oldAttribute)
2932  return updateAttribute_WOSD(
2933  (XMLSTR)newAttribute->lpszValue, (XMLSTR)newAttribute->lpszName,
2934  oldAttribute->lpszName);
2935  return addAttribute_WOSD(
2936  (XMLSTR)newAttribute->lpszName, (XMLSTR)newAttribute->lpszValue);
2937 }
2938 
2939 XMLAttribute* XMLNode::updateAttribute_WOSD(
2940  XMLSTR lpszNewValue, XMLSTR lpszNewName, XMLCSTR lpszOldName)
2941 {
2942  int j = 0;
2943  getAttribute(lpszOldName, &j);
2944  if (j)
2945  return updateAttribute_WOSD(lpszNewValue, lpszNewName, j - 1);
2946  else
2947  {
2948  if (lpszNewName)
2949  return addAttribute_WOSD(lpszNewName, lpszNewValue);
2950  else
2951  return addAttribute_WOSD(stringDup(lpszOldName), lpszNewValue);
2952  }
2953 }
2954 
2955 int XMLNode::indexText(XMLCSTR lpszValue) const
2956 {
2957  if (!d) return -1;
2958  int i, l = d->nText;
2959  if (!lpszValue)
2960  {
2961  if (l) return 0;
2962  return -1;
2963  }
2964  XMLCSTR* p = d->pText;
2965  for (i = 0; i < l; i++)
2966  if (lpszValue == p[i]) return i;
2967  return -1;
2968 }
2969 
2970 void XMLNode::deleteText(int i)
2971 {
2972  if ((!d) || (i < 0) || (i >= d->nText)) return;
2973  d->nText--;
2974  XMLCSTR* p = d->pText + i;
2975  free((void*)*p);
2976  if (d->nText)
2977  memmove(p, p + 1, (d->nText - i) * sizeof(XMLCSTR));
2978  else
2979  {
2980  free(p);
2981  d->pText = nullptr;
2982  }
2983  removeOrderElement(d, eNodeText, i);
2984 }
2985 
2986 void XMLNode::deleteText(XMLCSTR lpszValue)
2987 {
2988  deleteText(indexText(lpszValue));
2989 }
2990 
2991 XMLCSTR XMLNode::updateText_WOSD(XMLSTR lpszNewValue, int i)
2992 {
2993  if (!d)
2994  {
2995  if (lpszNewValue) free(lpszNewValue);
2996  return nullptr;
2997  }
2998  if (i >= d->nText) return addText_WOSD(lpszNewValue);
2999  XMLCSTR* p = d->pText + i;
3000  if (*p != lpszNewValue)
3001  {
3002  free((void*)*p);
3003  *p = lpszNewValue;
3004  }
3005  return lpszNewValue;
3006 }
3007 
3008 XMLCSTR XMLNode::updateText_WOSD(XMLSTR lpszNewValue, XMLCSTR lpszOldValue)
3009 {
3010  if (!d)
3011  {
3012  if (lpszNewValue) free(lpszNewValue);
3013  return nullptr;
3014  }
3015  int i = indexText(lpszOldValue);
3016  if (i >= 0) return updateText_WOSD(lpszNewValue, i);
3017  return addText_WOSD(lpszNewValue);
3018 }
3019 
3020 void XMLNode::deleteClear(int i)
3021 {
3022  if ((!d) || (i < 0) || (i >= d->nClear)) return;
3023  d->nClear--;
3024  XMLClear* p = d->pClear + i;
3025  free((void*)p->lpszValue);
3026  if (d->nClear)
3027  memmove(p, p + 1, (d->nClear - i) * sizeof(XMLClear));
3028  else
3029  {
3030  free(p);
3031  d->pClear = nullptr;
3032  }
3033  removeOrderElement(d, eNodeClear, i);
3034 }
3035 
3036 int XMLNode::indexClear(XMLCSTR lpszValue) const
3037 {
3038  if (!d) return -1;
3039  int i, l = d->nClear;
3040  if (!lpszValue)
3041  {
3042  if (l) return 0;
3043  return -1;
3044  }
3045  XMLClear* p = d->pClear;
3046  for (i = 0; i < l; i++)
3047  if (lpszValue == p[i].lpszValue) return i;
3048  return -1;
3049 }
3050 
3051 void XMLNode::deleteClear(XMLCSTR lpszValue)
3052 {
3053  deleteClear(indexClear(lpszValue));
3054 }
3055 void XMLNode::deleteClear(XMLClear* a)
3056 {
3057  if (a) deleteClear(a->lpszValue);
3058 }
3059 
3060 XMLClear* XMLNode::updateClear_WOSD(XMLSTR lpszNewContent, int i)
3061 {
3062  if (!d)
3063  {
3064  if (lpszNewContent) free(lpszNewContent);
3065  return nullptr;
3066  }
3067  if (i >= d->nClear) return addClear_WOSD(lpszNewContent);
3068  XMLClear* p = d->pClear + i;
3069  if (lpszNewContent != p->lpszValue)
3070  {
3071  free((void*)p->lpszValue);
3072  p->lpszValue = lpszNewContent;
3073  }
3074  return p;
3075 }
3076 
3077 XMLClear* XMLNode::updateClear_WOSD(XMLSTR lpszNewContent, XMLCSTR lpszOldValue)
3078 {
3079  if (!d)
3080  {
3081  if (lpszNewContent) free(lpszNewContent);
3082  return nullptr;
3083  }
3084  int i = indexClear(lpszOldValue);
3085  if (i >= 0) return updateClear_WOSD(lpszNewContent, i);
3086  return addClear_WOSD(lpszNewContent);
3087 }
3088 
3089 XMLClear* XMLNode::updateClear_WOSD(XMLClear* newP, XMLClear* oldP)
3090 {
3091  if (oldP)
3092  return updateClear_WOSD(
3093  (XMLSTR)newP->lpszValue, (XMLSTR)oldP->lpszValue);
3094  return nullptr;
3095 }
3096 
3097 int XMLNode::nChildNode(XMLCSTR name) const
3098 {
3099  if (!d) return 0;
3100  int i, j = 0, n = d->nChild;
3101  XMLNode* pc = d->pChild;
3102  for (i = 0; i < n; i++)
3103  {
3104  if (xstricmp(pc->d->lpszName, name) == 0) j++;
3105  pc++;
3106  }
3107  return j;
3108 }
3109 
3110 XMLNode XMLNode::getChildNode(XMLCSTR name, int* j) const
3111 {
3112  if (!d) return emptyXMLNode;
3113  int i = 0, n = d->nChild;
3114  if (j) i = *j;
3115  XMLNode* pc = d->pChild + i;
3116  for (; i < n; i++)
3117  {
3118  if (!xstricmp(pc->d->lpszName, name))
3119  {
3120  if (j) *j = i + 1;
3121  return *pc;
3122  }
3123  pc++;
3124  }
3125  return emptyXMLNode;
3126 }
3127 
3128 XMLNode XMLNode::getChildNode(XMLCSTR name, int j) const
3129 {
3130  if (!d) return emptyXMLNode;
3131  if (j >= 0)
3132  {
3133  int i = 0;
3134  while (j-- > 0) getChildNode(name, &i);
3135  return getChildNode(name, &i);
3136  }
3137  int i = d->nChild;
3138  while (i--)
3139  if (!xstricmp(name, d->pChild[i].d->lpszName)) break;
3140  if (i < 0) return emptyXMLNode;
3141  return getChildNode(i);
3142 }
3143 
3144 XMLNode XMLNode::getChildNodeByPath(
3145  XMLCSTR _path, char createMissing, XMLCHAR sep)
3146 {
3147  XMLSTR path = stringDup(_path);
3148  XMLNode x = getChildNodeByPath(path, createMissing, sep);
3149  if (path) free(path);
3150  return x;
3151 }
3152 
3153 XMLNode XMLNode::getChildNodeByPath(
3154  XMLSTR path, char createIfMissing, XMLCHAR sep)
3155 {
3156  if ((!path) || (!(*path))) return *this;
3157  XMLNode xn, xbase = *this;
3158  XMLCHAR *tend1, sepString[2];
3159  sepString[0] = sep;
3160  sepString[1] = 0;
3161  tend1 = xstrstr(path, sepString);
3162  while (tend1)
3163  {
3164  *tend1 = 0;
3165  xn = xbase.getChildNode(path);
3166  if (xn.isEmpty())
3167  {
3168  if (createIfMissing)
3169  xn = xbase.addChild(path);
3170  else
3171  return XMLNode::emptyXMLNode;
3172  }
3173  xbase = xn;
3174  path = tend1 + 1;
3175  tend1 = xstrstr(path, sepString);
3176  }
3177  xn = xbase.getChildNode(path);
3178  if (xn.isEmpty() && createIfMissing) xn = xbase.addChild(path);
3179  return xn;
3180 }
3181 
3182 XMLElementPosition XMLNode::positionOfText(int i) const
3183 {
3184  if (i >= d->nText) i = d->nText - 1;
3185  return findPosition(d, i, eNodeText);
3186 }
3187 XMLElementPosition XMLNode::positionOfClear(int i) const
3188 {
3189  if (i >= d->nClear) i = d->nClear - 1;
3190  return findPosition(d, i, eNodeClear);
3191 }
3192 XMLElementPosition XMLNode::positionOfChildNode(int i) const
3193 {
3194  if (i >= d->nChild) i = d->nChild - 1;
3195  return findPosition(d, i, eNodeChild);
3196 }
3197 XMLElementPosition XMLNode::positionOfText(XMLCSTR lpszValue) const
3198 {
3199  return positionOfText(indexText(lpszValue));
3200 }
3201 XMLElementPosition XMLNode::positionOfClear(XMLCSTR lpszValue) const
3202 {
3203  return positionOfClear(indexClear(lpszValue));
3204 }
3205 XMLElementPosition XMLNode::positionOfClear(XMLClear* a) const
3206 {
3207  if (a) return positionOfClear(a->lpszValue);
3208  return positionOfClear();
3209 }
3210 XMLElementPosition XMLNode::positionOfChildNode(XMLNode x) const
3211 {
3212  if ((!d) || (!x.d)) return -1;
3213  XMLNodeData* dd = x.d;
3214  XMLNode* pc = d->pChild;
3215  int i = d->nChild;
3216  while (i--)
3217  if (pc[i].d == dd) return findPosition(d, i, eNodeChild);
3218  return -1;
3219 }
3220 XMLElementPosition XMLNode::positionOfChildNode(XMLCSTR name, int count) const
3221 {
3222  if (!name) return positionOfChildNode(count);
3223  int j = 0;
3224  do
3225  {
3226  getChildNode(name, &j);
3227  if (j < 0) return -1;
3228  } while (count--);
3229  return findPosition(d, j - 1, eNodeChild);
3230 }
3231 
3232 XMLNode XMLNode::getChildNodeWithAttribute(
3233  XMLCSTR name, XMLCSTR attributeName, XMLCSTR attributeValue, int* k) const
3234 {
3235  int i = 0, j;
3236  if (k) i = *k;
3237  XMLNode x;
3238  XMLCSTR t;
3239  do
3240  {
3241  x = getChildNode(name, &i);
3242  if (!x.isEmpty())
3243  {
3244  if (attributeValue)
3245  {
3246  j = 0;
3247  do
3248  {
3249  t = x.getAttribute(attributeName, &j);
3250  if (t && (xstricmp(attributeValue, t) == 0))
3251  {
3252  if (k) *k = i;
3253  return x;
3254  }
3255  } while (t);
3256  }
3257  else
3258  {
3259  if (x.isAttributeSet(attributeName))
3260  {
3261  if (k) *k = i;
3262  return x;
3263  }
3264  }
3265  }
3266  } while (!x.isEmpty());
3267  return emptyXMLNode;
3268 }
3269 
3270 // Find an attribute on an node.
3271 XMLCSTR XMLNode::getAttribute(XMLCSTR lpszAttrib, int* j) const
3272 {
3273  if (!d) return nullptr;
3274  int i = 0, n = d->nAttribute;
3275  if (j) i = *j;
3276  XMLAttribute* pAttr = d->pAttribute + i;
3277  for (; i < n; i++)
3278  {
3279  if (xstricmp(pAttr->lpszName, lpszAttrib) == 0)
3280  {
3281  if (j) *j = i + 1;
3282  return pAttr->lpszValue;
3283  }
3284  pAttr++;
3285  }
3286  return nullptr;
3287 }
3288 
3289 char XMLNode::isAttributeSet(XMLCSTR lpszAttrib) const
3290 {
3291  if (!d) return FALSE;
3292  int i, n = d->nAttribute;
3293  XMLAttribute* pAttr = d->pAttribute;
3294  for (i = 0; i < n; i++)
3295  {
3296  if (xstricmp(pAttr->lpszName, lpszAttrib) == 0)
3297  {
3298  return TRUE;
3299  }
3300  pAttr++;
3301  }
3302  return FALSE;
3303 }
3304 
3305 XMLCSTR XMLNode::getAttribute(XMLCSTR name, int j) const
3306 {
3307  if (!d) return nullptr;
3308  int i = 0;
3309  while (j-- > 0) getAttribute(name, &i);
3310  return getAttribute(name, &i);
3311 }
3312 
3313 XMLNodeContents XMLNode::enumContents(int i) const
3314 {
3315  XMLNodeContents c;
3316  if (!d)
3317  {
3318  c.etype = eNodeNULL;
3319  return c;
3320  }
3321  if (i < d->nAttribute)
3322  {
3323  c.etype = eNodeAttribute;
3324  c.attrib = d->pAttribute[i];
3325  return c;
3326  }
3327  i -= d->nAttribute;
3328  c.etype = (XMLElementType)(d->pOrder[i] & 3);
3329  i = (d->pOrder[i]) >> 2;
3330  switch (c.etype)
3331  {
3332  case eNodeChild:
3333  c.child = d->pChild[i];
3334  break;
3335  case eNodeText:
3336  c.text = d->pText[i];
3337  break;
3338  case eNodeClear:
3339  c.clear = d->pClear[i];
3340  break;
3341  default:
3342  break;
3343  }
3344  return c;
3345 }
3346 
3347 XMLCSTR XMLNode::getName() const
3348 {
3349  if (!d) return nullptr;
3350  return d->lpszName;
3351 }
3352 int XMLNode::nText() const
3353 {
3354  if (!d) return 0;
3355  return d->nText;
3356 }
3357 int XMLNode::nChildNode() const
3358 {
3359  if (!d) return 0;
3360  return d->nChild;
3361 }
3362 int XMLNode::nAttribute() const
3363 {
3364  if (!d) return 0;
3365  return d->nAttribute;
3366 }
3367 int XMLNode::nClear() const
3368 {
3369  if (!d) return 0;
3370  return d->nClear;
3371 }
3372 int XMLNode::nElement() const
3373 {
3374  if (!d) return 0;
3375  return d->nAttribute + d->nChild + d->nText + d->nClear;
3376 }
3377 XMLClear XMLNode::getClear(int i) const
3378 {
3379  if ((!d) || (i >= d->nClear)) return emptyXMLClear;
3380  return d->pClear[i];
3381 }
3382 XMLAttribute XMLNode::getAttribute(int i) const
3383 {
3384  if ((!d) || (i >= d->nAttribute)) return emptyXMLAttribute;
3385  return d->pAttribute[i];
3386 }
3387 XMLCSTR XMLNode::getAttributeName(int i) const
3388 {
3389  if ((!d) || (i >= d->nAttribute)) return nullptr;
3390  return d->pAttribute[i].lpszName;
3391 }
3392 XMLCSTR XMLNode::getAttributeValue(int i) const
3393 {
3394  if ((!d) || (i >= d->nAttribute)) return nullptr;
3395  return d->pAttribute[i].lpszValue;
3396 }
3397 XMLCSTR XMLNode::getText(int i) const
3398 {
3399  if ((!d) || (i >= d->nText)) return nullptr;
3400  return d->pText[i];
3401 }
3402 XMLNode XMLNode::getChildNode(int i) const
3403 {
3404  if ((!d) || (i >= d->nChild)) return emptyXMLNode;
3405  return d->pChild[i];
3406 }
3407 XMLNode XMLNode::getParentNode() const
3408 {
3409  if ((!d) || (!d->pParent)) return emptyXMLNode;
3410  return XMLNode(d->pParent);
3411 }
3412 char XMLNode::isDeclaration() const
3413 {
3414  if (!d) return 0;
3415  return d->isDeclaration;
3416 }
3417 char XMLNode::isEmpty() const { return (d == nullptr); }
3418 XMLNode XMLNode::emptyNode() { return XMLNode::emptyXMLNode; }
3419 XMLNode XMLNode::addChild(
3420  XMLCSTR lpszName, char isDeclaration, XMLElementPosition pos)
3421 {
3422  return addChild_priv(0, stringDup(lpszName), isDeclaration, pos);
3423 }
3424 XMLNode XMLNode::addChild_WOSD(
3425  XMLSTR lpszName, char isDeclaration, XMLElementPosition pos)
3426 {
3427  return addChild_priv(0, lpszName, isDeclaration, pos);
3428 }
3429 XMLAttribute* XMLNode::addAttribute(XMLCSTR lpszName, XMLCSTR lpszValue)
3430 {
3431  return addAttribute_priv(0, stringDup(lpszName), stringDup(lpszValue));
3432 }
3433 XMLAttribute* XMLNode::addAttribute_WOSD(XMLSTR lpszName, XMLSTR lpszValuev)
3434 {
3435  return addAttribute_priv(0, lpszName, lpszValuev);
3436 }
3437 XMLCSTR XMLNode::addText(XMLCSTR lpszValue, XMLElementPosition pos)
3438 {
3439  return addText_priv(0, stringDup(lpszValue), pos);
3440 }
3441 XMLCSTR XMLNode::addText_WOSD(XMLSTR lpszValue, XMLElementPosition pos)
3442 {
3443  return addText_priv(0, lpszValue, pos);
3444 }
3445 XMLClear* XMLNode::addClear(
3446  XMLCSTR lpszValue, XMLCSTR lpszOpen, XMLCSTR lpszClose,
3447  XMLElementPosition pos)
3448 {
3449  return addClear_priv(0, stringDup(lpszValue), lpszOpen, lpszClose, pos);
3450 }
3451 XMLClear* XMLNode::addClear_WOSD(
3452  XMLSTR lpszValue, XMLCSTR lpszOpen, XMLCSTR lpszClose,
3453  XMLElementPosition pos)
3454 {
3455  return addClear_priv(0, lpszValue, lpszOpen, lpszClose, pos);
3456 }
3457 XMLCSTR XMLNode::updateName(XMLCSTR lpszName)
3458 {
3459  return updateName_WOSD(stringDup(lpszName));
3460 }
3461 XMLAttribute* XMLNode::updateAttribute(
3462  XMLAttribute* newAttribute, XMLAttribute* oldAttribute)
3463 {
3464  return updateAttribute_WOSD(
3465  stringDup(newAttribute->lpszValue), stringDup(newAttribute->lpszName),
3466  oldAttribute->lpszName);
3467 }
3468 XMLAttribute* XMLNode::updateAttribute(
3469  XMLCSTR lpszNewValue, XMLCSTR lpszNewName, int i)
3470 {
3471  return updateAttribute_WOSD(
3472  stringDup(lpszNewValue), stringDup(lpszNewName), i);
3473 }
3474 XMLAttribute* XMLNode::updateAttribute(
3475  XMLCSTR lpszNewValue, XMLCSTR lpszNewName, XMLCSTR lpszOldName)
3476 {
3477  return updateAttribute_WOSD(
3478  stringDup(lpszNewValue), stringDup(lpszNewName), lpszOldName);
3479 }
3480 XMLCSTR XMLNode::updateText(XMLCSTR lpszNewValue, int i)
3481 {
3482  return updateText_WOSD(stringDup(lpszNewValue), i);
3483 }
3484 XMLCSTR XMLNode::updateText(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue)
3485 {
3486  return updateText_WOSD(stringDup(lpszNewValue), lpszOldValue);
3487 }
3488 XMLClear* XMLNode::updateClear(XMLCSTR lpszNewContent, int i)
3489 {
3490  return updateClear_WOSD(stringDup(lpszNewContent), i);
3491 }
3492 XMLClear* XMLNode::updateClear(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue)
3493 {
3494  return updateClear_WOSD(stringDup(lpszNewValue), lpszOldValue);
3495 }
3496 XMLClear* XMLNode::updateClear(XMLClear* newP, XMLClear* oldP)
3497 {
3498  return updateClear_WOSD(stringDup(newP->lpszValue), oldP->lpszValue);
3499 }
3500 
3501 char XMLNode::setGlobalOptions(
3502  XMLCharEncoding _characterEncoding, char _guessWideCharChars,
3503  char _dropWhiteSpace, char _removeCommentsInMiddleOfText)
3504 {
3505  guessWideCharChars = _guessWideCharChars;
3506  dropWhiteSpace = _dropWhiteSpace;
3507  removeCommentsInMiddleOfText = _removeCommentsInMiddleOfText;
3508 #ifdef _XMLWIDECHAR
3509  if (_characterEncoding) characterEncoding = _characterEncoding;
3510 #else
3511  switch (_characterEncoding)
3512  {
3513  case char_encoding_UTF8:
3514  characterEncoding = _characterEncoding;
3515  XML_ByteTable = XML_utf8ByteTable;
3516  break;
3517  case char_encoding_legacy:
3518  characterEncoding = _characterEncoding;
3519  XML_ByteTable = XML_legacyByteTable;
3520  break;
3521  case char_encoding_ShiftJIS:
3522  characterEncoding = _characterEncoding;
3523  XML_ByteTable = XML_sjisByteTable;
3524  break;
3525  case char_encoding_GB2312:
3526  characterEncoding = _characterEncoding;
3527  XML_ByteTable = XML_gb2312ByteTable;
3528  break;
3529  case char_encoding_Big5:
3530  case char_encoding_GBK:
3531  characterEncoding = _characterEncoding;
3532  XML_ByteTable = XML_gbk_big5_ByteTable;
3533  break;
3534  default:
3535  return 1;
3536  }
3537 #endif
3538  return 0;
3539 }
3540 
3541 XMLNode::XMLCharEncoding XMLNode::guessCharEncoding(
3542  void* buf, int l, char useXMLEncodingAttribute)
3543 {
3544 #ifdef _XMLWIDECHAR
3545  return (XMLCharEncoding)0;
3546 #else
3547  if (l < 25) return (XMLCharEncoding)0;
3548  if (guessWideCharChars && (myIsTextWideChar(buf, l)))
3549  return (XMLCharEncoding)0;
3550  unsigned char* b = (unsigned char*)buf;
3551  if ((b[0] == 0xef) && (b[1] == 0xbb) && (b[2] == 0xbf))
3552  return char_encoding_UTF8;
3553 
3554  // Match utf-8 model ?
3555  XMLCharEncoding bestGuess = char_encoding_UTF8;
3556  int i = 0;
3557  while (i < l) switch (XML_utf8ByteTable[b[i]])
3558  {
3559  case 4:
3560  i++;
3561  if ((i < l) && (b[i] & 0xC0) != 0x80)
3562  {
3563  bestGuess = char_encoding_legacy;
3564  i = l;
3565  } // 10bbbbbb ?
3566  /*FALLTHROUGH*/
3567  case 3:
3568  i++;
3569  if ((i < l) && (b[i] & 0xC0) != 0x80)
3570  {
3571  bestGuess = char_encoding_legacy;
3572  i = l;
3573  } // 10bbbbbb ?
3574  /*FALLTHROUGH*/
3575  case 2:
3576  i++;
3577  if ((i < l) && (b[i] & 0xC0) != 0x80)
3578  {
3579  bestGuess = char_encoding_legacy;
3580  i = l;
3581  } // 10bbbbbb ?
3582  /*FALLTHROUGH*/
3583  case 1:
3584  i++;
3585  break;
3586  case 0:
3587  i = l;
3588  /*FALLTHROUGH*/
3589  }
3590  if (!useXMLEncodingAttribute) return bestGuess;
3591  // if encoding is specified and different from utf-8 than it's non-utf8
3592  // otherwise it's utf-8
3593  char bb[201];
3594  l = mmin(l, 200);
3595  memcpy(bb, buf, l); // copy buf into bb to be able to do "bb[l]=0"
3596  bb[l] = 0;
3597  b = (unsigned char*)strstr(bb, "encoding");
3598  if (!b) return bestGuess;
3599  b += 8;
3600  while
3601  XML_isSPACECHAR(*b) b++;
3602  if (*b != '=') return bestGuess;
3603  b++;
3604  while
3605  XML_isSPACECHAR(*b) b++;
3606  if ((*b != '\'') && (*b != '"')) return bestGuess;
3607  b++;
3608  while
3609  XML_isSPACECHAR(*b) b++;
3610 
3611  if ((xstrnicmp((char*)b, "utf-8", 5) == 0) ||
3612  (xstrnicmp((char*)b, "utf8", 4) == 0))
3613  {
3614  if (bestGuess == char_encoding_legacy) return char_encoding_error;
3615  return char_encoding_UTF8;
3616  }
3617 
3618  if ((xstrnicmp((char*)b, "shiftjis", 8) == 0) ||
3619  (xstrnicmp((char*)b, "shift-jis", 9) == 0) ||
3620  (xstrnicmp((char*)b, "sjis", 4) == 0))
3621  return char_encoding_ShiftJIS;
3622 
3623  if (xstrnicmp((char*)b, "GB2312", 6) == 0) return char_encoding_GB2312;
3624  if (xstrnicmp((char*)b, "Big5", 4) == 0) return char_encoding_Big5;
3625  if (xstrnicmp((char*)b, "GBK", 3) == 0) return char_encoding_GBK;
3626 
3627  return char_encoding_legacy;
3628 #endif
3629 }
3630 #undef XML_isSPACECHAR
3631 
3632 //////////////////////////////////////////////////////////
3633 // Here starts the base64 conversion functions. //
3634 //////////////////////////////////////////////////////////
3635 
3636 static const char base64Fillchar =
3637  _CXML('='); // used to mark partial words at the end
3638 
3639 // this lookup table defines the base64 encoding
3640 XMLCSTR base64EncodeTable =
3641  _CXML("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
3642 
3643 // Decode Table gives the index of any valid base64 character in the Base64
3644 // table]
3645 // 96: '=' - 97: space char - 98: illegal char - 99: end of string
3646 const unsigned char base64DecodeTable[] = {
3647  99, 98, 98, 98, 98, 98, 98, 98, 98, 97, 97, 98, 98, 97, 98, 98,
3648  98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, // 00 -29
3649  98, 98, 97, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 62, 98, 98,
3650  98, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 98, 98, // 30 -59
3651  98, 96, 98, 98, 98, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
3652  11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, // 60 -89
3653  25, 98, 98, 98, 98, 98, 98, 26, 27, 28, 29, 30, 31, 32, 33, 34,
3654  35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, // 90 -119
3655  49, 50, 51, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98,
3656  98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, // 120 -149
3657  98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98,
3658  98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, // 150 -179
3659  98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98,
3660  98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, // 180 -209
3661  98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98,
3662  98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, // 210 -239
3663  98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98 // 240 -255
3664 };
3665 
3666 XMLParserBase64Tool::~XMLParserBase64Tool() { freeBuffer(); }
3667 void XMLParserBase64Tool::freeBuffer()
3668 {
3669  if (buf) free(buf);
3670  buf = nullptr;
3671  buflen = 0;
3672 }
3673 
3674 int XMLParserBase64Tool::encodeLength(int inlen, char formatted)
3675 {
3676  unsigned int i = ((inlen - 1) / 3 * 4 + 4 + 1);
3677  if (formatted) i += inlen / 54;
3678  return i;
3679 }
3680 
3681 XMLSTR XMLParserBase64Tool::encode(
3682  unsigned char* inbuf, unsigned int inlen, char formatted)
3683 {
3684  int i = encodeLength(inlen, formatted), k = 17, eLen = inlen / 3, j;
3685  alloc(i * sizeof(XMLCHAR));
3686  XMLSTR curr = (XMLSTR)buf;
3687  for (i = 0; i < eLen; i++)
3688  {
3689  // Copy next three bytes into lower 24 bits of int, paying attention to
3690  // sign.
3691  j = (inbuf[0] << 16) | (inbuf[1] << 8) | inbuf[2];
3692  inbuf += 3;
3693  // Encode the int into four chars
3694  *(curr++) = base64EncodeTable[j >> 18];
3695  *(curr++) = base64EncodeTable[(j >> 12) & 0x3f];
3696  *(curr++) = base64EncodeTable[(j >> 6) & 0x3f];
3697  *(curr++) = base64EncodeTable[(j)&0x3f];
3698  if (formatted)
3699  {
3700  if (!k)
3701  {
3702  *(curr++) = _CXML('\n');
3703  k = 18;
3704  }
3705  k--;
3706  }
3707  }
3708  eLen = inlen - eLen * 3; // 0 - 2.
3709  if (eLen == 1)
3710  {
3711  *(curr++) = base64EncodeTable[inbuf[0] >> 2];
3712  *(curr++) = base64EncodeTable[(inbuf[0] << 4) & 0x3F];
3713  *(curr++) = base64Fillchar;
3714  *(curr++) = base64Fillchar;
3715  }
3716  else if (eLen == 2)
3717  {
3718  j = (inbuf[0] << 8) | inbuf[1];
3719  *(curr++) = base64EncodeTable[j >> 10];
3720  *(curr++) = base64EncodeTable[(j >> 4) & 0x3f];
3721  *(curr++) = base64EncodeTable[(j << 2) & 0x3f];
3722  *(curr++) = base64Fillchar;
3723  }
3724  *(curr++) = 0;
3725  return (XMLSTR)buf;
3726 }
3727 
3728 unsigned int XMLParserBase64Tool::decodeSize(XMLCSTR data, XMLError* xe)
3729 {
3730  if (xe) *xe = eXMLErrorNone;
3731  int size = 0;
3732  unsigned char c;
3733  // skip any extra characters (e.g. newlines or spaces)
3734  while (*data)
3735  {
3736 #ifdef _XMLWIDECHAR
3737  if (*data > 255)
3738  {
3739  if (xe) *xe = eXMLErrorBase64DecodeIllegalCharacter;
3740  return 0;
3741  }
3742 #endif
3743  c = base64DecodeTable[(unsigned char)(*data)];
3744  if (c < 97)
3745  size++;
3746  else if (c == 98)
3747  {
3748  if (xe) *xe = eXMLErrorBase64DecodeIllegalCharacter;
3749  return 0;
3750  }
3751  data++;
3752  }
3753  if (xe && (size % 4 != 0)) *xe = eXMLErrorBase64DataSizeIsNotMultipleOf4;
3754  if (size == 0) return 0;
3755  do
3756  {
3757  data--;
3758  size--;
3759  } while (*data == base64Fillchar);
3760  size++;
3761  return (unsigned int)((size * 3) / 4);
3762 }
3763 
3764 unsigned char XMLParserBase64Tool::decode(
3765  XMLCSTR data, unsigned char* buf, int len, XMLError* xe)
3766 {
3767  if (xe) *xe = eXMLErrorNone;
3768  int i = 0, p = 0;
3769  unsigned char d, c;
3770  for (;;)
3771  {
3772 #ifdef _XMLWIDECHAR
3773 #define BASE64DECODE_READ_NEXT_CHAR(c) \
3774  do \
3775  { \
3776  if (data[i] > 255) \
3777  { \
3778  c = 98; \
3779  break; \
3780  } \
3781  c = base64DecodeTable[(unsigned char)data[i++]]; \
3782  } while (c == 97); \
3783  if (c == 98) \
3784  { \
3785  if (xe) *xe = eXMLErrorBase64DecodeIllegalCharacter; \
3786  return 0; \
3787  }
3788 #else
3789 #define BASE64DECODE_READ_NEXT_CHAR(c) \
3790  do \
3791  { \
3792  c = base64DecodeTable[(unsigned char)data[i++]]; \
3793  } while (c == 97); \
3794  if (c == 98) \
3795  { \
3796  if (xe) *xe = eXMLErrorBase64DecodeIllegalCharacter; \
3797  return 0; \
3798  }
3799 #endif
3800 
3801  BASE64DECODE_READ_NEXT_CHAR(c)
3802  if (c == 99)
3803  {
3804  return 2;
3805  }
3806  if (c == 96)
3807  {
3808  if (p == (int)len) return 2;
3809  if (xe) *xe = eXMLErrorBase64DecodeTruncatedData;
3810  return 1;
3811  }
3812 
3813  BASE64DECODE_READ_NEXT_CHAR(d)
3814  if ((d == 99) || (d == 96))
3815  {
3816  if (xe) *xe = eXMLErrorBase64DecodeTruncatedData;
3817  return 1;
3818  }
3819  if (p == (int)len)
3820  {
3821  if (xe) *xe = eXMLErrorBase64DecodeBufferTooSmall;
3822  return 0;
3823  }
3824  buf[p++] = (unsigned char)((c << 2) | ((d >> 4) & 0x3));
3825 
3826  BASE64DECODE_READ_NEXT_CHAR(c)
3827  if (c == 99)
3828  {
3829  if (xe) *xe = eXMLErrorBase64DecodeTruncatedData;
3830  return 1;
3831  }
3832  if (p == (int)len)
3833  {
3834  if (c == 96) return 2;
3835  if (xe) *xe = eXMLErrorBase64DecodeBufferTooSmall;
3836  return 0;
3837  }
3838  if (c == 96)
3839  {
3840  if (xe) *xe = eXMLErrorBase64DecodeTruncatedData;
3841  return 1;
3842  }
3843  buf[p++] = (unsigned char)(((d << 4) & 0xf0) | ((c >> 2) & 0xf));
3844 
3845  BASE64DECODE_READ_NEXT_CHAR(d)
3846  if (d == 99)
3847  {
3848  if (xe) *xe = eXMLErrorBase64DecodeTruncatedData;
3849  return 1;
3850  }
3851  if (p == (int)len)
3852  {
3853  if (d == 96) return 2;
3854  if (xe) *xe = eXMLErrorBase64DecodeBufferTooSmall;
3855  return 0;
3856  }
3857  if (d == 96)
3858  {
3859  if (xe) *xe = eXMLErrorBase64DecodeTruncatedData;
3860  return 1;
3861  }
3862  buf[p++] = (unsigned char)(((c << 6) & 0xc0) | d);
3863  }
3864 }
3865 #undef BASE64DECODE_READ_NEXT_CHAR
3866 
3867 void XMLParserBase64Tool::alloc(int newsize)
3868 {
3869  if ((!buf) && (newsize))
3870  {
3871  buf = malloc(newsize);
3872  buflen = newsize;
3873  return;
3874  }
3875  if (newsize > buflen)
3876  {
3877  buf = realloc(buf, newsize);
3878  buflen = newsize;
3879  }
3880 }
3881 
3882 unsigned char* XMLParserBase64Tool::decode(
3883  XMLCSTR data, int* outlen, XMLError* xe)
3884 {
3885  if (xe) *xe = eXMLErrorNone;
3886  unsigned int len = decodeSize(data, xe);
3887  if (outlen) *outlen = len;
3888  if (!len) return nullptr;
3889  alloc(len + 1);
3890  if (!decode(data, (unsigned char*)buf, len, xe))
3891  {
3892  return nullptr;
3893  }
3894  return (unsigned char*)buf;
3895 }
XMLNode::getVersion
static XMLCSTR getVersion()
Return the XMLParser library version number.
Definition: xmlParser.cpp:27
XMLNode::getChildNodeWithAttribute
XMLNode getChildNodeWithAttribute(XMLCSTR tagName, XMLCSTR attributeName, XMLCSTR attributeValue=nullptr, int *i=nullptr) const
next child node with specific name (return an empty node if failing)
Definition: xmlParser.cpp:3232
XMLNode::nAttribute
int nAttribute() const
next attribute content with specific name (return a nullptr if failing)
Definition: xmlParser.cpp:3362
XMLNode::isAttributeSet
char isAttributeSet(XMLCSTR name) const
test if an attribute with a specific name is given
Definition: xmlParser.cpp:3289
XML_gbk_big5_ByteTable
static const char XML_gbk_big5_ByteTable[256]
Definition: xmlParser.cpp:721
count
GLuint GLuint GLsizei count
Definition: glext.h:3528
XMLNode::updateName_WOSD
XMLCSTR updateName_WOSD(XMLSTR lpszName)
change node&#39;s name
Definition: xmlParser.cpp:1369
XMLNode::getParentNode
XMLNode getParentNode() const
return the parent node
Definition: xmlParser.cpp:3407
ToXMLStringTool::toXML
XMLSTR toXML(XMLCSTR source)
object to release memory used by the internal buffer.
Definition: xmlParser.cpp:958
XMLElementType
XMLElementType
Enumeration used to manage type of data.
Definition: xmlParser.h:265
_CXML
#define _CXML(c)
Definition: xmlParser.h:225
MEMORYINCREASE
#define MEMORYINCREASE
Definition: xmlParser.cpp:1419
base64EncodeTable
XMLCSTR base64EncodeTable
Definition: xmlParser.cpp:3640
xmltoc
XMLCHAR xmltoc(XMLCSTR t, XMLCHAR v)
Definition: xmlParser.cpp:515
t
GLdouble GLdouble t
Definition: glext.h:3689
XMLParserBase64Tool::encode
XMLSTR encode(unsigned char *inByteBuf, unsigned int inByteLen, char formatted=0)
length of the base64 string that encodes a data buffer of size inBufLen bytes.
Definition: xmlParser.cpp:3681
XMLCHAR
#define XMLCHAR
Definition: xmlParser.h:228
XMLParserBase64Tool::alloc
void alloc(int newsize)
Definition: xmlParser.cpp:3867
XMLClearTags
static ALLXMLClearTag XMLClearTags[]
Definition: xmlParser.cpp:49
Attrib
enum Attrib { eAttribName=0, eAttribEquals, eAttribValue } Attrib
Definition: xmlParser.cpp:800
XMLNode::maybeAddTxT
char maybeAddTxT(void *pa, XMLCSTR tokenPStr)
Definition: xmlParser.cpp:1659
XML
struct XML XML
XMLClear::lpszOpenTag
XMLCSTR lpszOpenTag
Definition: xmlParser.h:284
XMLNode::deleteAttribute
void deleteAttribute(int i=0)
Delete the ith attribute of the current XMLNode.
Definition: xmlParser.cpp:2876
INDENTCHAR
#define INDENTCHAR
Definition: xmlParser.cpp:78
XMLNode
Main Class representing a XML node.
Definition: xmlParser.h:313
XMLResults::nColumn
int nColumn
Definition: xmlParser.h:277
XML::lpXML
XMLCSTR lpXML
Definition: xmlParser.cpp:782
myFree
static void myFree(void *p)
Definition: xmlParser.cpp:1421
xstrstr
static XMLSTR xstrstr(XMLCSTR c1, XMLCSTR c2)
Definition: xmlParser.cpp:294
XMLNode::updateClear
XMLClear * updateClear(XMLCSTR lpszNewContent, int i=0)
text to update is missing, a new one will be added
Definition: xmlParser.cpp:3488
XMLNode::writeToFile
XMLError writeToFile(XMLCSTR filename, const char *encoding=nullptr, char nFormat=1) const
Save the content of an xmlNode inside a file.
Definition: xmlParser.cpp:806
mrpt::system::os::fclose
int void fclose(FILE *f)
An OS-independent version of fclose.
Definition: os.cpp:273
XMLNode::addClear
XMLClear * addClear(XMLCSTR lpszValue, XMLCSTR lpszOpen=nullptr, XMLCSTR lpszClose=nullptr, XMLElementPosition pos=-1)
Add a new clear tag.
Definition: xmlParser.cpp:3445
ToXMLStringTool::freeBuffer
void freeBuffer()
call this function when you have finished using this
Definition: xmlParser.cpp:952
XMLNode::XMLCharEncoding
XMLCharEncoding
childNode with the specified name if (name==nullptr) return the position of the ith childNode ...
Definition: xmlParser.h:777
mrpt::system::os::_strnicmp
int _strnicmp(const char *str, const char *subStr, size_t count) noexcept
An OS-independent version of strnicmp.
Definition: os.cpp:344
XMLNode::parseString
static XMLNode parseString(XMLCSTR lpXMLString, XMLCSTR tag=nullptr, XMLResults *pResults=nullptr)
Parse an XML string and return the root of a XMLNode tree representing the string.
Definition: xmlParser.cpp:2216
XMLNode::getChildNodeByPath
XMLNode getChildNodeByPath(XMLSTR path, char createNodeIfMissing=0, XMLCHAR sep='/')
name/attribute (return an empty node if failing)
Definition: xmlParser.cpp:3153
n
GLenum GLsizei n
Definition: glext.h:5074
XMLNode::updateText
XMLCSTR updateText(XMLCSTR lpszNewValue, int i=0)
change the name of the attribute if the attribute to update is missing, a new one will be added ...
Definition: xmlParser.cpp:3480
XMLClear
Structure for XML clear (unformatted) node (usually comments)
Definition: xmlParser.h:281
SEEK_END
#define SEEK_END
Definition: zconf.h:303
XMLNode::addToOrder
void * addToOrder(int memInc, int *_pos, int nc, void *p, int size, XMLElementType xtype)
Definition: xmlParser.cpp:1468
XMLNode::isEmpty
char isEmpty() const
is this node Empty?
Definition: xmlParser.cpp:3417
XML::nIndex
int nIndex
Definition: xmlParser.cpp:784
XMLNodeContents
This structure is given by the function XMLNode::enumContents.
Definition: xmlParser.h:940
xstrnicmp
static int xstrnicmp(XMLCSTR c1, XMLCSTR c2, int l)
Definition: xmlParser.cpp:284
XML::lpNewElement
XMLCSTR lpNewElement
Definition: xmlParser.cpp:788
stringDup
XMLSTR stringDup(XMLCSTR lpszData, int cbData)
Duplicate (copy in a new allocated buffer) the source string.
Definition: xmlParser.cpp:860
XMLNode::createXMLTopNode
static XMLNode createXMLTopNode(XMLCSTR lpszName, char isDeclaration=FALSE)
Create the top node of an XMLNode structure.
Definition: xmlParser.cpp:1414
XMLNode::nClear
int nClear() const
nbr of clear field
Definition: xmlParser.cpp:3367
XMLNode::addClear_WOSD
XMLClear * addClear_WOSD(XMLSTR lpszValue, XMLCSTR lpszOpen=nullptr, XMLCSTR lpszClose=nullptr, XMLElementPosition pos=-1)
Add a new clear Tag.
Definition: xmlParser.cpp:3451
XMLNode::addChild_priv
XMLNode addChild_priv(int, XMLSTR, char, int)
Definition: xmlParser.cpp:1511
myRealloc
static void * myRealloc(void *p, int newsize, int memInc, int sizeofElem)
Definition: xmlParser.cpp:1425
XMLNode::addAttribute_priv
XMLAttribute * addAttribute_priv(int, XMLSTR, XMLSTR)
Definition: xmlParser.cpp:1525
XMLCSTR
#define XMLCSTR
Definition: xmlParser.h:226
NextToken::pStr
XMLCSTR pStr
Definition: xmlParser.cpp:796
XMLNode::removeOrderElement
static int removeOrderElement(XMLNodeData *d, XMLElementType t, int index)
Definition: xmlParser.cpp:1454
XML::lpEndTag
XMLCSTR lpEndTag
Definition: xmlParser.cpp:786
XMLNode::positionOfChildNode
XMLElementPosition positionOfChildNode(int i=0) const
Definition: xmlParser.cpp:3192
s
GLdouble s
Definition: glext.h:3676
len
GLenum GLsizei len
Definition: glext.h:4712
XML_gb2312ByteTable
static const char XML_gb2312ByteTable[256]
Definition: xmlParser.cpp:686
xstrncmp
static int xstrncmp(XMLCSTR c1, XMLCSTR c2, int l)
Definition: xmlParser.cpp:290
XMLNode::emptyXMLClear
static XMLClear emptyXMLClear
Definition: xmlParser.h:522
XMLNode::deleteText
void deleteText(int i=0)
with the name "anAttribute->lpszName" (the "strcmp" function is used to find the right attribute) ...
Definition: xmlParser.cpp:2970
BASE64DECODE_READ_NEXT_CHAR
#define BASE64DECODE_READ_NEXT_CHAR(c)
XMLNode::operator=
XMLNode & operator=(const XMLNode &A)
to allow shallow/fast copy:
Definition: xmlParser.cpp:2766
XMLNode::ParseXMLElement
int ParseXMLElement(void *pXML)
Definition: xmlParser.cpp:1716
XMLNode::getError
static XMLCSTR getError(XMLError error)
this gives you a
Definition: xmlParser.cpp:83
XMLNode::d
XMLNodeData * d
Definition: xmlParser.h:916
mmin
int mmin(const int t1, const int t2)
Definition: xmlParser.cpp:37
XMLNode::nChildNode
int nChildNode() const
nbr of child node
Definition: xmlParser.cpp:3357
XMLNode::getText
XMLCSTR getText(int i=0) const
return ith text field
Definition: xmlParser.cpp:3397
XMLAttribute
struct XMLAttribute XMLAttribute
Structure for XML attribute.
XMLNode::XMLNode
XMLNode()
Definition: xmlParser.h:520
XMLNode::nText
int nText() const
nbr of text field
Definition: xmlParser.cpp:3352
XMLNode::createXMLTopNode_WOSD
static XMLNode createXMLTopNode_WOSD(XMLSTR lpszName, char isDeclaration=FALSE)
Create the top node of an XMLNode structure.
Definition: xmlParser.cpp:1410
XMLParserBase64Tool::encodeLength
static int encodeLength(int inBufLen, char formatted=0)
this object to release memory used by the internal buffer.
Definition: xmlParser.cpp:3674
XMLNode::addText_WOSD
XMLCSTR addText_WOSD(XMLSTR lpszValue, XMLElementPosition pos=-1)
Add a new text content.
Definition: xmlParser.cpp:3441
XMLNode::getAttribute
XMLAttribute getAttribute(int i=0) const
return ith attribute
Definition: xmlParser.cpp:3382
GetNextToken
static NextToken GetNextToken(XML *pXML, int *pcbToken, enum XMLTokenTypeTag *pType)
Definition: xmlParser.cpp:1181
XMLNode::addText_priv
XMLCSTR addText_priv(int, XMLSTR, int)
Definition: xmlParser.cpp:1546
XML::error
enum XMLError error
Definition: xmlParser.cpp:785
XMLNode::nElement
int nElement() const
clear) of the current XMLNode.
Definition: xmlParser.cpp:3372
getNextChar
static XMLCHAR getNextChar(XML *pXML)
Definition: xmlParser.cpp:1168
index
GLuint index
Definition: glext.h:4054
c
const GLubyte * c
Definition: glext.h:6313
XMLNode::addChild_WOSD
XMLNode addChild_WOSD(XMLSTR lpszName, char isDeclaration=FALSE, XMLElementPosition pos=-1)
Add a new child node.
Definition: xmlParser.cpp:3424
XMLNode::emptyTheNode
void emptyTheNode(char force)
Definition: xmlParser.cpp:2718
XMLError
XMLError
Enumeration for XML parse errors.
Definition: xmlParser.h:238
xmltoa
XMLCSTR xmltoa(XMLCSTR t, XMLCSTR v)
Definition: xmlParser.cpp:510
XMLNode::deleteNodeContent
void deleteNodeContent()
The "deleteNodeContent" function forces the deletion of the content of this XMLNode and the subtree...
Definition: xmlParser.cpp:2707
XMLNode::detachFromParent
static int detachFromParent(XMLNodeData *d)
Definition: xmlParser.cpp:2685
XMLSTR
#define XMLSTR
Definition: xmlParser.h:227
XMLNode::indexClear
int indexClear(XMLCSTR lpszValue) const
Definition: xmlParser.cpp:3036
characterEncoding
static XMLNode::XMLCharEncoding characterEncoding
Definition: xmlParser.cpp:33
XMLNode::setGlobalOptions
static char setGlobalOptions(XMLCharEncoding characterEncoding=XMLNode::char_encoding_UTF8, char guessWideCharChars=1, char dropWhiteSpace=1, char removeCommentsInMiddleOfText=1)
Sets the global options for the conversions.
Definition: xmlParser.cpp:3501
XMLNode::updateAttribute_WOSD
XMLAttribute * updateAttribute_WOSD(XMLAttribute *newAttribute, XMLAttribute *oldAttribute)
if the attribute to update is
Definition: xmlParser.cpp:2928
XMLNode::updateName
XMLCSTR updateName(XMLCSTR lpszName)
change node&#39;s name
Definition: xmlParser.cpp:3457
XMLNode::enumContents
XMLNodeContents enumContents(XMLElementPosition i) const
enumerate all the different contents (attribute,child,text,
Definition: xmlParser.cpp:3313
XMLNode::emptyNode
static XMLNode emptyNode()
return XMLNode::emptyXMLNode;
Definition: xmlParser.cpp:3418
XMLParserBase64Tool::decodeSize
static unsigned int decodeSize(XMLCSTR inString, XMLError *xe=nullptr)
containing the base64 string containing the binary data encoded from "inByteBuf"
Definition: xmlParser.cpp:3728
b
GLubyte GLubyte b
Definition: glext.h:6279
XML::cbNewElement
int cbNewElement
Definition: xmlParser.cpp:789
XML_isSPACECHAR
#define XML_isSPACECHAR(ch)
Definition: xmlParser.cpp:1147
XMLNode::positionOfText
XMLElementPosition positionOfText(int i=0) const
Definition: xmlParser.cpp:3182
XMLClear::lpszValue
XMLCSTR lpszValue
Definition: xmlParser.h:283
XMLNode::positionOfClear
XMLElementPosition positionOfClear(int i=0) const
Definition: xmlParser.cpp:3187
Status
enum Status { eInsideTag=0, eOutsideTag } Status
Definition: xmlParser.cpp:804
charmemset
static void charmemset(XMLSTR dest, XMLCHAR c, int l)
Definition: xmlParser.cpp:2366
dropWhiteSpace
static char dropWhiteSpace
Definition: xmlParser.cpp:34
CountLinesAndColumns
static void CountLinesAndColumns(XMLCSTR lpXML, int nUpto, XMLResults *pResults)
Definition: xmlParser.cpp:2191
XMLNode::findPosition
static XMLElementPosition findPosition(XMLNodeData *d, int index, XMLElementType xtype)
Definition: xmlParser.cpp:1443
xstricmp
static int xstricmp(XMLCSTR c1, XMLCSTR c2)
Definition: xmlParser.cpp:288
XMLNode::XMLNodeData
struct XMLNode::XMLNodeDataTag XMLNodeData
XMLNode::emptyXMLAttribute
static XMLAttribute emptyXMLAttribute
Definition: xmlParser.h:523
xstrcpy
static XMLSTR xstrcpy(XMLSTR c1, XMLCSTR c2)
Definition: xmlParser.cpp:298
XML_sjisByteTable
static const char XML_sjisByteTable[256]
Definition: xmlParser.cpp:651
XMLEntities
static XMLCharacterEntity XMLEntities[]
Definition: xmlParser.cpp:69
XMLNode::exactMemory
static void exactMemory(XMLNodeData *d)
Definition: xmlParser.cpp:1643
xfopen
static FILE * xfopen(XMLCSTR filename, XMLCSTR mode)
Definition: xmlParser.cpp:272
LENSTR
#define LENSTR(lpsz)
mrpt::system::os::fprintf
int fprintf(FILE *fil, const char *format,...) noexcept MRPT_printf_format_check(2
An OS-independent version of fprintf.
Definition: os.cpp:406
XMLNode::guessCharEncoding
static XMLCharEncoding guessCharEncoding(void *buffer, int bufLen, char useXMLEncodingAttribute=1)
Guess the character encoding of the string (ascii, utf8 or shift-JIS)
Definition: xmlParser.cpp:3541
XMLNode::parseFile
static XMLNode parseFile(XMLCSTR filename, XMLCSTR tag=nullptr, XMLResults *pResults=nullptr)
Parse an XML file and return the root of a XMLNode tree representing the file.
Definition: xmlParser.cpp:2283
ALLXMLClearTag::lpszOpen
XMLCSTR lpszOpen
Definition: xmlParser.cpp:45
mode
GLint mode
Definition: glext.h:5669
XMLNode::updateAttribute
XMLAttribute * updateAttribute(XMLAttribute *newAttribute, XMLAttribute *oldAttribute)
if the attribute to update is
Definition: xmlParser.cpp:3461
XMLAttribute::lpszName
XMLCSTR lpszName
Definition: xmlParser.h:291
XMLNode::addText
XMLCSTR addText(XMLCSTR lpszValue, XMLElementPosition pos=-1)
Add a new text content.
Definition: xmlParser.cpp:3437
XMLNode::indexText
int indexText(XMLCSTR lpszValue) const
Definition: xmlParser.cpp:2955
v
const GLdouble * v
Definition: glext.h:3678
XMLNode::createXMLString
XMLSTR createXMLString(int nFormat=1, int *pnSize=nullptr) const
user-friendly explanation of the parsing error
Definition: xmlParser.cpp:2661
XMLNode::addAttribute_WOSD
XMLAttribute * addAttribute_WOSD(XMLSTR lpszName, XMLSTR lpszValue)
Add a new attribute.
Definition: xmlParser.cpp:3433
XML::nIndexMissigEndTag
int nIndexMissigEndTag
Definition: xmlParser.cpp:784
XMLNode::updateText_WOSD
XMLCSTR updateText_WOSD(XMLSTR lpszNewValue, int i=0)
change the name of the attribute if the attribute to update is missing, a new one will be added ...
Definition: xmlParser.cpp:2991
XMLElementPosition
int XMLElementPosition
XMLElementPosition are not interchangeable with simple indexes.
Definition: xmlParser.h:296
r
GLdouble GLdouble GLdouble r
Definition: glext.h:3705
ToXMLStringTool::lengthXMLString
static int lengthXMLString(XMLCSTR source)
deprecated: use "toXML" instead
Definition: xmlParser.cpp:920
SEEK_SET
#define SEEK_SET
Definition: zconf.h:301
XMLParserBase64Tool::decode
unsigned char * decode(XMLCSTR inString, int *outByteLen=nullptr, XMLError *xe=nullptr)
The "decode" function returns a pointer to a buffer containing the binary data decoded from "inString...
Definition: xmlParser.cpp:3882
XMLNode::parseClearTag
char parseClearTag(void *px, void *pa)
Definition: xmlParser.cpp:1587
XML_ByteTable
static const char * XML_ByteTable
Definition: xmlParser.cpp:756
base64Fillchar
static const char base64Fillchar
Definition: xmlParser.cpp:3636
XML_utf8ByteTable
static const char XML_utf8ByteTable[256]
Definition: xmlParser.cpp:604
XMLNode::updateClear_WOSD
XMLClear * updateClear_WOSD(XMLSTR lpszNewContent, int i=0)
is missing, a new one will be added
Definition: xmlParser.cpp:3060
FALSE
#define FALSE
Definition: xmlParser.h:231
myTagCompare
char myTagCompare(XMLCSTR cclose, XMLCSTR copen)
Definition: xmlParser.cpp:1152
xmltob
char xmltob(XMLCSTR t, char v)
Definition: xmlParser.cpp:489
status
_u8 status
Definition: rplidar_cmd.h:19
name
GLuint const GLchar * name
Definition: glext.h:4054
source
GLsizei GLsizei GLchar * source
Definition: glext.h:4082
XMLAttribute
Structure for XML attribute.
Definition: xmlParser.h:289
base64DecodeTable
const unsigned char base64DecodeTable[]
Definition: xmlParser.cpp:3646
XML::nFirst
int nFirst
Definition: xmlParser.cpp:790
guessWideCharChars
static char guessWideCharChars
Definition: xmlParser.cpp:34
NextToken::pClr
ALLXMLClearTag * pClr
Definition: xmlParser.cpp:795
ALLXMLClearTag::lpszClose
XMLCSTR lpszClose
Definition: xmlParser.cpp:47
myIsTextWideChar
char myIsTextWideChar(const void *b, int l)
Definition: xmlParser.cpp:193
XMLAttribute::lpszValue
XMLCSTR lpszValue
Definition: xmlParser.h:292
mrpt::system::os::fopen
FILE * fopen(const char *fileName, const char *mode) noexcept
An OS-independent version of fopen.
Definition: os.cpp:255
XMLResults::error
enum XMLError error
Definition: xmlParser.h:276
XMLNode::addChild
XMLNode addChild(XMLCSTR lpszName, char isDeclaration=FALSE, XMLElementPosition pos=-1)
Add a new child node.
Definition: xmlParser.cpp:3419
XMLNode::CreateXMLStringR
static int CreateXMLStringR(XMLNodeData *pEntry, XMLSTR lpszMarker, int nFormat)
Definition: xmlParser.cpp:2376
xmltol
long xmltol(XMLCSTR t, long v)
Definition: xmlParser.cpp:499
size
GLsizeiptr size
Definition: glext.h:3923
XML::lpszText
XMLCSTR lpszText
Definition: xmlParser.cpp:783
XMLTokenType
enum XMLTokenTypeTag XMLTokenType
x
GLenum GLint x
Definition: glext.h:3538
XMLNode::getClear
XMLClear getClear(int i=0) const
return ith clear field (comments)
Definition: xmlParser.cpp:3377
removeCommentsInMiddleOfText
static char removeCommentsInMiddleOfText
Definition: xmlParser.cpp:35
mrpt::system::os::strcpy
char * strcpy(char *dest, size_t destSize, const char *source) noexcept
An OS-independent version of strcpy.
Definition: os.cpp:297
XMLNode::getAttributeValue
XMLCSTR getAttributeValue(int i=0) const
return ith attribute value
Definition: xmlParser.cpp:3392
XMLNode::emptyXMLNode
static XMLNode emptyXMLNode
Definition: xmlParser.h:520
XMLTokenTypeTag
XMLTokenTypeTag
Definition: xmlParser.cpp:766
XMLNode::isDeclaration
char isDeclaration() const
is this node a declaration <? .... ?>
Definition: xmlParser.cpp:3412
XML::cbEndTag
int cbEndTag
Definition: xmlParser.cpp:787
TRUE
#define TRUE
Definition: xmlParser.h:234
XMLParserBase64Tool::freeBuffer
void freeBuffer()
Call this function when you have finished using.
Definition: xmlParser.cpp:3667
myWideCharToMultiByte
char * myWideCharToMultiByte(const wchar_t *s)
Definition: xmlParser.cpp:243
data
GLsizei GLsizei GLenum GLenum const GLvoid * data
Definition: glext.h:3546
a
GLubyte GLubyte GLubyte a
Definition: glext.h:6279
p
GLfloat GLfloat p
Definition: glext.h:6305
XMLNode::getAttributeName
XMLCSTR getAttributeName(int i=0) const
return ith attribute name
Definition: xmlParser.cpp:3387
freeXMLString
void freeXMLString(XMLSTR t)
to free the string allocated inside the "stringDup" function or the "createXMLString" function...
Definition: xmlParser.cpp:28
XMLNode::deleteClear
void deleteClear(int i=0)
"lpszValue" inside the current XMLNode (direct "pointer-to-pointer" comparison is used to find the ri...
Definition: xmlParser.cpp:3020
XMLClear::lpszCloseTag
XMLCSTR lpszCloseTag
Definition: xmlParser.h:285
XMLNode::nChildNode
int nChildNode(XMLCSTR name) const
return the number of child node with specific name
Definition: xmlParser.cpp:3097
XMLNode::deepCopy
XMLNode deepCopy() const
deep copy (duplicate/clone) a XMLNode
Definition: xmlParser.cpp:2789
XMLResults
Structure used to obtain error details if the parse fails.
Definition: xmlParser.h:274
xmltof
double xmltof(XMLCSTR t, double v)
Definition: xmlParser.cpp:504
mrpt::system::os::sprintf
int sprintf(char *buf, size_t bufSize, const char *format,...) noexcept MRPT_printf_format_check(3
An OS-independent version of sprintf (Notice the bufSize param, which may be ignored in some compiler...
Definition: os.cpp:189
ToXMLStringTool::toXMLUnSafe
static XMLSTR toXMLUnSafe(XMLSTR dest, XMLCSTR source)
that contains a XML-encoded string based on the "source" parameter.
Definition: xmlParser.cpp:875
xstrlen
static int xstrlen(XMLCSTR c)
Definition: xmlParser.cpp:276
xmltoi
int xmltoi(XMLCSTR t, int v)
Definition: xmlParser.cpp:494
fromXMLString
XMLSTR fromXMLString(XMLCSTR s, int lo, XML *pXML)
Definition: xmlParser.cpp:970
XMLNode::getName
XMLCSTR getName() const
name of the node
Definition: xmlParser.cpp:3347
mrpt::system::os::memcpy
void memcpy(void *dest, size_t destSize, const void *src, size_t copyCount) noexcept
An OS and compiler independent version of "memcpy".
Definition: os.cpp:356
XMLNode::getChildNode
XMLNode getChildNode(int i=0) const
return ith child node
Definition: xmlParser.cpp:3402
XMLNode::addAttribute
XMLAttribute * addAttribute(XMLCSTR lpszName, XMLCSTR lpszValuev)
it will be detached from it&#39;s parents before being attached to the current XMLNode ...
Definition: xmlParser.cpp:3429
XML_legacyByteTable
static const char XML_legacyByteTable[256]
Definition: xmlParser.cpp:639
XMLNode::addClear_priv
XMLClear * addClear_priv(int, XMLSTR, XMLCSTR, XMLCSTR, int)
Definition: xmlParser.cpp:1562
XMLNode::openFileHelper
static XMLNode openFileHelper(XMLCSTR filename, XMLCSTR tag=nullptr)
Parse an XML file and return the root of a XMLNode tree representing the file.
Definition: xmlParser.cpp:529


Page generated by Doxygen 1.8.14 for MRPT 1.9.9 Git: 7d5e6d718 Fri Aug 24 01:51:28 2018 +0200 at lun nov 2 08:35:50 CET 2020