src/xml/xml.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        xml.cpp
   3 // Purpose:     wxXmlDocument - XML parser & data holder class
   4 // Author:      Vaclav Slavik
   5 // Created:     2000/03/05
   6 // RCS-ID:      $Id$
   7 // Copyright:   (c) 2000 Vaclav Slavik
   8 // Licence:     wxWindows licence
   9 /////////////////////////////////////////////////////////////////////////////
  10
  11 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  12 #pragma implementation "xml.h"
  13 #endif
  14
  15 // For compilers that support precompilation, includes "wx.h".
  16 #include "wx/wxprec.h"
  17
  18 #ifdef __BORLANDC__
  19     #pragma hdrstop
  20 #endif
  21
  22 #include "wx/xml/xml.h"
  23
  24 #if wxUSE_XML
  25
  26 #include "wx/wfstream.h"
  27 #include "wx/datstrm.h"
  28 #include "wx/zstream.h"
  29 #include "wx/log.h"
  30 #include "wx/intl.h"
  31 #include "wx/strconv.h"
  32
  33 #include "expat.h" // from Expat
  34
  35 // DLL options compatibility check:
  36 #include "wx/app.h"
  37 WX_CHECK_BUILD_OPTIONS("wxXML")
  38
  39 //-----------------------------------------------------------------------------
  40 //  wxXmlNode
  41 //-----------------------------------------------------------------------------
  42
  43 wxXmlNode::wxXmlNode(wxXmlNode *parent,wxXmlNodeType type,
  44                      const wxString& name, const wxString& content,
  45                      wxXmlProperty *props, wxXmlNode *next)
  46     : m_type(type), m_name(name), m_content(content),
  47       m_properties(props), m_parent(parent),
  48       m_children(NULL), m_next(next)
  49 {
  50     if (m_parent)
  51     {
  52         if (m_parent->m_children)
  53         {
  54             m_next = m_parent->m_children;
  55             m_parent->m_children = this;
  56         }
  57         else
  58             m_parent->m_children = this;
  59     }
  60 }
  61
  62 wxXmlNode::wxXmlNode(wxXmlNodeType type, const wxString& name,
  63                      const wxString& content)
  64     : m_type(type), m_name(name), m_content(content),
  65       m_properties(NULL), m_parent(NULL),
  66       m_children(NULL), m_next(NULL)
  67 {}
  68
  69 wxXmlNode::wxXmlNode(const wxXmlNode& node)
  70 {
  71     m_next = NULL;
  72     m_parent = NULL;
  73     DoCopy(node);
  74 }
  75
  76 wxXmlNode::~wxXmlNode()
  77 {
  78     wxXmlNode *c, *c2;
  79     for (c = m_children; c; c = c2)
  80     {
  81         c2 = c->m_next;
  82         delete c;
  83     }
  84
  85     wxXmlProperty *p, *p2;
  86     for (p = m_properties; p; p = p2)
  87     {
  88         p2 = p->GetNext();
  89         delete p;
  90     }
  91 }
  92
  93 wxXmlNode& wxXmlNode::operator=(const wxXmlNode& node)
  94 {
  95     wxDELETE(m_properties);
  96     wxDELETE(m_children);
  97     DoCopy(node);
  98     return *this;
  99 }
 100
 101 void wxXmlNode::DoCopy(const wxXmlNode& node)
 102 {
 103     m_type = node.m_type;
 104     m_name = node.m_name;
 105     m_content = node.m_content;
 106     m_children = NULL;
 107
 108     wxXmlNode *n = node.m_children;
 109     while (n)
 110     {
 111         AddChild(new wxXmlNode(*n));
 112         n = n->GetNext();
 113     }
 114
 115     m_properties = NULL;
 116     wxXmlProperty *p = node.m_properties;
 117     while (p)
 118     {
 119        AddProperty(p->GetName(), p->GetValue());
 120        p = p->GetNext();
 121     }
 122 }
 123
 124 bool wxXmlNode::HasProp(const wxString& propName) const
 125 {
 126     wxXmlProperty *prop = GetProperties();
 127
 128     while (prop)
 129     {
 130         if (prop->GetName() == propName) return TRUE;
 131         prop = prop->GetNext();
 132     }
 133
 134     return FALSE;
 135 }
 136
 137 bool wxXmlNode::GetPropVal(const wxString& propName, wxString *value) const
 138 {
 139     wxXmlProperty *prop = GetProperties();
 140
 141     while (prop)
 142     {
 143         if (prop->GetName() == propName)
 144         {
 145             *value = prop->GetValue();
 146             return TRUE;
 147         }
 148         prop = prop->GetNext();
 149     }
 150
 151     return FALSE;
 152 }
 153
 154 wxString wxXmlNode::GetPropVal(const wxString& propName, const wxString& defaultVal) const
 155 {
 156     wxString tmp;
 157     if (GetPropVal(propName, &tmp))
 158         return tmp;
 159
 160     return defaultVal;
 161 }
 162
 163 void wxXmlNode::AddChild(wxXmlNode *child)
 164 {
 165     if (m_children == NULL)
 166         m_children = child;
 167     else
 168     {
 169         wxXmlNode *ch = m_children;
 170         while (ch->m_next) ch = ch->m_next;
 171         ch->m_next = child;
 172     }
 173     child->m_next = NULL;
 174     child->m_parent = this;
 175 }
 176
 177 void wxXmlNode::InsertChild(wxXmlNode *child, wxXmlNode *before_node)
 178 {
 179     wxASSERT_MSG(before_node->GetParent() == this, wxT("wxXmlNode::InsertChild - the node has incorrect parent"));
 180
 181     if (m_children == before_node)
 182        m_children = child;
 183     else
 184     {
 185         wxXmlNode *ch = m_children;
 186         while (ch->m_next != before_node) ch = ch->m_next;
 187         ch->m_next = child;
 188     }
 189
 190     child->m_parent = this;
 191     child->m_next = before_node;
 192 }
 193
 194 bool wxXmlNode::RemoveChild(wxXmlNode *child)
 195 {
 196     if (m_children == NULL)
 197         return FALSE;
 198     else if (m_children == child)
 199     {
 200         m_children = child->m_next;
 201         child->m_parent = NULL;
 202         child->m_next = NULL;
 203         return TRUE;
 204     }
 205     else
 206     {
 207         wxXmlNode *ch = m_children;
 208         while (ch->m_next)
 209         {
 210             if (ch->m_next == child)
 211             {
 212                 ch->m_next = child->m_next;
 213                 child->m_parent = NULL;
 214                 child->m_next = NULL;
 215                 return TRUE;
 216             }
 217             ch = ch->m_next;
 218         }
 219         return FALSE;
 220     }
 221 }
 222
 223 void wxXmlNode::AddProperty(const wxString& name, const wxString& value)
 224 {
 225     AddProperty(new wxXmlProperty(name, value, NULL));
 226 }
 227
 228 void wxXmlNode::AddProperty(wxXmlProperty *prop)
 229 {
 230     if (m_properties == NULL)
 231         m_properties = prop;
 232     else
 233     {
 234         wxXmlProperty *p = m_properties;
 235         while (p->GetNext()) p = p->GetNext();
 236         p->SetNext(prop);
 237     }
 238 }
 239
 240 bool wxXmlNode::DeleteProperty(const wxString& name)
 241 {
 242     wxXmlProperty *prop;
 243
 244     if (m_properties == NULL)
 245         return FALSE;
 246
 247     else if (m_properties->GetName() == name)
 248     {
 249         prop = m_properties;
 250         m_properties = prop->GetNext();
 251         prop->SetNext(NULL);
 252         delete prop;
 253         return TRUE;
 254     }
 255
 256     else
 257     {
 258         wxXmlProperty *p = m_properties;
 259         while (p->GetNext())
 260         {
 261             if (p->GetNext()->GetName() == name)
 262             {
 263                 prop = p->GetNext();
 264                 p->SetNext(prop->GetNext());
 265                 prop->SetNext(NULL);
 266                 delete prop;
 267                 return TRUE;
 268             }
 269             p = p->GetNext();
 270         }
 271         return FALSE;
 272     }
 273 }
 274
 275
 276
 277 //-----------------------------------------------------------------------------
 278 //  wxXmlDocument
 279 //-----------------------------------------------------------------------------
 280
 281 wxXmlDocument::wxXmlDocument()
 282     : m_version(wxT("1.0")), m_fileEncoding(wxT("utf-8")), m_root(NULL)
 283 {
 284 #if !wxUSE_UNICODE
 285     m_encoding = wxT("UTF-8");
 286 #endif
 287 }
 288
 289 wxXmlDocument::wxXmlDocument(const wxString& filename, const wxString& encoding)
 290                           : wxObject(), m_root(NULL)
 291 {
 292     if ( !Load(filename, encoding) )
 293     {
 294         wxDELETE(m_root);
 295     }
 296 }
 297
 298 wxXmlDocument::wxXmlDocument(wxInputStream& stream, const wxString& encoding)
 299                           : wxObject(), m_root(NULL)
 300 {
 301     if ( !Load(stream, encoding) )
 302     {
 303         wxDELETE(m_root);
 304     }
 305 }
 306
 307 wxXmlDocument::wxXmlDocument(const wxXmlDocument& doc)
 308 {
 309     DoCopy(doc);
 310 }
 311
 312 wxXmlDocument& wxXmlDocument::operator=(const wxXmlDocument& doc)
 313 {
 314     wxDELETE(m_root);
 315     DoCopy(doc);
 316     return *this;
 317 }
 318
 319 void wxXmlDocument::DoCopy(const wxXmlDocument& doc)
 320 {
 321     m_version = doc.m_version;
 322 #if !wxUSE_UNICODE
 323     m_encoding = doc.m_encoding;
 324 #endif
 325     m_fileEncoding = doc.m_fileEncoding;
 326     m_root = new wxXmlNode(*doc.m_root);
 327 }
 328
 329 bool wxXmlDocument::Load(const wxString& filename, const wxString& encoding)
 330 {
 331     wxFileInputStream stream(filename);
 332     return Load(stream, encoding);
 333 }
 334
 335 bool wxXmlDocument::Save(const wxString& filename) const
 336 {
 337     wxFileOutputStream stream(filename);
 338     return Save(stream);
 339 }
 340
 341
 342
 343 //-----------------------------------------------------------------------------
 344 //  wxXmlDocument loading routines
 345 //-----------------------------------------------------------------------------
 346
 347 /*
 348     FIXME:
 349        - process all elements, including CDATA
 350  */
 351
 352 // converts Expat-produced string in UTF-8 into wxString.
 353 inline static wxString CharToString(wxMBConv *conv,
 354                                     const char *s, size_t len = wxSTRING_MAXLEN)
 355 {
 356 #if wxUSE_UNICODE
 357     (void)conv;
 358     return wxString(s, wxConvUTF8, len);
 359 #else
 360     if ( conv )
 361     {
 362         size_t nLen = (len != wxSTRING_MAXLEN) ? len :
 363                           wxConvUTF8.MB2WC((wchar_t*) NULL, s, 0);
 364
 365         wchar_t *buf = new wchar_t[nLen+1];
 366         wxConvUTF8.MB2WC(buf, s, nLen);
 367         buf[nLen] = 0;
 368         wxString str(buf, *conv, len);
 369         delete[] buf;
 370         return str;
 371     }
 372     else
 373         return wxString(s, len != wxSTRING_MAXLEN ? len : strlen(s));
 374 #endif
 375 }
 376
 377 struct wxXmlParsingContext
 378 {
 379     wxMBConv  *conv;
 380     wxXmlNode *root;
 381     wxXmlNode *node;
 382     wxXmlNode *lastAsText;
 383     wxString   encoding;
 384     wxString   version;
 385 };
 386
 387 static void StartElementHnd(void *userData, const char *name, const char **atts)
 388 {
 389     wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;
 390     wxXmlNode *node = new wxXmlNode(wxXML_ELEMENT_NODE, CharToString(ctx->conv, name));
 391     const char **a = atts;
 392     while (*a)
 393     {
 394         node->AddProperty(CharToString(ctx->conv, a[0]), CharToString(ctx->conv, a[1]));
 395         a += 2;
 396     }
 397     if (ctx->root == NULL)
 398         ctx->root = node;
 399     else
 400         ctx->node->AddChild(node);
 401     ctx->node = node;
 402     ctx->lastAsText = NULL;
 403 }
 404
 405 static void EndElementHnd(void *userData, const char* WXUNUSED(name))
 406 {
 407     wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;
 408
 409     ctx->node = ctx->node->GetParent();
 410     ctx->lastAsText = NULL;
 411 }
 412
 413 static void TextHnd(void *userData, const char *s, int len)
 414 {
 415     wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;
 416     char *buf = new char[len + 1];
 417
 418     buf[len] = '\0';
 419     memcpy(buf, s, (size_t)len);
 420
 421     if (ctx->lastAsText)
 422     {
 423         ctx->lastAsText->SetContent(ctx->lastAsText->GetContent() +
 424                                     CharToString(ctx->conv, buf));
 425     }
 426     else
 427     {
 428         bool whiteOnly = TRUE;
 429         for (char *c = buf; *c != '\0'; c++)
 430             if (*c != ' ' && *c != '\t' && *c != '\n' && *c != '\r')
 431             {
 432                 whiteOnly = FALSE;
 433                 break;
 434             }
 435         if (!whiteOnly)
 436         {
 437             ctx->lastAsText = new wxXmlNode(wxXML_TEXT_NODE, wxT("text"),
 438                                             CharToString(ctx->conv, buf));
 439             ctx->node->AddChild(ctx->lastAsText);
 440         }
 441     }
 442
 443     delete[] buf;
 444 }
 445
 446 static void CommentHnd(void *userData, const char *data)
 447 {
 448     wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;
 449
 450     if (ctx->node)
 451     {
 452         // VS: ctx->node == NULL happens if there is a comment before
 453         //     the root element (e.g. wxDesigner's output). We ignore such
 454         //     comments, no big deal...
 455         ctx->node->AddChild(new wxXmlNode(wxXML_COMMENT_NODE,
 456                             wxT("comment"), CharToString(ctx->conv, data)));
 457     }
 458     ctx->lastAsText = NULL;
 459 }
 460
 461 static void DefaultHnd(void *userData, const char *s, int len)
 462 {
 463     // XML header:
 464     if (len > 6 && memcmp(s, "<?xml ", 6) == 0)
 465     {
 466         wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;
 467
 468         wxString buf = CharToString(ctx->conv, s, (size_t)len);
 469         int pos;
 470         pos = buf.Find(wxT("encoding="));
 471         if (pos != wxNOT_FOUND)
 472             ctx->encoding = buf.Mid(pos + 10).BeforeFirst(buf[(size_t)pos+9]);
 473         pos = buf.Find(wxT("version="));
 474         if (pos != wxNOT_FOUND)
 475             ctx->version = buf.Mid(pos + 9).BeforeFirst(buf[(size_t)pos+8]);
 476     }
 477 }
 478
 479 static int UnknownEncodingHnd(void * WXUNUSED(encodingHandlerData),
 480                               const XML_Char *name, XML_Encoding *info)
 481 {
 482     // We must build conversion table for expat. The easiest way to do so
 483     // is to let wxCSConv convert as string containing all characters to
 484     // wide character representation:
 485     wxString str(name, wxConvLibc);
 486     wxCSConv conv(str);
 487     char mbBuf[2];
 488     wchar_t wcBuf[10];
 489     size_t i;
 490
 491     mbBuf[1] = 0;
 492     info->map[0] = 0;
 493     for (i = 0; i < 255; i++)
 494     {
 495         mbBuf[0] = (char)(i+1);
 496         if (conv.MB2WC(wcBuf, mbBuf, 2) == (size_t)-1)
 497         {
 498             // invalid/undefined byte in the encoding:
 499             info->map[i+1] = -1;
 500         }
 501         info->map[i+1] = (int)wcBuf[0];
 502     }
 503
 504     info->data = NULL;
 505     info->convert = NULL;
 506     info->release = NULL;
 507
 508     return 1;
 509 }
 510
 511 bool wxXmlDocument::Load(wxInputStream& stream, const wxString& encoding)
 512 {
 513 #if wxUSE_UNICODE
 514     (void)encoding;
 515 #else
 516     m_encoding = encoding;
 517 #endif
 518
 519     const size_t BUFSIZE = 1024;
 520     char buf[BUFSIZE];
 521     wxXmlParsingContext ctx;
 522     bool done;
 523     XML_Parser parser = XML_ParserCreate(NULL);
 524
 525     ctx.root = ctx.node = NULL;
 526     ctx.encoding = wxT("UTF-8"); // default in absence of encoding=""
 527     ctx.conv = NULL;
 528 #if !wxUSE_UNICODE
 529     if ( encoding != wxT("UTF-8") && encoding != wxT("utf-8") )
 530         ctx.conv = new wxCSConv(encoding);
 531 #endif
 532
 533     XML_SetUserData(parser, (void*)&ctx);
 534     XML_SetElementHandler(parser, StartElementHnd, EndElementHnd);
 535     XML_SetCharacterDataHandler(parser, TextHnd);
 536     XML_SetCommentHandler(parser, CommentHnd);
 537     XML_SetDefaultHandler(parser, DefaultHnd);
 538     XML_SetUnknownEncodingHandler(parser, UnknownEncodingHnd, NULL);
 539
 540     bool ok = true;
 541     do
 542     {
 543         size_t len = stream.Read(buf, BUFSIZE).LastRead();
 544         done = (len < BUFSIZE);
 545         if (!XML_Parse(parser, buf, len, done))
 546         {
 547             wxString error(XML_ErrorString(XML_GetErrorCode(parser)),
 548                            *wxConvCurrent);
 549             wxLogError(_("XML parsing error: '%s' at line %d"),
 550                        error.c_str(),
 551                        XML_GetCurrentLineNumber(parser));
 552             ok = false;
 553             break;
 554         }
 555     } while (!done);
 556
 557     if (ok)
 558     {
 559         if (!ctx.version.IsEmpty())
 560             SetVersion(ctx.version);
 561         if (!ctx.encoding.IsEmpty())
 562             SetFileEncoding(ctx.encoding);
 563         SetRoot(ctx.root);
 564     }
 565     else
 566     {
 567         delete ctx.root;
 568     }
 569
 570     XML_ParserFree(parser);
 571 #if !wxUSE_UNICODE
 572     if ( ctx.conv )
 573         delete ctx.conv;
 574 #endif
 575
 576     return ok;
 577
 578 }
 579
 580
 581
 582 //-----------------------------------------------------------------------------
 583 //  wxXmlDocument saving routines
 584 //-----------------------------------------------------------------------------
 585
 586 // write string to output:
 587 inline static void OutputString(wxOutputStream& stream, const wxString& str,
 588 #if wxUSE_UNICODE
 589     wxMBConv * WXUNUSED(convMem),
 590 #else
 591     wxMBConv *convMem,
 592 #endif
 593     wxMBConv *convFile)
 594 {
 595     if (str.IsEmpty()) return;
 596 #if wxUSE_UNICODE
 597     const wxWX2MBbuf buf(str.mb_str(*(convFile ? convFile : &wxConvUTF8)));
 598     stream.Write((const char*)buf, strlen((const char*)buf));
 599 #else
 600     if ( convFile == NULL )
 601         stream.Write(str.mb_str(), str.Len());
 602     else
 603     {
 604         wxString str2(str.wc_str(*convMem), *convFile);
 605         stream.Write(str2.mb_str(), str2.Len());
 606     }
 607 #endif
 608 }
 609
 610 // Same as above, but create entities first.
 611 // Translates '<' to "&lt;", '>' to "&gt;" and '&' to "&amp;"
 612 static void OutputStringEnt(wxOutputStream& stream, const wxString& str,
 613                             wxMBConv *convMem, wxMBConv *convFile,
 614                             bool escapeQuotes = false)
 615 {
 616     wxString buf;
 617     size_t i, last, len;
 618     wxChar c;
 619
 620     len = str.Len();
 621     last = 0;
 622     for (i = 0; i < len; i++)
 623     {
 624         c = str.GetChar(i);
 625         if (c == wxT('<') || c == wxT('>') ||
 626             (c == wxT('&') && str.Mid(i+1, 4) != wxT("amp;")) ||
 627             (escapeQuotes && c == wxT('"')))
 628         {
 629             OutputString(stream, str.Mid(last, i - last), convMem, convFile);
 630             switch (c)
 631             {
 632                 case wxT('<'):
 633                     OutputString(stream, wxT("&lt;"), NULL, NULL);
 634                     break;
 635                 case wxT('>'):
 636                     OutputString(stream, wxT("&gt;"), NULL, NULL);
 637                     break;
 638                 case wxT('&'):
 639                     OutputString(stream, wxT("&amp;"), NULL, NULL);
 640                     break;
 641                 case wxT('"'):
 642                     OutputString(stream, wxT("&quot;"), NULL, NULL);
 643                     break;
 644                 default: break;
 645             }
 646             last = i + 1;
 647         }
 648     }
 649     OutputString(stream, str.Mid(last, i - last), convMem, convFile);
 650 }
 651
 652 inline static void OutputIndentation(wxOutputStream& stream, int indent)
 653 {
 654     wxString str = wxT("\n");
 655     for (int i = 0; i < indent; i++)
 656         str << wxT(' ') << wxT(' ');
 657     OutputString(stream, str, NULL, NULL);
 658 }
 659
 660 static void OutputNode(wxOutputStream& stream, wxXmlNode *node, int indent,
 661                        wxMBConv *convMem, wxMBConv *convFile)
 662 {
 663     wxXmlNode *n, *prev;
 664     wxXmlProperty *prop;
 665
 666     switch (node->GetType())
 667     {
 668         case wxXML_TEXT_NODE:
 669             OutputStringEnt(stream, node->GetContent(), convMem, convFile);
 670             break;
 671
 672         case wxXML_ELEMENT_NODE:
 673             OutputString(stream, wxT("<"), NULL, NULL);
 674             OutputString(stream, node->GetName(), NULL, NULL);
 675
 676             prop = node->GetProperties();
 677             while (prop)
 678             {
 679                 OutputString(stream, wxT(" ") + prop->GetName() +  wxT("=\""),
 680                              NULL, NULL);
 681                 OutputStringEnt(stream, prop->GetValue(), NULL, NULL,
 682                                 true/*escapeQuotes*/);
 683                 OutputString(stream, wxT("\""), NULL, NULL);
 684                 prop = prop->GetNext();
 685             }
 686
 687             if (node->GetChildren())
 688             {
 689                 OutputString(stream, wxT(">"), NULL, NULL);
 690                 prev = NULL;
 691                 n = node->GetChildren();
 692                 while (n)
 693                 {
 694                     if (n && n->GetType() != wxXML_TEXT_NODE)
 695                         OutputIndentation(stream, indent + 1);
 696                     OutputNode(stream, n, indent + 1, convMem, convFile);
 697                     prev = n;
 698                     n = n->GetNext();
 699                 }
 700                 if (prev && prev->GetType() != wxXML_TEXT_NODE)
 701                     OutputIndentation(stream, indent);
 702                 OutputString(stream, wxT("</"), NULL, NULL);
 703                 OutputString(stream, node->GetName(), NULL, NULL);
 704                 OutputString(stream, wxT(">"), NULL, NULL);
 705             }
 706             else
 707                 OutputString(stream, wxT("/>"), NULL, NULL);
 708             break;
 709
 710         case wxXML_COMMENT_NODE:
 711             OutputString(stream, wxT("<!--"), NULL, NULL);
 712             OutputString(stream, node->GetContent(), convMem, convFile);
 713             OutputString(stream, wxT("-->"), NULL, NULL);
 714             break;
 715
 716         default:
 717             wxFAIL_MSG(wxT("unsupported node type"));
 718     }
 719 }
 720
 721 bool wxXmlDocument::Save(wxOutputStream& stream) const
 722 {
 723     if ( !IsOk() )
 724         return FALSE;
 725
 726     wxString s;
 727
 728     wxMBConv *convMem = NULL, *convFile = NULL;
 729 #if wxUSE_UNICODE
 730     convFile = new wxCSConv(GetFileEncoding());
 731 #else
 732     if ( GetFileEncoding() != GetEncoding() )
 733     {
 734         convFile = new wxCSConv(GetFileEncoding());
 735         convMem = new wxCSConv(GetEncoding());
 736     }
 737 #endif
 738
 739     s.Printf(wxT("<?xml version=\"%s\" encoding=\"%s\"?>\n"),
 740              GetVersion().c_str(), GetFileEncoding().c_str());
 741     OutputString(stream, s, NULL, NULL);
 742
 743     OutputNode(stream, GetRoot(), 0, convMem, convFile);
 744     OutputString(stream, wxT("\n"), NULL, NULL);
 745
 746     if ( convFile )
 747         delete convFile;
 748     if ( convMem )
 749         delete convMem;
 750
 751     return TRUE;
 752 }
 753
 754 #endif // wxUSE_XML