nel/src/misc/o_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) 2016  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/o_xml.h"
  23 #include "nel/misc/i_xml.h"
  24
  25 #ifndef NL_DONT_USE_EXTERNAL_CODE
  26
  27 // Include from libxml2
  28 #include <libxml/xmlerror.h>
  29
  30 #if defined(NL_OS_WINDOWS) && defined(NL_COMP_VC_VERSION) && NL_COMP_VC_VERSION >= 80
  31 #define USE_LOCALE_SPRINTF
  32 #include <locale.h>
  33 #endif
  34
  35 using namespace std;
  36
  37 #ifdef DEBUG_NEW
  38         #define new DEBUG_NEW
  39 #endif
  40
  41 namespace NLMISC
  42 {
  43
  44 // ***************************************************************************
  45
  46 const char SEPARATOR = ' ';
  47
  48 // ***************************************************************************
  49
  50 #define writenumber(src,format,digits) \
  51         char number_as_cstring [digits+1]; \
  52         sprintf( number_as_cstring, format, src ); \
  53         serialSeparatedBufferOut( number_as_cstring );
  54
  55 // ***************************************************************************
  56 // XML callbacks
  57 // ***************************************************************************
  58
  59 int xmlOutputWriteCallbackForNeL ( void *context, const char *buffer, int len)
  60 {
  61         // no need to save empty buffer
  62         if(len == 0) return 0;
  63
  64         // Get the object
  65         COXml *object = (COXml*) context;
  66
  67         // Serialise the buffer
  68         object->_InternalStream->serialBuffer ((uint8*)buffer, len);
  69
  70         // Return the value
  71         return len;
  72 }
  73
  74 // ***************************************************************************
  75
  76 int xmlOutputCloseCallbackForNeL ( void * /* context */ )
  77 {
  78         // Get the object
  79         // COXml *object = (COXml*) context;
  80
  81         // Does nothing
  82         return 1;
  83 }
  84
  85 // ***************************************************************************
  86
  87 xmlDocPtr COXml::getDocument ()
  88 {
  89         if (_Document)
  90                 return _Document;
  91
  92         // Initialise the document
  93         _Document = xmlNewDoc ((const xmlChar *)_Version.c_str());
  94
  95         return _Document;
  96 }
  97
  98
  99 // ***************************************************************************
 100
 101 inline void COXml::flushContentString ()
 102 {
 103         // Current node must exist here
 104         nlassert (_CurrentNode);
 105
 106         // String size
 107         uint size=(uint)_ContentString.length();
 108
 109         // Some content to write ?
 110         if (size)
 111         {
 112                 // Write it in the current node
 113                 xmlNodePtr textNode = xmlNewText ((const xmlChar *)_ContentString.c_str());
 114                 xmlAddChild (_CurrentNode, textNode);
 115
 116                 // Empty the string
 117                 _ContentString.erase ();
 118         }
 119 }
 120
 121 // ***************************************************************************
 122
 123 COXml::COXml () : IStream (false /* Output mode */)
 124 {
 125         // Set XML mode
 126         setXMLMode (true);
 127
 128         // Set the stream
 129         _InternalStream = NULL;
 130
 131         // Set the version
 132         _Version = "1.0";
 133
 134         // Initialise the document
 135         _Document = NULL;
 136
 137         // Current node
 138         _CurrentNode = NULL;
 139
 140         // Content string
 141         _ContentString.clear();
 142
 143         // Push begin
 144         _PushBegin = false;
 145 }
 146
 147 // ***************************************************************************
 148
 149 bool COXml::init (IStream *stream, const std::string &version)
 150 {
 151         resetPtrTable();
 152
 153         CIXml::initLibXml();
 154
 155         // Output stream ?
 156         if (!stream->isReading())
 157         {
 158                 // Set XML mode
 159                 setXMLMode (true);
 160
 161                 // Set the stream
 162                 _InternalStream = stream;
 163
 164                 // Set the version
 165                 _Version = version;
 166
 167                 // Initialise the document
 168                 _Document = NULL;
 169
 170                 // Current node
 171                 _CurrentNode = NULL;
 172
 173                 // Content string
 174                 _ContentString.clear();
 175
 176                 // Push begin
 177                 _PushBegin = false;
 178
 179                 // Ok
 180                 return true;
 181         }
 182         else
 183                 return false;
 184 }
 185
 186 // ***************************************************************************
 187
 188 COXml::~COXml ()
 189 {
 190         // Flush document to the internal stream
 191         flush ();
 192 }
 193
 194 // ***************************************************************************
 195
 196 void COXml::serialSeparatedBufferOut( const std::string &value )
 197 {
 198         nlassert( ! isReading() );
 199
 200         // Output stream has been setuped ?
 201         if ( _InternalStream )
 202         {
 203                 // Current node presents ?
 204                 if (_CurrentNode)
 205                 {
 206                         // Write a push attribute ?
 207                         if (_PushBegin)
 208                         {
 209                                 // Current attrib is set ?
 210                                 if (_AttribPresent)
 211                                 {
 212                                         // Set the attribute
 213                                         xmlSetProp (_CurrentNode, (const xmlChar*)_AttribName.c_str(), (const xmlChar*)value.c_str());
 214
 215                                         // The attribute has been used
 216                                         _AttribPresent = false;
 217                                 }
 218                                 else
 219                                 {
 220                                         // * Error, the stream don't use XML streaming properly
 221                                         // * You must take care of this in your last serial call:
 222                                         // * - Between xmlPushBegin() and xmlPushEnd(), before each serial, you must set the attribute name with xmlSetAttrib.
 223                                         // * - Between xmlPushBegin() and xmlPushEnd(), you must serial only basic objects (numbers and strings).
 224                                         nlerror ( "Error, the stream don't use XML streaming properly" );
 225                                 }
 226                         }
 227                         else
 228                         {
 229                                 // Get the content buffer size
 230                                 uint size=(uint)_ContentString.length();
 231
 232                                 // Add a separator
 233                                 if ((size) && (_ContentString[size-1]!='\n'))
 234                                         _ContentString += SEPARATOR;
 235
 236                                 // Concat the strings
 237                                 _ContentString += value;
 238                         }
 239                 }
 240                 else
 241                 {
 242                         // * Error, no current node present.
 243                         // * Check that your serial is initialy made between a xmlPushBegin and xmlPushEnd calls.
 244                         nlerror ( "Error, the stream don't use XML streaming properly" );
 245                 }
 246         }
 247         else
 248         {
 249                 nlerror ( "Output stream has not been setuped" );
 250         }
 251 }
 252
 253 // ***************************************************************************
 254
 255 void COXml::serial(uint8 &b)
 256 {
 257         // Write the number
 258         writenumber( (uint16)b,"%hu", 3 );
 259 }
 260
 261 // ***************************************************************************
 262
 263 void COXml::serial(sint8 &b)
 264 {
 265         writenumber( (sint16)b, "%hd", 4 );
 266 }
 267
 268 // ***************************************************************************
 269
 270 void COXml::serial(uint16 &b)
 271 {
 272         writenumber( b, "%hu", 5 );
 273 }
 274
 275 // ***************************************************************************
 276
 277 void COXml::serial(sint16 &b)
 278 {
 279         writenumber( b, "%hd", 6 );
 280 }
 281
 282 // ***************************************************************************
 283
 284 void COXml::serial(uint32 &b)
 285 {
 286         writenumber( b, "%u", 10 );
 287 }
 288
 289 // ***************************************************************************
 290
 291 void COXml::serial(sint32 &b)
 292 {
 293         writenumber( b, "%d", 11 );
 294 }
 295
 296 // ***************************************************************************
 297
 298 void COXml::serial(uint64 &b)
 299 {
 300         writenumber( b, "%" NL_I64 "u", 20 );
 301 }
 302
 303 // ***************************************************************************
 304
 305 void COXml::serial(sint64 &b)
 306 {
 307         writenumber( b, "%" NL_I64 "d", 20 );
 308 }
 309
 310 // ***************************************************************************
 311
 312 void COXml::serial(float &b)
 313 {
 314         writenumber( (double)b, "%f", 128 );
 315 }
 316
 317 // ***************************************************************************
 318
 319 void COXml::serial(double &b)
 320 {
 321         writenumber( b, "%f", 128 );
 322 }
 323
 324 // ***************************************************************************
 325
 326 void COXml::serial(bool &b)
 327 {
 328         serialBit(b);
 329 }
 330
 331 // ***************************************************************************
 332
 333 void COXml::serialBit(bool &bit)
 334 {
 335         uint8 u = (uint8)bit;
 336         serial( u );
 337 }
 338
 339 // ***************************************************************************
 340
 341 #ifndef NL_OS_CYGWIN
 342 void COXml::serial(char &b)
 343 {
 344         std::string tmp;
 345         tmp += b;
 346         serialSeparatedBufferOut( tmp );
 347 }
 348 #endif // NL_OS_CYGWIN
 349
 350 // ***************************************************************************
 351
 352 void COXml::serial(std::string &b)
 353 {
 354         nlassert( ! isReading() );
 355
 356         // Attibute ?
 357         if (_PushBegin)
 358         {
 359                 // Only serial the string
 360                 serialSeparatedBufferOut( b );
 361         }
 362         else
 363         {
 364                 // Open a string node
 365                 xmlPush ("S");
 366
 367                 // Serial the string
 368                 serialSeparatedBufferOut( b );
 369
 370                 // Close the node
 371                 xmlPop ();
 372         }
 373 }
 374
 375 // ***************************************************************************
 376
 377 void COXml::serial(ucstring &b)
 378 {
 379         nlassert( ! isReading() );
 380
 381         // convert ucstring to utf-8 std::string
 382         std::string output = b.toUtf8();
 383
 384         // Serial this string
 385         serial (output);
 386 }
 387
 388 // ***************************************************************************
 389
 390 void COXml::serialBuffer(uint8 *buf, uint len)
 391 {
 392         // Open a node
 393         xmlPush ("BUFFER");
 394
 395         // Serialize the buffer
 396         for (uint i=0; i<len; i++)
 397         {
 398                 xmlPush ("ELM");
 399
 400                 serial (buf[i]);
 401
 402                 xmlPop ();
 403         }
 404
 405         // Close the node
 406         xmlPop ();
 407 }
 408
 409 // ***************************************************************************
 410
 411 bool COXml::xmlPushBeginInternal (const std::string &nodeName)
 412 {
 413         nlassert( ! isReading() );
 414
 415         // Check _InternalStream
 416         if ( _InternalStream )
 417         {
 418                 // Can make a xmlPushBegin ?
 419                 if ( ! _PushBegin )
 420                 {
 421                         // Current node exist ?
 422                         if (_CurrentNode==NULL)
 423                         {
 424                                 // No document ?
 425                                 if (_Document == NULL)
 426                                 {
 427                                         // Initialise the document
 428                                         _Document = xmlNewDoc ((const xmlChar *)_Version.c_str());
 429
 430                                         // Return NULL if error
 431                                         nlassert (_Document);
 432                                 }
 433
 434                                 // Create the first node
 435                                 _CurrentNode=xmlNewDocNode (_Document, NULL, (const xmlChar*)nodeName.c_str(), NULL);
 436                                 xmlDocSetRootElement (_Document, _CurrentNode);
 437
 438                                 // Return NULL if error
 439                                 nlassert (_CurrentNode);
 440                         }
 441                         else
 442                         {
 443                                 // Flush current content string ?
 444                                 flushContentString ();
 445
 446                                 // Create a new node
 447                                 _CurrentNode=xmlNewChild (_CurrentNode, NULL, (const xmlChar*)nodeName.c_str(), NULL);
 448
 449                                 // Return NULL if error
 450                                 nlassert (_CurrentNode);
 451                         }
 452
 453                         // Push begun
 454                         _PushBegin = true;
 455                 }
 456                 else
 457                 {
 458                         nlwarning ( "XML: You must close your xmlPushBegin - xmlPushEnd before calling a new xmlPushBegin.");
 459                         return false;
 460                 }
 461         }
 462         else
 463         {
 464                 nlwarning ( "XML: Output stream has not been setuped.");
 465                 return false;
 466         }
 467
 468         // Ok
 469         return true;
 470 }
 471
 472 // ***************************************************************************
 473
 474 bool COXml::xmlPushEndInternal ()
 475 {
 476         nlassert( ! isReading() );
 477
 478         // Check _InternalStream
 479         if ( _InternalStream )
 480         {
 481                 // Can make a xmlPushEnd ?
 482                 if ( _PushBegin )
 483                 {
 484                         // Push begun
 485                         _PushBegin = false;
 486                 }
 487                 else
 488                 {
 489                         nlwarning ( "XML: You must call xmlPushBegin before calling xmlPushEnd.");
 490                         return false;
 491                 }
 492         }
 493         else
 494         {
 495                 nlwarning ( "XML: Output stream has not been setuped.");
 496                 return false;
 497         }
 498
 499         // Ok
 500         return true;
 501 }
 502
 503 // ***************************************************************************
 504
 505 bool COXml::xmlPopInternal ()
 506 {
 507         nlassert( ! isReading() );
 508
 509         // Check _InternalStream
 510         if ( _InternalStream )
 511         {
 512                 // Not in the push mode ?
 513                 if ( ! _PushBegin )
 514                 {
 515                         // Some content to write ?
 516                         flushContentString ();
 517
 518                         // Get parent
 519                         _CurrentNode=_CurrentNode->parent;
 520                 }
 521                 else
 522                 {
 523                         nlwarning ( "XML: You must call xmlPop after xmlPushEnd.");
 524                         return false;
 525                 }
 526         }
 527         else
 528         {
 529                 nlwarning ( "XML: Output stream has not been setuped.");
 530                 return false;
 531         }
 532
 533         // Ok
 534         return true;
 535 }
 536
 537 // ***************************************************************************
 538
 539 bool COXml::xmlSetAttribInternal (const std::string &attribName)
 540 {
 541         nlassert( ! isReading() );
 542
 543         // Check _InternalStream
 544         if ( _InternalStream )
 545         {
 546                 // Can make a xmlPushEnd ?
 547                 if ( _PushBegin )
 548                 {
 549                         // Set attribute name
 550                         _AttribName = attribName;
 551
 552                         // Attribute name is present
 553                         _AttribPresent = true;
 554                 }
 555                 else
 556                 {
 557                         nlwarning ( "XML: You must call xmlSetAttrib between xmlPushBegin and xmlPushEnd calls.");
 558                         return false;
 559                 }
 560         }
 561         else
 562         {
 563                 nlwarning ( "XML: Output stream has not been setuped.");
 564                 return false;
 565         }
 566
 567         // Ok
 568         return true;
 569 }
 570
 571 // ***************************************************************************
 572
 573 bool COXml::xmlBreakLineInternal ()
 574 {
 575         nlassert( ! isReading() );
 576
 577         // Check _InternalStream
 578         if ( _InternalStream )
 579         {
 580                 // Not in the push mode ?
 581                 if ( ! _PushBegin )
 582                 {
 583                         // Add a break line
 584                         _ContentString += '\n';
 585                 }
 586                 else
 587                 {
 588                         nlwarning ( "XML: You must call xmlNBreakLine after xmlPushEnd.");
 589                         return false;
 590                 }
 591         }
 592         else
 593         {
 594                 nlwarning ( "XML: Output stream has not been setuped.");
 595                 return false;
 596         }
 597
 598         // Ok
 599         return true;
 600 }
 601
 602 // ***************************************************************************
 603
 604 bool COXml::xmlCommentInternal (const std::string &comment)
 605 {
 606         nlassert( ! isReading() );
 607
 608         // Check _InternalStream
 609         if ( _InternalStream )
 610         {
 611                 // Not in the push mode ?
 612                 if ( _CurrentNode != NULL)
 613                 {
 614                         // Add a comment node
 615                         xmlNodePtr commentPtr = xmlNewComment ((const xmlChar *)comment.c_str());
 616
 617                         // Add the node
 618                         xmlAddChild (_CurrentNode, commentPtr);
 619                 }
 620                 else
 621                 {
 622                         nlwarning ( "XML: You must call xmlCommentInternal between xmlPushBegin and xmlPushEnd.");
 623                         return false;
 624                 }
 625         }
 626         else
 627         {
 628                 nlwarning ( "XML: Output stream has not been setuped.");
 629                 return false;
 630         }
 631         // Ok
 632         return true;
 633 }
 634
 635 // ***************************************************************************
 636
 637 void COXml::flush ()
 638 {
 639         if (_Document)
 640         {
 641                 // Generate indentation
 642                 xmlKeepBlanksDefault (0);
 643
 644                 // Create a output context
 645                 xmlOutputBufferPtr outputBuffer = xmlOutputBufferCreateIO  ( xmlOutputWriteCallbackForNeL, xmlOutputCloseCallbackForNeL, this, NULL );
 646
 647                 // Save the file
 648                 int res = xmlSaveFormatFileTo (outputBuffer, _Document, NULL, 1);
 649
 650                 // No error should be returned because, exception should be raised by the internal stream
 651                 nlassert (res!=-1);
 652
 653                 // Free the document
 654                 xmlFreeDoc (_Document);
 655                 _Document = NULL;
 656         }
 657 }
 658
 659 // ***************************************************************************
 660
 661 bool COXml::isStringValidForProperties (const std::string &str)
 662 {
 663         return str.find('\n') == std::string::npos;
 664 }
 665
 666 // ***************************************************************************
 667
 668 std::string COXml::getErrorString()
 669 {
 670         // error string is managed by CIXml
 671         return CIXml::getErrorString();
 672 }
 673
 674 } // NLMISC
 675
 676 #endif // NL_DONT_USE_EXTERNAL_CODE