nel/src/misc/i_xml.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 #include "stdmisc.h"
  21
  22 #include "nel/misc/i_xml.h"
  23
  24 #ifndef NL_DONT_USE_EXTERNAL_CODE
  25
  26 // Include from libxml2
  27 #include <libxml/xmlerror.h>
  28
  29 using namespace std;
  30
  31 #define NLMISC_READ_BUFFER_SIZE 1024
  32
  33 #ifdef DEBUG_NEW
  34         #define new DEBUG_NEW
  35 #endif
  36
  37 namespace NLMISC
  38 {
  39
  40 // *********************************************************
  41
  42 const char SEPARATOR = ' ';
  43
  44 std::string CIXml::_ErrorString;
  45
  46 bool CIXml::_LibXmlIntialized = false;
  47
  48 // ***************************************************************************
  49
  50 #define readnumber(dest,digits) \
  51         string number_as_string; \
  52         serialSeparatedBufferIn( number_as_string ); \
  53         NLMISC::fromString(number_as_string, dest);
  54
  55 // ***************************************************************************
  56
  57 inline void CIXml::flushContentString ()
  58 {
  59         // String size
  60         _ContentString.erase ();
  61
  62         // Reset
  63         _ContentStringIndex = 0;
  64 }
  65
  66 // ***************************************************************************
  67
  68 CIXml::CIXml () : IStream (true /* Input mode */)
  69 {
  70         // Not initialized
  71         _Parser = NULL;
  72         _CurrentElement = NULL;
  73         _CurrentNode = NULL;
  74         _PushBegin = false;
  75         _AttribPresent = false;
  76         _TryBinaryMode = false;
  77         _BinaryStream = NULL;
  78 }
  79
  80 // ***************************************************************************
  81
  82 CIXml::CIXml (bool tryBinaryMode) : IStream (true /* Input mode */)
  83 {
  84         // Not initialized
  85         _Parser = NULL;
  86         _CurrentElement = NULL;
  87         _CurrentNode = NULL;
  88         _PushBegin = false;
  89         _AttribPresent = false;
  90         _TryBinaryMode = tryBinaryMode;
  91         _BinaryStream = NULL;
  92 }
  93
  94 // ***************************************************************************
  95
  96 CIXml::~CIXml ()
  97 {
  98         // Release
  99         release ();
 100 }
 101
 102 // ***************************************************************************
 103
 104 void CIXml::release ()
 105 {
 106         // Release the parser
 107         if (_Parser)
 108         {
 109                 // Free it
 110                 xmlClearParserCtxt (_Parser);
 111                 xmlFreeParserCtxt (_Parser);
 112
 113                 _Parser = NULL;
 114         }
 115
 116         // Not initialized
 117         _CurrentElement = NULL;
 118         _CurrentNode = NULL;
 119         _PushBegin = false;
 120         _AttribPresent = false;
 121         _ErrorString.clear();
 122
 123         resetPtrTable();
 124 }
 125
 126 // ***************************************************************************
 127
 128 void xmlGenericErrorFuncRead (void *ctx, const char *msg, ...)
 129 {
 130         // Get the error string
 131         string str;
 132         NLMISC_CONVERT_VARGS (str, msg, NLMISC::MaxCStringSize);
 133         CIXml::_ErrorString += str;
 134 }
 135
 136 // ***************************************************************************
 137
 138 bool CIXml::init (IStream &stream)
 139 {
 140         // Release
 141         release ();
 142
 143         initLibXml();
 144
 145         // Default : XML mode
 146         _BinaryStream = NULL;
 147
 148         // Input stream ?
 149         if (stream.isReading())
 150         {
 151                 // Set XML mode
 152                 setXMLMode (true);
 153
 154                 // Get current position
 155                 sint32 pos = stream.getPos ();
 156
 157                 // Go to end
 158                 bool seekGood = stream.seek (0, end);
 159                 nlassert (seekGood);
 160
 161                 // Get input stream length
 162                 sint32 length = stream.getPos () - pos;
 163
 164                 // Go to start
 165                 stream.seek (pos, begin);
 166
 167                 // The read buffer
 168         char buffer[NLMISC_READ_BUFFER_SIZE];
 169
 170                 // Fill the buffer
 171                 stream.serialBuffer ((uint8*)buffer, 4);
 172                 length -= 4;
 173
 174                 // Try binary mode
 175                 if (_TryBinaryMode)
 176                 {
 177                         char header[5];
 178                         header[0] = buffer[0];
 179                         header[1] = buffer[1];
 180                         header[2] = buffer[2];
 181                         header[3] = buffer[3];
 182                         header[4] = '\0';
 183                         toLowerAscii(header);
 184
 185                         // Does it a xml stream ?
 186                         if (strcmp(header, "<?xm"))
 187                         {
 188                                 // NO ! Go in binary mode
 189                                 _BinaryStream = &stream;
 190
 191                                 // Seek back to the start
 192                                 stream.seek (pos, begin);
 193
 194                                 // Done
 195                                 return true;
 196                         }
 197                 }
 198
 199                 _ErrorString.clear();
 200
 201                 // The parser context
 202         _Parser = xmlCreatePushParserCtxt(NULL, NULL, buffer, 4, NULL);
 203                 nlassert (_Parser);
 204
 205                 // For all the file
 206         while (length>=NLMISC_READ_BUFFER_SIZE)
 207                 {
 208                         // Fill the buffer
 209                         stream.serialBuffer ((uint8*)buffer, NLMISC_READ_BUFFER_SIZE);
 210
 211                         // Read a buffer
 212             int res = xmlParseChunk(_Parser, buffer, NLMISC_READ_BUFFER_SIZE, 0);
 213
 214                         // Error code ?
 215                         if (res)
 216                         {
 217                                 throw EXmlParsingError (_ErrorString);
 218                         }
 219
 220                         // Length left
 221                         length -= NLMISC_READ_BUFFER_SIZE;
 222         }
 223
 224                 // Fill the buffer
 225                 stream.serialBuffer ((uint8*)buffer, length);
 226
 227                 // Parse the last buffer
 228                 int res = xmlParseChunk(_Parser, buffer, length, 1);
 229
 230                 // Error code ?
 231                 if (res)
 232                 {
 233                         throw EXmlParsingError (_ErrorString);
 234                 }
 235
 236                 // Ok
 237                 return true;
 238         }
 239         else
 240         {
 241                 nlwarning ("XML: The stream is not an input stream.");
 242         }
 243
 244         // Error
 245         return false;
 246 }
 247
 248 // ***************************************************************************
 249
 250 void CIXml::serialSeparatedBufferIn ( string &value, bool checkSeparator )
 251 {
 252         nlassert( isReading() );
 253
 254         // Output stream has been initialized ?
 255         if ( _Parser )
 256         {
 257                 // Current node presents ?
 258                 if (_CurrentElement)
 259                 {
 260                         // Write a push attribute ?
 261                         if (_PushBegin)
 262                         {
 263                                 // Current attrib is set ?
 264                                 if (_AttribPresent)
 265                                 {
 266                                         // Should have a current element
 267                                         nlassert (_CurrentElement);
 268
 269                                         // Get the attribute
 270                                         xmlChar *attributeValue = xmlGetProp (_CurrentElement, (const xmlChar*)_AttribName.c_str());
 271
 272                                         // Attribute is here ?
 273                                         if (attributeValue)
 274                                         {
 275                                                 // Copy the value
 276                                                 value = (const char*)attributeValue;
 277
 278                                                 // Delete the value
 279                                                 xmlFree ((void*)attributeValue);
 280                                         }
 281                                         else
 282                                         {
 283                                                 // Node name must not be NULL
 284                                                 nlassert (_CurrentElement->name);
 285
 286                                                 // Make an error message
 287                                                 char tmp[512];
 288                                                 smprintf (tmp, 512, "NeL XML Syntax error in block line %d\nAttribute \"%s\" is missing in node \"%s\"",
 289                                                         (int)_CurrentElement->line, _AttribName.c_str(), _CurrentElement->name);
 290                                                 throw EXmlParsingError (tmp);
 291                                         }
 292
 293                                         // The attribute has been used
 294                                         _AttribPresent = false;
 295                                 }
 296                                 else
 297                                 {
 298                                         // * Error, the stream don't use XML streaming properly
 299                                         // * You must take care of this in your last serial call:
 300                                         // * - Between xmlPushBegin() and xmlPushEnd(), before each serial, you must set the attribute name with xmlSetAttrib.
 301                                         // * - Between xmlPushBegin() and xmlPushEnd(), you must serial only basic objects (numbers and strings).
 302                                         nlerror ( "Error, the stream don't use XML streaming properly" );
 303                                 }
 304                         }
 305                         else
 306                         {
 307                                 // Content length
 308                                 uint length = (uint)_ContentString.length();
 309
 310                                 // String empty ?
 311                                 if (length==0)
 312                                 {
 313                                         // Try to open the node
 314                                         do
 315                                         {
 316                                                 // If no more node, empty string
 317                                                 if (_CurrentNode == NULL)
 318                                                 {
 319                                                         value.clear();
 320                                                         _ContentStringIndex = 0;
 321                                                         _ContentString.erase ();
 322                                                         return;
 323                                                 }
 324
 325                                                 // Node with the good name
 326                                                 if (_CurrentNode->type == XML_TEXT_NODE)
 327                                                 {
 328                                                         // Stop searching
 329                                                         break;
 330                                                 }
 331                                                 else
 332                                                         // Get next
 333                                                         _CurrentNode = _CurrentNode->next;
 334                                         }
 335                                         while (_CurrentNode);
 336
 337                                         // Not found ?
 338                                         if (_CurrentNode != NULL)
 339                                         {
 340                                                 // Read the content
 341                                                 const char *content = (const char*)xmlNodeGetContent (_CurrentNode);
 342                                                 if (content)
 343                                                 {
 344                                                         _ContentString = content;
 345
 346                                                         // Delete the value
 347                                                         xmlFree ((void*)content);
 348                                                 }
 349                                                 else
 350                                                         _ContentString.erase ();
 351
 352                                                 // Set the current index
 353                                                 _ContentStringIndex = 0;
 354
 355                                                 // New length
 356                                                 length = (uint)_ContentString.length();
 357                                         }
 358                                 }
 359
 360                                 // Keyword in the buffer ?
 361                                 if (_ContentStringIndex < length)
 362                                 {
 363                                         // First index
 364                                         uint first = _ContentStringIndex;
 365
 366                                         // Have to take care of separators ?
 367                                         if (checkSeparator)
 368                                         {
 369                                                 // Scan to the end
 370                                                 while (_ContentStringIndex < length)
 371                                                 {
 372                                                         // Not a separator ?
 373                                                         if ( (_ContentString[_ContentStringIndex]==SEPARATOR) || (_ContentString[_ContentStringIndex]=='\n') )
 374                                                         {
 375                                                                 _ContentStringIndex++;
 376                                                                 break;
 377                                                         }
 378
 379                                                         // Next char
 380                                                         _ContentStringIndex++;
 381                                                 }
 382                                         }
 383                                         else
 384                                         {
 385                                                 // Copy all the string
 386                                                 _ContentStringIndex = length;
 387                                         }
 388
 389                                         // Make a string
 390                                         value.assign (_ContentString, first, _ContentStringIndex-first);
 391                                 }
 392                                 else
 393                                 {
 394                                         // Should have a name
 395                                         nlassert (_CurrentElement->name);
 396
 397                                         // Make an error message
 398                                         char tmp[512];
 399                                         smprintf (tmp, 512, "NeL XML Syntax error in block line %d \nMissing keywords in text child node in the node %s",
 400                                                 (int)_CurrentElement->line, _CurrentElement->name);
 401                                         throw EXmlParsingError (tmp);
 402                                 }
 403                         }
 404                 }
 405                 else
 406                 {
 407                         // * Error, no current node present.
 408                         // * Check that your serial is initialy made between a xmlPushBegin and xmlPushEnd calls.
 409                         nlerror ( "Error, the stream don't use XML streaming properly" );
 410                 }
 411         }
 412         else
 413         {
 414                 nlerror ( "Output stream has not been initialized" );
 415         }
 416 }
 417
 418 // ***************************************************************************
 419
 420 void CIXml::serial(uint8 &b)
 421 {
 422         if (_BinaryStream)
 423         {
 424                 _BinaryStream->serial(b);
 425         }
 426         else
 427         {
 428                 // Read the number
 429                 readnumber( b, 3 );
 430         }
 431 }
 432
 433 // ***************************************************************************
 434
 435 void CIXml::serial(sint8 &b)
 436 {
 437         if (_BinaryStream)
 438         {
 439                 _BinaryStream->serial(b);
 440         }
 441         else
 442         {
 443                 readnumber( b, 4 );
 444         }
 445 }
 446
 447 // ***************************************************************************
 448
 449 void CIXml::serial(uint16 &b)
 450 {
 451         if (_BinaryStream)
 452         {
 453                 _BinaryStream->serial(b);
 454         }
 455         else
 456         {
 457                 readnumber( b, 5 );
 458         }
 459 }
 460
 461 // ***************************************************************************
 462
 463 void CIXml::serial(sint16 &b)
 464 {
 465         if (_BinaryStream)
 466         {
 467                 _BinaryStream->serial(b);
 468         }
 469         else
 470         {
 471                 readnumber( b, 6 );
 472         }
 473 }
 474
 475 // ***************************************************************************
 476
 477 inline uint32 atoui( const char *ident)
 478 {
 479         return (uint32) strtoul (ident, NULL, 10);
 480 }
 481
 482 void CIXml::serial(uint32 &b)
 483 {
 484         if (_BinaryStream)
 485         {
 486                 _BinaryStream->serial(b);
 487         }
 488         else
 489         {
 490                 readnumber( b, 10 );
 491         }
 492 }
 493
 494 // ***************************************************************************
 495
 496 void CIXml::serial(sint32 &b)
 497 {
 498         if (_BinaryStream)
 499         {
 500                 _BinaryStream->serial(b);
 501         }
 502         else
 503         {
 504                 readnumber( b, 11 );
 505         }
 506 }
 507
 508 // ***************************************************************************
 509
 510 void CIXml::serial(uint64 &b)
 511 {
 512         if (_BinaryStream)
 513         {
 514                 _BinaryStream->serial(b);
 515         }
 516         else
 517         {
 518                 readnumber( b, 20 );
 519         }
 520 }
 521
 522 // ***************************************************************************
 523
 524 void CIXml::serial(sint64 &b)
 525 {
 526         if (_BinaryStream)
 527         {
 528                 _BinaryStream->serial(b);
 529         }
 530         else
 531         {
 532                 readnumber( b, 20 );
 533         }
 534 }
 535
 536 // ***************************************************************************
 537
 538 void CIXml::serial(float &b)
 539 {
 540         if (_BinaryStream)
 541         {
 542                 _BinaryStream->serial(b);
 543         }
 544         else
 545         {
 546                 readnumber( b, 128 );
 547         }
 548 }
 549
 550 // ***************************************************************************
 551
 552 void CIXml::serial(double &b)
 553 {
 554         if (_BinaryStream)
 555         {
 556                 _BinaryStream->serial(b);
 557         }
 558         else
 559         {
 560                 readnumber( b, 128 );
 561         }
 562 }
 563
 564 // ***************************************************************************
 565
 566 void CIXml::serial(bool &b)
 567 {
 568         if (_BinaryStream)
 569         {
 570                 _BinaryStream->serial(b);
 571         }
 572         else
 573         {
 574                 serialBit(b);
 575         }
 576 }
 577
 578 // ***************************************************************************
 579
 580 void CIXml::serialBit(bool &bit)
 581 {
 582         if (_BinaryStream)
 583         {
 584                 _BinaryStream->serialBit(bit);
 585         }
 586         else
 587         {
 588                 uint8 u;
 589                 serial (u);
 590                 bit = (u!=0);
 591         }
 592 }
 593
 594 // ***************************************************************************
 595
 596 #ifndef NL_OS_CYGWIN
 597 void CIXml::serial(char &b)
 598 {
 599         if (_BinaryStream)
 600         {
 601                 _BinaryStream->serial(b);
 602         }
 603         else
 604         {
 605                 string toto;
 606                 serialSeparatedBufferIn ( toto );
 607
 608                 // Good value ?
 609                 if (toto.length()!=1)
 610                 {
 611                         // Protect error
 612                         if (_Parser)
 613                         {
 614                                 // Should have a name
 615                                 nlassert (_CurrentElement->name);
 616
 617                                 // Make an error message
 618                                 char tmp[512];
 619                                 smprintf (tmp, 512, "NeL XML Syntax error in block line %d \nValue is not a char in the node named %s",
 620                                         (int)_CurrentElement->line, _CurrentElement->name);
 621                                 throw EXmlParsingError (tmp);
 622                         }
 623                         else
 624                         {
 625                                 nlerror ( "Output stream has not been initialized" );
 626                         }
 627                 }
 628                 else
 629                         b=toto[0];
 630         }
 631 }
 632 #endif // NL_OS_CYGWIN
 633
 634 // ***************************************************************************
 635
 636 void CIXml::serial(std::string &b)
 637 {
 638         nlassert( isReading() );
 639
 640         if (_BinaryStream)
 641         {
 642                 _BinaryStream->serial(b);
 643         }
 644         else
 645         {
 646                 // Attibute ?
 647                 if (_PushBegin)
 648                 {
 649                         // Only serial the string
 650                         serialSeparatedBufferIn ( b, false );
 651                 }
 652                 else
 653                 {
 654                         // Open a string node
 655                         xmlPush ("S");
 656
 657                         // Serial the string
 658                         serialSeparatedBufferIn ( b, false );
 659
 660                         // Close the node
 661                         xmlPop ();
 662                 }
 663         }
 664 }
 665
 666 // ***************************************************************************
 667
 668 void CIXml::serial(ucstring &b)
 669 {
 670         nlassert( isReading() );
 671
 672         if (_BinaryStream)
 673         {
 674                 _BinaryStream->serial(b);
 675         }
 676         else
 677         {
 678                 // Serial a simple string
 679                 string tmp;
 680
 681                 // Serial this string
 682                 serial (tmp);
 683
 684                 // Return a ucstring
 685                 b.fromUtf8(tmp);
 686         }
 687 }
 688
 689 // ***************************************************************************
 690
 691 void CIXml::serialBuffer(uint8 *buf, uint len)
 692 {
 693         if (_BinaryStream)
 694         {
 695                 _BinaryStream->serialBuffer(buf, len);
 696         }
 697         else
 698         {
 699                 // Open a node
 700                 xmlPush ("BUFFER");
 701
 702                 // Serialize the buffer
 703                 for (uint i=0; i<len; i++)
 704                 {
 705                         xmlPush ("ELM");
 706
 707                         serial (buf[i]);
 708
 709                         xmlPop ();
 710                 }
 711
 712                 // Close the node
 713                 xmlPop ();
 714         }
 715 }
 716
 717 // ***************************************************************************
 718
 719 bool CIXml::xmlPushBeginInternal (const std::string &nodeName)
 720 {
 721         nlassert( isReading() );
 722
 723         if (_BinaryStream)
 724         {
 725                 return true;
 726         }
 727         else
 728         {
 729                 // Check _Parser
 730                 if ( _Parser )
 731                 {
 732                         // Can make a xmlPushBegin ?
 733                         if ( ! _PushBegin )
 734                         {
 735                                 // Current node exist ?
 736                                 if (_CurrentNode==NULL)
 737                                 {
 738                                         // Get the first node
 739                                         _CurrentNode = xmlDocGetRootElement (_Parser->myDoc);
 740
 741                                         // Has a root node ?
 742                                         if (_CurrentNode)
 743                                         {
 744                                                 // Node name must not be NULL
 745                                                 nlassert (_CurrentNode->name);
 746
 747                                                 // Node element with the good name ?
 748                                                 if ( (_CurrentNode->type != XML_ELEMENT_NODE) || ( (const char*)_CurrentNode->name != nodeName) )
 749                                                 {
 750                                                         // Make an error message
 751                                                         char tmp[512];
 752                                                         smprintf (tmp, 512, "NeL XML Syntax error : root node has the wrong name : \"%s\" should have \"%s\"",
 753                                                                 _CurrentNode->name, nodeName.c_str());
 754                                                         throw EXmlParsingError (tmp);
 755                                                 }
 756                                         }
 757                                         else
 758                                         {
 759                                                 // Make an error message
 760                                                 char tmp[512];
 761                                                 smprintf (tmp, 512, "NeL XML Syntax error : no root node found.");
 762                                                 throw EXmlParsingError (tmp);
 763                                         }
 764                                 }
 765
 766                                 // Try to open the node
 767                                 do
 768                                 {
 769                                         // Node name must not be NULL
 770                                         nlassert (_CurrentNode->name);
 771
 772                                         // Node with the good name
 773                                         if ( (_CurrentNode->type == XML_ELEMENT_NODE) && ( (const char*)_CurrentNode->name == nodeName) )
 774                                         {
 775                                                 // Save current element
 776                                                 _CurrentElement = _CurrentNode;
 777
 778                                                 // Stop searching
 779                                                 break;
 780                                         }
 781                                         else
 782                                                 // Get next
 783                                                 _CurrentNode = _CurrentNode->next;
 784                                 }
 785                                 while (_CurrentNode);
 786
 787                                 // Not found ?
 788                                 if (_CurrentNode == NULL)
 789                                 {
 790                                         // Make an error message
 791                                         char tmp[512];
 792                                         smprintf (tmp, 512, "NeL XML Syntax error in block line %d \nCan't open the node named %s in node named %s",
 793                                                 (int)_CurrentElement->line, nodeName.c_str(), _CurrentElement->name);
 794                                         throw EXmlParsingError (tmp);
 795                                 }
 796
 797                                 // Get first child
 798                                 _CurrentNode = _CurrentNode->children;
 799
 800                                 // Push begun
 801                                 _PushBegin = true;
 802
 803                                 // Flush current string
 804                                 flushContentString ();
 805                         }
 806                         else
 807                         {
 808                                 nlerror ( "You must close your xmlPushBegin - xmlPushEnd before calling a new xmlPushBegin.");
 809                                 return false;
 810                         }
 811                 }
 812                 else
 813                 {
 814                         nlerror ( "Output stream has not been initialized.");
 815                         return false;
 816                 }
 817
 818                 // Ok
 819                 return true;
 820         }
 821 }
 822
 823 // ***************************************************************************
 824
 825 bool CIXml::xmlPushEndInternal ()
 826 {
 827         nlassert( isReading() );
 828
 829         if (_BinaryStream)
 830         {
 831                 return true;
 832         }
 833         else
 834         {
 835                 // Check _Parser
 836                 if ( _Parser )
 837                 {
 838                         // Can make a xmlPushEnd ?
 839                         if ( _PushBegin )
 840                         {
 841                                 // Push begun
 842                                 _PushBegin = false;
 843                         }
 844                         else
 845                         {
 846                                 nlerror ( "You must call xmlPushBegin before calling xmlPushEnd.");
 847                                 return false;
 848                         }
 849                 }
 850                 else
 851                 {
 852                         nlerror ( "Output stream has not been initialized.");
 853                         return false;
 854                 }
 855
 856                 // Ok
 857                 return true;
 858         }
 859 }
 860
 861 // ***************************************************************************
 862
 863 bool CIXml::xmlPopInternal ()
 864 {
 865         nlassert( isReading() );
 866
 867         if (_BinaryStream)
 868         {
 869                 return true;
 870         }
 871         else
 872         {
 873                 // Check _Parser
 874                 if ( _Parser )
 875                 {
 876                         // Not in the push mode ?
 877                         if ( ! _PushBegin )
 878                         {
 879                                 // Some content to write ?
 880                                 flushContentString ();
 881
 882                                 // Get parents
 883                                 _CurrentNode = _CurrentElement;
 884                                 _CurrentElement = _CurrentElement->parent;
 885                                 _CurrentNode = _CurrentNode->next;
 886                         }
 887                         else
 888                         {
 889                                 nlerror ( "You must call xmlPop after xmlPushEnd.");
 890                                 return false;
 891                         }
 892                 }
 893                 else
 894                 {
 895                         nlerror ( "Output stream has not been initialized.");
 896                         return false;
 897                 }
 898
 899                 // Ok
 900                 return true;
 901         }
 902 }
 903
 904 // ***************************************************************************
 905
 906 bool CIXml::xmlSetAttribInternal (const std::string &attribName)
 907 {
 908         nlassert( isReading() );
 909
 910         if (_BinaryStream)
 911         {
 912                 return true;
 913         }
 914         else
 915         {
 916                 // Check _Parser
 917                 if ( _Parser )
 918                 {
 919                         // Can make a xmlPushEnd ?
 920                         if ( _PushBegin )
 921                         {
 922                                 // Set attribute name
 923                                 _AttribName = attribName;
 924
 925                                 // Attribute name is present
 926                                 _AttribPresent = true;
 927                         }
 928                         else
 929                         {
 930                                 nlerror ( "You must call xmlSetAttrib between xmlPushBegin and xmlPushEnd calls.");
 931                                 return false;
 932                         }
 933                 }
 934                 else
 935                 {
 936                         nlerror ( "Output stream has not been initialized.");
 937                         return false;
 938                 }
 939
 940                 // Ok
 941                 return true;
 942         }
 943 }
 944
 945 // ***************************************************************************
 946
 947 bool CIXml::xmlBreakLineInternal ()
 948 {
 949         // Ok
 950         return true;
 951 }
 952
 953 // ***************************************************************************
 954
 955 bool CIXml::xmlCommentInternal (const std::string &/* comment */)
 956 {
 957         // Ok
 958         return true;
 959 }
 960
 961 // ***************************************************************************
 962
 963 xmlNodePtr CIXml::getFirstChildNode (xmlNodePtr parent, const std::string &childName)
 964 {
 965         xmlNodePtr child = parent->children;
 966         while (child)
 967         {
 968                 if (childName == (const char*)child->name)
 969                         return child;
 970                 child = child->next;
 971         }
 972         return NULL;
 973 }
 974
 975 // ***************************************************************************
 976
 977 xmlNodePtr CIXml::getNextChildNode (xmlNodePtr last, const std::string &childName)
 978 {
 979         last = last->next;
 980         while (last)
 981         {
 982                 if (childName == (const char*)last->name)
 983                         return last;
 984                 last = last->next;
 985         }
 986         return NULL;
 987 }
 988
 989 // ***************************************************************************
 990
 991 xmlNodePtr CIXml::getFirstChildNode (xmlNodePtr parent, sint /* xmlElementType */ type)
 992 {
 993         xmlNodePtr child = parent->children;
 994         while (child)
 995         {
 996                 if (child->type == (xmlElementType)type)
 997                         return child;
 998                 child = child->next;
 999         }
1000         return NULL;
1001 }
1002
1003 // ***************************************************************************
1004
1005 xmlNodePtr CIXml::getNextChildNode (xmlNodePtr last, sint /* xmlElementType */ type)
1006 {
1007         last = last->next;
1008         while (last)
1009         {
1010                 if (last->type == (xmlElementType)type)
1011                         return last;
1012                 last = last->next;
1013         }
1014         return NULL;
1015 }
1016
1017 // ***************************************************************************
1018
1019 uint CIXml::countChildren (xmlNodePtr node, const std::string &childName)
1020 {
1021         uint count=0;
1022         xmlNodePtr child = getFirstChildNode (node, childName);
1023         while (child)
1024         {
1025                 count++;
1026                 child = getNextChildNode (child, childName);
1027         }
1028         return count;
1029 }
1030
1031 // ***************************************************************************
1032
1033 uint CIXml::countChildren (xmlNodePtr node, sint /* xmlElementType */ type)
1034 {
1035         uint count=0;
1036         xmlNodePtr child = getFirstChildNode (node, type);
1037         while (child)
1038         {
1039                 count++;
1040                 child = getNextChildNode (child, type);
1041         }
1042         return count;
1043 }
1044
1045 // ***************************************************************************
1046
1047 xmlNodePtr CIXml::getRootNode () const
1048 {
1049         if (_Parser)
1050                 if (_Parser->myDoc)
1051                         return xmlDocGetRootElement (_Parser->myDoc);
1052         return NULL;
1053 }
1054
1055 // ***************************************************************************
1056
1057 bool CIXml::getPropertyString (std::string &result, xmlNodePtr node, const std::string &property)
1058 {
1059         // Get the value
1060         const char *value = (const char*)xmlGetProp (node, (xmlChar*)property.c_str());
1061         if (value)
1062         {
1063                 // Active value
1064                 result = value;
1065
1066                 // Delete the value
1067                 xmlFree ((void*)value);
1068
1069                 // Found
1070                 return true;
1071         }
1072
1073         return false;
1074 }
1075
1076 // ***************************************************************************
1077
1078 int CIXml::getIntProperty(xmlNodePtr node, const std::string &property, int defaultValue)
1079 {
1080         std::string s;
1081
1082         bool b = getPropertyString(s, node, property);
1083
1084         if (!b)
1085                 return defaultValue;
1086
1087         // remove leading and trailing spaces
1088         s = trim(s);
1089
1090         sint val;
1091
1092         if (!fromString(s, val) || (val == 0 && s != "0"))
1093         {
1094                 nlwarning("Bad integer value: %s",s.c_str());
1095                 return defaultValue;
1096         }
1097
1098         return val;
1099 }
1100
1101 // ***************************************************************************
1102
1103 double CIXml::getFloatProperty(xmlNodePtr node, const std::string &property, float defaultValue)
1104 {
1105         std::string s;
1106
1107         bool b = getPropertyString(s, node, property);
1108
1109         if (!b)
1110                 return defaultValue;
1111
1112         // remove leading and trailing spaces
1113         s = trim(s);
1114
1115         float val;
1116
1117         if (!fromString(s, val))
1118         {
1119                 nlwarning("Bad float value: %s", s.c_str());
1120                 return defaultValue;
1121         }
1122
1123         return val;
1124 }
1125
1126 // ***************************************************************************
1127
1128 std::string CIXml::getStringProperty(xmlNodePtr node, const std::string &property, const std::string& defaultValue)
1129 {
1130         std::string s;
1131
1132         bool b = getPropertyString(s, node, property);
1133
1134         if (!b)
1135                 return defaultValue;
1136
1137         return s;
1138 }
1139
1140 // ***************************************************************************
1141
1142 bool CIXml::getContentString (std::string &result, xmlNodePtr node)
1143 {
1144         const char *valueText = (const char*)xmlNodeGetContent (node);
1145         if (valueText)
1146         {
1147                 result = valueText;
1148
1149                 // Delete the value
1150                 xmlFree ((void*)valueText);
1151
1152                 // Found
1153                 return true;
1154         }
1155         return false;
1156 }
1157
1158 // ***************************************************************************
1159
1160 void CIXml::initLibXml()
1161 {
1162         if (_LibXmlIntialized) return;
1163
1164         _ErrorString.clear();
1165
1166         // Set error handler
1167         xmlSetGenericErrorFunc  (NULL, xmlGenericErrorFuncRead);
1168
1169         LIBXML_TEST_VERSION
1170
1171         // an error occured during initialization
1172         if (!_ErrorString.empty())
1173         {
1174                 throw EXmlParsingError (_ErrorString);
1175         }
1176
1177         // Ask to get debug info
1178         xmlLineNumbersDefault(1);
1179
1180         _LibXmlIntialized = true;
1181 }
1182
1183 // ***************************************************************************
1184
1185 void CIXml::releaseLibXml()
1186 {
1187         if (!_LibXmlIntialized) return;
1188
1189         xmlCleanupParser();
1190
1191         _LibXmlIntialized = false;
1192 }
1193
1194 std::string CIXml::getErrorString()
1195 {
1196         return _ErrorString;
1197 }
1198
1199 } // NLMISC
1200
1201 #endif // NL_DONT_USE_EXTERNAL_CODE