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);
 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     wxCSConv conv(wxString(name, wxConvLibc));
 486     char mbBuf[2];
 487     wchar_t wcBuf[10];
 488     size_t i;
 489
 490     mbBuf[1] = 0;
 491     info->map[0] = 0;
 492     for (i = 0; i < 255; i++)
 493     {
 494         mbBuf[0] = (char)(i+1);
 495         if (conv.MB2WC(wcBuf, mbBuf, 2) == (size_t)-1)
 496         {
 497             // invalid/undefined byte in the encoding:
 498             info->map[i+1] = -1;
 499         }
 500         info->map[i+1] = (int)wcBuf[0];
 501     }
 502
 503     info->data = NULL;
 504     info->convert = NULL;
 505     info->release = NULL;
 506
 507     return 1;
 508 }
 509
 510 bool wxXmlDocument::Load(wxInputStream& stream, const wxString& encoding)
 511 {
 512 #if wxUSE_UNICODE
 513     (void)encoding;
 514 #else
 515     m_encoding = encoding;
 516 #endif
 517
 518     const size_t BUFSIZE = 1024;
 519     char buf[BUFSIZE];
 520     wxXmlParsingContext ctx;
 521     bool done;
 522     XML_Parser parser = XML_ParserCreate(NULL);
 523
 524     ctx.root = ctx.node = NULL;
 525     ctx.encoding = wxT("UTF-8"); // default in absence of encoding=""
 526     ctx.conv = NULL;
 527 #if !wxUSE_UNICODE
 528     if ( encoding != wxT("UTF-8") && encoding != wxT("utf-8") )
 529         ctx.conv = new wxCSConv(encoding);
 530 #endif
 531
 532     XML_SetUserData(parser, (void*)&ctx);
 533     XML_SetElementHandler(parser, StartElementHnd, EndElementHnd);
 534     XML_SetCharacterDataHandler(parser, TextHnd);
 535     XML_SetCommentHandler(parser, CommentHnd);
 536     XML_SetDefaultHandler(parser, DefaultHnd);
 537     XML_SetUnknownEncodingHandler(parser, UnknownEncodingHnd, NULL);
 538
 539     bool ok = true;
 540     do
 541     {
 542         size_t len = stream.Read(buf, BUFSIZE).LastRead();
 543         done = (len < BUFSIZE);
 544         if (!XML_Parse(parser, buf, len, done))
 545         {
 546             wxString error(XML_ErrorString(XML_GetErrorCode(parser)),
 547                            *wxConvCurrent);
 548             wxLogError(_("XML parsing error: '%s' at line %d"),
 549                        error.c_str(),
 550                        XML_GetCurrentLineNumber(parser));
 551             ok = false;
 552             break;
 553         }
 554     } while (!done);
 555
 556     if (ok)
 557     {
 558         if (!ctx.version.IsEmpty())
 559             SetVersion(ctx.version);
 560         if (!ctx.encoding.IsEmpty())
 561             SetFileEncoding(ctx.encoding);
 562         SetRoot(ctx.root);
 563     }
 564     else
 565     {
 566         delete ctx.root;
 567     }
 568
 569     XML_ParserFree(parser);
 570 #if !wxUSE_UNICODE
 571     if ( ctx.conv )
 572         delete ctx.conv;
 573 #endif
 574
 575     return ok;
 576
 577 }
 578
 579
 580
 581 //-----------------------------------------------------------------------------
 582 //  wxXmlDocument saving routines
 583 //-----------------------------------------------------------------------------
 584
 585 // write string to output:
 586 inline static void OutputString(wxOutputStream& stream, const wxString& str,
 587 #if wxUSE_UNICODE
 588     wxMBConv * WXUNUSED(convMem),
 589 #else
 590     wxMBConv *convMem,
 591 #endif
 592     wxMBConv *convFile)
 593 {
 594     if (str.IsEmpty()) return;
 595 #if wxUSE_UNICODE
 596     const wxWX2MBbuf buf(str.mb_str(*(convFile ? convFile : &wxConvUTF8)));
 597     stream.Write((const char*)buf, strlen((const char*)buf));
 598 #else
 599     if ( convFile == NULL )
 600         stream.Write(str.mb_str(), str.Len());
 601     else
 602     {
 603         wxString str2(str.wc_str(*convMem), *convFile);
 604         stream.Write(str2.mb_str(), str2.Len());
 605     }
 606 #endif
 607 }
 608
 609 // Same as above, but create entities first.
 610 // Translates '<' to "&lt;", '>' to "&gt;" and '&' to "&amp;"
 611 static void OutputStringEnt(wxOutputStream& stream, const wxString& str,
 612                             wxMBConv *convMem, wxMBConv *convFile,
 613                             bool escapeQuotes = false)
 614 {
 615     wxString buf;
 616     size_t i, last, len;
 617     wxChar c;
 618
 619     len = str.Len();
 620     last = 0;
 621     for (i = 0; i < len; i++)
 622     {
 623         c = str.GetChar(i);
 624         if (c == wxT('<') || c == wxT('>') ||
 625             (c == wxT('&') && str.Mid(i+1, 4) != wxT("amp;")) ||
 626             (escapeQuotes && c == wxT('"')))
 627         {
 628             OutputString(stream, str.Mid(last, i - last), convMem, convFile);
 629             switch (c)
 630             {
 631                 case wxT('<'):
 632                     OutputString(stream, wxT("&lt;"), NULL, NULL);
 633                     break;
 634                 case wxT('>'):
 635                     OutputString(stream, wxT("&gt;"), NULL, NULL);
 636                     break;
 637                 case wxT('&'):
 638                     OutputString(stream, wxT("&amp;"), NULL, NULL);
 639                     break;
 640                 case wxT('"'):
 641                     OutputString(stream, wxT("&quot;"), NULL, NULL);
 642                     break;
 643                 default: break;
 644             }
 645             last = i + 1;
 646         }
 647     }
 648     OutputString(stream, str.Mid(last, i - last), convMem, convFile);
 649 }
 650
 651 inline static void OutputIndentation(wxOutputStream& stream, int indent)
 652 {
 653     wxString str = wxT("\n");
 654     for (int i = 0; i < indent; i++)
 655         str << wxT(' ') << wxT(' ');
 656     OutputString(stream, str, NULL, NULL);
 657 }
 658
 659 static void OutputNode(wxOutputStream& stream, wxXmlNode *node, int indent,
 660                        wxMBConv *convMem, wxMBConv *convFile)
 661 {
 662     wxXmlNode *n, *prev;
 663     wxXmlProperty *prop;
 664
 665     switch (node->GetType())
 666     {
 667         case wxXML_TEXT_NODE:
 668             OutputStringEnt(stream, node->GetContent(), convMem, convFile);
 669             break;
 670
 671         case wxXML_ELEMENT_NODE:
 672             OutputString(stream, wxT("<"), NULL, NULL);
 673             OutputString(stream, node->GetName(), NULL, NULL);
 674
 675             prop = node->GetProperties();
 676             while (prop)
 677             {
 678                 OutputString(stream, wxT(" ") + prop->GetName() +  wxT("=\""),
 679                              NULL, NULL);
 680                 OutputStringEnt(stream, prop->GetValue(), NULL, NULL,
 681                                 true/*escapeQuotes*/);
 682                 OutputString(stream, wxT("\""), NULL, NULL);
 683                 prop = prop->GetNext();
 684             }
 685
 686             if (node->GetChildren())
 687             {
 688                 OutputString(stream, wxT(">"), NULL, NULL);
 689                 prev = NULL;
 690                 n = node->GetChildren();
 691                 while (n)
 692                 {
 693                     if (n && n->GetType() != wxXML_TEXT_NODE)
 694                         OutputIndentation(stream, indent + 1);
 695                     OutputNode(stream, n, indent + 1, convMem, convFile);
 696                     prev = n;
 697                     n = n->GetNext();
 698                 }
 699                 if (prev && prev->GetType() != wxXML_TEXT_NODE)
 700                     OutputIndentation(stream, indent);
 701                 OutputString(stream, wxT("</"), NULL, NULL);
 702                 OutputString(stream, node->GetName(), NULL, NULL);
 703                 OutputString(stream, wxT(">"), NULL, NULL);
 704             }
 705             else
 706                 OutputString(stream, wxT("/>"), NULL, NULL);
 707             break;
 708
 709         case wxXML_COMMENT_NODE:
 710             OutputString(stream, wxT("<!--"), NULL, NULL);
 711             OutputString(stream, node->GetContent(), convMem, convFile);
 712             OutputString(stream, wxT("-->"), NULL, NULL);
 713             break;
 714
 715         default:
 716             wxFAIL_MSG(wxT("unsupported node type"));
 717     }
 718 }
 719
 720 bool wxXmlDocument::Save(wxOutputStream& stream) const
 721 {
 722     if ( !IsOk() )
 723         return FALSE;
 724
 725     wxString s;
 726
 727     wxMBConv *convMem = NULL, *convFile = NULL;
 728 #if wxUSE_UNICODE
 729     convFile = new wxCSConv(GetFileEncoding());
 730 #else
 731     if ( GetFileEncoding() != GetEncoding() )
 732     {
 733         convFile = new wxCSConv(GetFileEncoding());
 734         convMem = new wxCSConv(GetEncoding());
 735     }
 736 #endif
 737
 738     s.Printf(wxT("<?xml version=\"%s\" encoding=\"%s\"?>\n"),
 739              GetVersion().c_str(), GetFileEncoding().c_str());
 740     OutputString(stream, s, NULL, NULL);
 741
 742     OutputNode(stream, GetRoot(), 0, convMem, convFile);
 743     OutputString(stream, wxT("\n"), NULL, NULL);
 744
 745     if ( convFile )
 746         delete convFile;
 747     if ( convMem )
 748         delete convMem;
 749
 750     return TRUE;
 751 }
 752
 753 #endif // wxUSE_XML