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     else
 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             wxLogError(_("XML parsing error: '%s' at line %d"),
 547                        XML_ErrorString(XML_GetErrorCode(parser)),
 548                        XML_GetCurrentLineNumber(parser));
 549             ok = false;
 550             break;
 551         }
 552     } while (!done);
 553
 554     if (ok)
 555     {
 556         SetVersion(ctx.version);
 557         SetFileEncoding(ctx.encoding);
 558         SetRoot(ctx.root);
 559     }
 560
 561     XML_ParserFree(parser);
 562 #if !wxUSE_UNICODE
 563     if ( ctx.conv )
 564         delete ctx.conv;
 565 #endif
 566
 567     return ok;
 568
 569 }
 570
 571
 572
 573 //-----------------------------------------------------------------------------
 574 //  wxXmlDocument saving routines
 575 //-----------------------------------------------------------------------------
 576
 577 // write string to output:
 578 inline static void OutputString(wxOutputStream& stream, const wxString& str,
 579                                 wxMBConv *convMem, wxMBConv *convFile)
 580 {
 581     if (str.IsEmpty()) return;
 582 #if wxUSE_UNICODE
 583     const wxWX2MBbuf buf(str.mb_str(
 584 #ifdef __MWERKS__
 585     *(convFile ? convFile : &wxConvUTF8)
 586 #else
 587     convFile ? *convFile : wxConvUTF8
 588 #endif
 589     ));
 590     stream.Write((const char*)buf, strlen((const char*)buf));
 591 #else
 592     if ( convFile == NULL )
 593         stream.Write(str.mb_str(), str.Len());
 594     else
 595     {
 596         wxString str2(str.wc_str(*convMem), *convFile);
 597         stream.Write(str2.mb_str(), str2.Len());
 598     }
 599 #endif
 600 }
 601
 602 // Same as above, but create entities first.
 603 // Translates '<' to "&lt;", '>' to "&gt;" and '&' to "&amp;"
 604 static void OutputStringEnt(wxOutputStream& stream, const wxString& str,
 605                             wxMBConv *convMem, wxMBConv *convFile)
 606 {
 607     wxString buf;
 608     size_t i, last, len;
 609     wxChar c;
 610
 611     len = str.Len();
 612     last = 0;
 613     for (i = 0; i < len; i++)
 614     {
 615         c = str.GetChar(i);
 616         if (c == wxT('<') || c == wxT('>') ||
 617             (c == wxT('&') && str.Mid(i+1, 4) != wxT("amp;")))
 618         {
 619             OutputString(stream, str.Mid(last, i - last), convMem, convFile);
 620             switch (c)
 621             {
 622                 case wxT('<'):
 623                     OutputString(stream, wxT("&lt;"), NULL, NULL);
 624                     break;
 625                 case wxT('>'):
 626                     OutputString(stream, wxT("&gt;"), NULL, NULL);
 627                     break;
 628                 case wxT('&'):
 629                     OutputString(stream, wxT("&amp;"), NULL, NULL);
 630                     break;
 631                 default: break;
 632             }
 633             last = i + 1;
 634         }
 635     }
 636     OutputString(stream, str.Mid(last, i - last), convMem, convFile);
 637 }
 638
 639 inline static void OutputIndentation(wxOutputStream& stream, int indent)
 640 {
 641     wxString str = wxT("\n");
 642     for (int i = 0; i < indent; i++)
 643         str << wxT(' ') << wxT(' ');
 644     OutputString(stream, str, NULL, NULL);
 645 }
 646
 647 static void OutputNode(wxOutputStream& stream, wxXmlNode *node, int indent,
 648                        wxMBConv *convMem, wxMBConv *convFile)
 649 {
 650     wxXmlNode *n, *prev;
 651     wxXmlProperty *prop;
 652
 653     switch (node->GetType())
 654     {
 655         case wxXML_TEXT_NODE:
 656             OutputStringEnt(stream, node->GetContent(), convMem, convFile);
 657             break;
 658
 659         case wxXML_ELEMENT_NODE:
 660             OutputString(stream, wxT("<"), NULL, NULL);
 661             OutputString(stream, node->GetName(), NULL, NULL);
 662
 663             prop = node->GetProperties();
 664             while (prop)
 665             {
 666                 OutputString(stream, wxT(" ") + prop->GetName() +
 667                              wxT("=\"") + prop->GetValue() + wxT("\""),
 668                              NULL, NULL);
 669                 // FIXME - what if prop contains '"'?
 670                 prop = prop->GetNext();
 671             }
 672
 673             if (node->GetChildren())
 674             {
 675                 OutputString(stream, wxT(">"), NULL, NULL);
 676                 prev = NULL;
 677                 n = node->GetChildren();
 678                 while (n)
 679                 {
 680                     if (n && n->GetType() != wxXML_TEXT_NODE)
 681                         OutputIndentation(stream, indent + 1);
 682                     OutputNode(stream, n, indent + 1, convMem, convFile);
 683                     prev = n;
 684                     n = n->GetNext();
 685                 }
 686                 if (prev && prev->GetType() != wxXML_TEXT_NODE)
 687                     OutputIndentation(stream, indent);
 688                 OutputString(stream, wxT("</"), NULL, NULL);
 689                 OutputString(stream, node->GetName(), NULL, NULL);
 690                 OutputString(stream, wxT(">"), NULL, NULL);
 691             }
 692             else
 693                 OutputString(stream, wxT("/>"), NULL, NULL);
 694             break;
 695
 696         case wxXML_COMMENT_NODE:
 697             OutputString(stream, wxT("<!--"), NULL, NULL);
 698             OutputString(stream, node->GetContent(), convMem, convFile);
 699             OutputString(stream, wxT("-->"), NULL, NULL);
 700             break;
 701
 702         default:
 703             wxFAIL_MSG(wxT("unsupported node type"));
 704     }
 705 }
 706
 707 bool wxXmlDocument::Save(wxOutputStream& stream) const
 708 {
 709     if ( !IsOk() )
 710         return FALSE;
 711
 712     wxString s;
 713
 714     wxMBConv *convMem = NULL, *convFile = NULL;
 715 #if wxUSE_UNICODE
 716     convFile = new wxCSConv(GetFileEncoding());
 717 #else
 718     if ( GetFileEncoding() != GetEncoding() )
 719     {
 720         convFile = new wxCSConv(GetFileEncoding());
 721         convMem = new wxCSConv(GetEncoding());
 722     }
 723 #endif
 724
 725     s.Printf(wxT("<?xml version=\"%s\" encoding=\"%s\"?>\n"),
 726              GetVersion().c_str(), GetFileEncoding().c_str());
 727     OutputString(stream, s, NULL, NULL);
 728
 729     OutputNode(stream, GetRoot(), 0, convMem, convFile);
 730     OutputString(stream, wxT("\n"), NULL, NULL);
 731
 732     if ( convFile )
 733         delete convFile;
 734     if ( convMem )
 735         delete convMem;
 736
 737     return TRUE;
 738 }
 739
 740 #endif // wxUSE_XML