]> git.saurik.com Git - wxWidgets.git/blob - src/xml/xml.cpp
projects / wxWidgets.git / blob
? search:


665c4b906b4d7dc4d7a347b6bdcd78f12af2ddd6
[wxWidgets.git] / src / xml / xml.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/xml/xml.cpp
3 // Purpose: wxXmlDocument - XML parser & data holder class
4 // Author: Vaclav Slavik
5 // Created: 2000/03/05
6 // Copyright: (c) 2000 Vaclav Slavik
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 // For compilers that support precompilation, includes "wx.h".
11 #include "wx/wxprec.h"
12
13 #ifdef __BORLANDC__
14 #pragma hdrstop
15 #endif
16
17 #if wxUSE_XML
18
19 #include "wx/xml/xml.h"
20
21 #ifndef WX_PRECOMP
22 #include "wx/intl.h"
23 #include "wx/log.h"
24 #include "wx/app.h"
25 #endif
26
27 #include "wx/wfstream.h"
28 #include "wx/datstrm.h"
29 #include "wx/zstream.h"
30 #include "wx/strconv.h"
31 #include "wx/scopedptr.h"
32 #include "wx/versioninfo.h"
33
34 #include "expat.h" // from Expat
35
36 // DLL options compatibility check:
37 WX_CHECK_BUILD_OPTIONS("wxXML")
38
39
40 IMPLEMENT_CLASS(wxXmlDocument, wxObject)
41
42
43 // a private utility used by wxXML
44 static bool wxIsWhiteOnly(const wxString& buf);
45
46
47 //-----------------------------------------------------------------------------
48 // wxXmlNode
49 //-----------------------------------------------------------------------------
50
51 wxXmlNode::wxXmlNode(wxXmlNode *parent,wxXmlNodeType type,
52 const wxString& name, const wxString& content,
53 wxXmlAttribute *attrs, wxXmlNode *next, int lineNo)
54 : m_type(type), m_name(name), m_content(content),
55 m_attrs(attrs), m_parent(parent),
56 m_children(NULL), m_next(next),
57 m_lineNo(lineNo),
58 m_noConversion(false)
59 {
60 wxASSERT_MSG ( type != wxXML_ELEMENT_NODE || content.empty(), "element nodes can't have content" );
61
62 if (m_parent)
63 {
64 if (m_parent->m_children)
65 {
66 m_next = m_parent->m_children;
67 m_parent->m_children = this;
68 }
69 else
70 m_parent->m_children = this;
71 }
72 }
73
74 wxXmlNode::wxXmlNode(wxXmlNodeType type, const wxString& name,
75 const wxString& content,
76 int lineNo)
77 : m_type(type), m_name(name), m_content(content),
78 m_attrs(NULL), m_parent(NULL),
79 m_children(NULL), m_next(NULL),
80 m_lineNo(lineNo), m_noConversion(false)
81 {
82 wxASSERT_MSG ( type != wxXML_ELEMENT_NODE || content.empty(), "element nodes can't have content" );
83 }
84
85 wxXmlNode::wxXmlNode(const wxXmlNode& node)
86 {
87 m_next = NULL;
88 m_parent = NULL;
89 DoCopy(node);
90 }
91
92 wxXmlNode::~wxXmlNode()
93 {
94 DoFree();
95 }
96
97 wxXmlNode& wxXmlNode::operator=(const wxXmlNode& node)
98 {
99 if ( &node != this )
100 {
101 DoFree();
102 DoCopy(node);
103 }
104
105 return *this;
106 }
107
108 void wxXmlNode::DoFree()
109 {
110 wxXmlNode *c, *c2;
111 for (c = m_children; c; c = c2)
112 {
113 c2 = c->m_next;
114 delete c;
115 }
116
117 wxXmlAttribute *p, *p2;
118 for (p = m_attrs; p; p = p2)
119 {
120 p2 = p->GetNext();
121 delete p;
122 }
123 }
124
125 void wxXmlNode::DoCopy(const wxXmlNode& node)
126 {
127 m_type = node.m_type;
128 m_name = node.m_name;
129 m_content = node.m_content;
130 m_lineNo = node.m_lineNo;
131 m_noConversion = node.m_noConversion;
132 m_children = NULL;
133
134 wxXmlNode *n = node.m_children;
135 while (n)
136 {
137 AddChild(new wxXmlNode(*n));
138 n = n->GetNext();
139 }
140
141 m_attrs = NULL;
142 wxXmlAttribute *p = node.m_attrs;
143 while (p)
144 {
145 AddAttribute(p->GetName(), p->GetValue());
146 p = p->GetNext();
147 }
148 }
149
150 bool wxXmlNode::HasAttribute(const wxString& attrName) const
151 {
152 wxXmlAttribute *attr = GetAttributes();
153
154 while (attr)
155 {
156 if (attr->GetName() == attrName) return true;
157 attr = attr->GetNext();
158 }
159
160 return false;
161 }
162
163 bool wxXmlNode::GetAttribute(const wxString& attrName, wxString *value) const
164 {
165 wxCHECK_MSG( value, false, "value argument must not be NULL" );
166
167 wxXmlAttribute *attr = GetAttributes();
168
169 while (attr)
170 {
171 if (attr->GetName() == attrName)
172 {
173 *value = attr->GetValue();
174 return true;
175 }
176 attr = attr->GetNext();
177 }
178
179 return false;
180 }
181
182 wxString wxXmlNode::GetAttribute(const wxString& attrName, const wxString& defaultVal) const
183 {
184 wxString tmp;
185 if (GetAttribute(attrName, &tmp))
186 return tmp;
187
188 return defaultVal;
189 }
190
191 void wxXmlNode::AddChild(wxXmlNode *child)
192 {
193 if (m_children == NULL)
194 m_children = child;
195 else
196 {
197 wxXmlNode *ch = m_children;
198 while (ch->m_next) ch = ch->m_next;
199 ch->m_next = child;
200 }
201 child->m_next = NULL;
202 child->m_parent = this;
203 }
204
205 // inserts a new node in front of 'followingNode'
206 bool wxXmlNode::InsertChild(wxXmlNode *child, wxXmlNode *followingNode)
207 {
208 wxCHECK_MSG( child, false, "cannot insert a NULL node!" );
209 wxCHECK_MSG( child->m_parent == NULL, false, "node already has a parent" );
210 wxCHECK_MSG( child->m_next == NULL, false, "node already has m_next" );
211 wxCHECK_MSG( followingNode == NULL || followingNode->GetParent() == this,
212 false,
213 "wxXmlNode::InsertChild - followingNode has incorrect parent" );
214
215 // this is for backward compatibility, NULL was allowed here thanks to
216 // the confusion about followingNode's meaning
217 if ( followingNode == NULL )
218 followingNode = m_children;
219
220 if ( m_children == followingNode )
221 {
222 child->m_next = m_children;
223 m_children = child;
224 }
225 else
226 {
227 wxXmlNode *ch = m_children;
228 while ( ch && ch->m_next != followingNode )
229 ch = ch->m_next;
230 if ( !ch )
231 {
232 wxFAIL_MSG( "followingNode has this node as parent, but couldn't be found among children" );
233 return false;
234 }
235
236 child->m_next = followingNode;
237 ch->m_next = child;
238 }
239
240 child->m_parent = this;
241 return true;
242 }
243
244 // inserts a new node right after 'precedingNode'
245 bool wxXmlNode::InsertChildAfter(wxXmlNode *child, wxXmlNode *precedingNode)
246 {
247 wxCHECK_MSG( child, false, "cannot insert a NULL node!" );
248 wxCHECK_MSG( child->m_parent == NULL, false, "node already has a parent" );
249 wxCHECK_MSG( child->m_next == NULL, false, "node already has m_next" );
250 wxCHECK_MSG( precedingNode == NULL || precedingNode->m_parent == this, false,
251 "precedingNode has wrong parent" );
252
253 if ( precedingNode )
254 {
255 child->m_next = precedingNode->m_next;
256 precedingNode->m_next = child;
257 }
258 else // precedingNode == NULL
259 {
260 wxCHECK_MSG( m_children == NULL, false,
261 "NULL precedingNode only makes sense when there are no children" );
262
263 child->m_next = m_children;
264 m_children = child;
265 }
266
267 child->m_parent = this;
268 return true;
269 }
270
271 bool wxXmlNode::RemoveChild(wxXmlNode *child)
272 {
273 if (m_children == NULL)
274 return false;
275 else if (m_children == child)
276 {
277 m_children = child->m_next;
278 child->m_parent = NULL;
279 child->m_next = NULL;
280 return true;
281 }
282 else
283 {
284 wxXmlNode *ch = m_children;
285 while (ch->m_next)
286 {
287 if (ch->m_next == child)
288 {
289 ch->m_next = child->m_next;
290 child->m_parent = NULL;
291 child->m_next = NULL;
292 return true;
293 }
294 ch = ch->m_next;
295 }
296 return false;
297 }
298 }
299
300 void wxXmlNode::AddAttribute(const wxString& name, const wxString& value)
301 {
302 AddProperty(name, value);
303 }
304
305 void wxXmlNode::AddAttribute(wxXmlAttribute *attr)
306 {
307 AddProperty(attr);
308 }
309
310 bool wxXmlNode::DeleteAttribute(const wxString& name)
311 {
312 return DeleteProperty(name);
313 }
314
315 void wxXmlNode::AddProperty(const wxString& name, const wxString& value)
316 {
317 AddProperty(new wxXmlAttribute(name, value, NULL));
318 }
319
320 void wxXmlNode::AddProperty(wxXmlAttribute *attr)
321 {
322 if (m_attrs == NULL)
323 m_attrs = attr;
324 else
325 {
326 wxXmlAttribute *p = m_attrs;
327 while (p->GetNext()) p = p->GetNext();
328 p->SetNext(attr);
329 }
330 }
331
332 bool wxXmlNode::DeleteProperty(const wxString& name)
333 {
334 wxXmlAttribute *attr;
335
336 if (m_attrs == NULL)
337 return false;
338
339 else if (m_attrs->GetName() == name)
340 {
341 attr = m_attrs;
342 m_attrs = attr->GetNext();
343 attr->SetNext(NULL);
344 delete attr;
345 return true;
346 }
347
348 else
349 {
350 wxXmlAttribute *p = m_attrs;
351 while (p->GetNext())
352 {
353 if (p->GetNext()->GetName() == name)
354 {
355 attr = p->GetNext();
356 p->SetNext(attr->GetNext());
357 attr->SetNext(NULL);
358 delete attr;
359 return true;
360 }
361 p = p->GetNext();
362 }
363 return false;
364 }
365 }
366
367 wxString wxXmlNode::GetNodeContent() const
368 {
369 wxXmlNode *n = GetChildren();
370
371 while (n)
372 {
373 if (n->GetType() == wxXML_TEXT_NODE ||
374 n->GetType() == wxXML_CDATA_SECTION_NODE)
375 return n->GetContent();
376 n = n->GetNext();
377 }
378 return wxEmptyString;
379 }
380
381 int wxXmlNode::GetDepth(wxXmlNode *grandparent) const
382 {
383 const wxXmlNode *n = this;
384 int ret = -1;
385
386 do
387 {
388 ret++;
389 n = n->GetParent();
390 if (n == grandparent)
391 return ret;
392
393 } while (n);
394
395 return wxNOT_FOUND;
396 }
397
398 bool wxXmlNode::IsWhitespaceOnly() const
399 {
400 return wxIsWhiteOnly(m_content);
401 }
402
403
404
405 //-----------------------------------------------------------------------------
406 // wxXmlDocument
407 //-----------------------------------------------------------------------------
408
409 wxXmlDocument::wxXmlDocument()
410 : m_version(wxS("1.0")), m_fileEncoding(wxS("UTF-8")), m_docNode(NULL)
411 {
412 #if !wxUSE_UNICODE
413 m_encoding = wxS("UTF-8");
414 #endif
415 }
416
417 wxXmlDocument::wxXmlDocument(const wxString& filename, const wxString& encoding)
418 :wxObject(), m_docNode(NULL)
419 {
420 if ( !Load(filename, encoding) )
421 {
422 wxDELETE(m_docNode);
423 }
424 }
425
426 wxXmlDocument::wxXmlDocument(wxInputStream& stream, const wxString& encoding)
427 :wxObject(), m_docNode(NULL)
428 {
429 if ( !Load(stream, encoding) )
430 {
431 wxDELETE(m_docNode);
432 }
433 }
434
435 wxXmlDocument::wxXmlDocument(const wxXmlDocument& doc)
436 :wxObject()
437 {
438 DoCopy(doc);
439 }
440
441 wxXmlDocument& wxXmlDocument::operator=(const wxXmlDocument& doc)
442 {
443 wxDELETE(m_docNode);
444 DoCopy(doc);
445 return *this;
446 }
447
448 void wxXmlDocument::DoCopy(const wxXmlDocument& doc)
449 {
450 m_version = doc.m_version;
451 #if !wxUSE_UNICODE
452 m_encoding = doc.m_encoding;
453 #endif
454 m_fileEncoding = doc.m_fileEncoding;
455
456 if (doc.m_docNode)
457 m_docNode = new wxXmlNode(*doc.m_docNode);
458 else
459 m_docNode = NULL;
460 }
461
462 bool wxXmlDocument::Load(const wxString& filename, const wxString& encoding, int flags)
463 {
464 wxFileInputStream stream(filename);
465 if (!stream.IsOk())
466 return false;
467 return Load(stream, encoding, flags);
468 }
469
470 bool wxXmlDocument::Save(const wxString& filename, int indentstep) const
471 {
472 wxFileOutputStream stream(filename);
473 if (!stream.IsOk())
474 return false;
475 return Save(stream, indentstep);
476 }
477
478 wxXmlNode *wxXmlDocument::GetRoot() const
479 {
480 wxXmlNode *node = m_docNode;
481 if (node)
482 {
483 node = m_docNode->GetChildren();
484 while (node != NULL && node->GetType() != wxXML_ELEMENT_NODE)
485 node = node->GetNext();
486 }
487 return node;
488 }
489
490 wxXmlNode *wxXmlDocument::DetachRoot()
491 {
492 wxXmlNode *node = m_docNode;
493 if (node)
494 {
495 node = m_docNode->GetChildren();
496 wxXmlNode *prev = NULL;
497 while (node != NULL && node->GetType() != wxXML_ELEMENT_NODE)
498 {
499 prev = node;
500 node = node->GetNext();
501 }
502 if (node)
503 {
504 if (node == m_docNode->GetChildren())
505 m_docNode->SetChildren(node->GetNext());
506
507 if (prev)
508 prev->SetNext(node->GetNext());
509
510 node->SetParent(NULL);
511 node->SetNext(NULL);
512 }
513 }
514 return node;
515 }
516
517 void wxXmlDocument::SetRoot(wxXmlNode *root)
518 {
519 if (root)
520 {
521 wxASSERT_MSG( root->GetType() == wxXML_ELEMENT_NODE,
522 "Can only set an element type node as root" );
523 }
524
525 wxXmlNode *node = m_docNode;
526 if (node)
527 {
528 node = m_docNode->GetChildren();
529 wxXmlNode *prev = NULL;
530 while (node != NULL && node->GetType() != wxXML_ELEMENT_NODE)
531 {
532 prev = node;
533 node = node->GetNext();
534 }
535 if (node && root)
536 {
537 root->SetNext( node->GetNext() );
538 wxDELETE(node);
539 }
540 if (prev)
541 prev->SetNext(root);
542 else
543 m_docNode->SetChildren(root);
544 }
545 else
546 {
547 m_docNode = new wxXmlNode(wxXML_DOCUMENT_NODE, wxEmptyString);
548 m_docNode->SetChildren(root);
549 }
550 if (root)
551 root->SetParent(m_docNode);
552 }
553
554 void wxXmlDocument::AppendToProlog(wxXmlNode *node)
555 {
556 if (!m_docNode)
557 m_docNode = new wxXmlNode(wxXML_DOCUMENT_NODE, wxEmptyString);
558 if (IsOk())
559 m_docNode->InsertChild( node, GetRoot() );
560 else
561 m_docNode->AddChild( node );
562 }
563
564 //-----------------------------------------------------------------------------
565 // wxXmlDocument loading routines
566 //-----------------------------------------------------------------------------
567
568 // converts Expat-produced string in UTF-8 into wxString using the specified
569 // conv or keep in UTF-8 if conv is NULL
570 static wxString CharToString(wxMBConv *conv,
571 const char *s, size_t len = wxString::npos)
572 {
573 #if !wxUSE_UNICODE
574 if ( conv )
575 {
576 // there can be no embedded NULs in this string so we don't need the
577 // output length, it will be NUL-terminated
578 const wxWCharBuffer wbuf(
579 wxConvUTF8.cMB2WC(s, len == wxString::npos ? wxNO_LEN : len, NULL));
580
581 return wxString(wbuf, *conv);
582 }
583 // else: the string is wanted in UTF-8
584 #endif // !wxUSE_UNICODE
585
586 wxUnusedVar(conv);
587 return wxString::FromUTF8Unchecked(s, len);
588 }
589
590 // returns true if the given string contains only whitespaces
591 bool wxIsWhiteOnly(const wxString& buf)
592 {
593 for ( wxString::const_iterator i = buf.begin(); i != buf.end(); ++i )
594 {
595 wxChar c = *i;
596 if ( c != wxS(' ') && c != wxS('\t') && c != wxS('\n') && c != wxS('\r'))
597 return false;
598 }
599 return true;
600 }
601
602
603 struct wxXmlParsingContext
604 {
605 wxXmlParsingContext()
606 : conv(NULL),
607 node(NULL),
608 lastChild(NULL),
609 lastAsText(NULL),
610 removeWhiteOnlyNodes(false)
611 {}
612
613 XML_Parser parser;
614 wxMBConv *conv;
615 wxXmlNode *node; // the node being parsed
616 wxXmlNode *lastChild; // the last child of "node"
617 wxXmlNode *lastAsText; // the last _text_ child of "node"
618 wxString encoding;
619 wxString version;
620 bool removeWhiteOnlyNodes;
621 };
622
623 // checks that ctx->lastChild is in consistent state
624 #define ASSERT_LAST_CHILD_OK(ctx) \
625 wxASSERT( ctx->lastChild == NULL || \
626 ctx->lastChild->GetNext() == NULL ); \
627 wxASSERT( ctx->lastChild == NULL || \
628 ctx->lastChild->GetParent() == ctx->node )
629
630 extern "C" {
631 static void StartElementHnd(void *userData, const char *name, const char **atts)
632 {
633 wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;
634 wxXmlNode *node = new wxXmlNode(wxXML_ELEMENT_NODE,
635 CharToString(ctx->conv, name),
636 wxEmptyString,
637 XML_GetCurrentLineNumber(ctx->parser));
638 const char **a = atts;
639
640 // add node attributes
641 while (*a)
642 {
643 node->AddAttribute(CharToString(ctx->conv, a[0]), CharToString(ctx->conv, a[1]));
644 a += 2;
645 }
646
647 ASSERT_LAST_CHILD_OK(ctx);
648 ctx->node->InsertChildAfter(node, ctx->lastChild);
649 ctx->lastAsText = NULL;
650 ctx->lastChild = NULL; // our new node "node" has no children yet
651
652 ctx->node = node;
653 }
654
655 static void EndElementHnd(void *userData, const char* WXUNUSED(name))
656 {
657 wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;
658
659 // we're exiting the last children of ctx->node->GetParent() and going
660 // back one level up, so current value of ctx->node points to the last
661 // child of ctx->node->GetParent()
662 ctx->lastChild = ctx->node;
663
664 ctx->node = ctx->node->GetParent();
665 ctx->lastAsText = NULL;
666 }
667
668 static void TextHnd(void *userData, const char *s, int len)
669 {
670 wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;
671 wxString str = CharToString(ctx->conv, s, len);
672
673 if (ctx->lastAsText)
674 {
675 ctx->lastAsText->SetContent(ctx->lastAsText->GetContent() + str);
676 }
677 else
678 {
679 bool whiteOnly = false;
680 if (ctx->removeWhiteOnlyNodes)
681 whiteOnly = wxIsWhiteOnly(str);
682
683 if (!whiteOnly)
684 {
685 wxXmlNode *textnode =
686 new wxXmlNode(wxXML_TEXT_NODE, wxS("text"), str,
687 XML_GetCurrentLineNumber(ctx->parser));
688
689 ASSERT_LAST_CHILD_OK(ctx);
690 ctx->node->InsertChildAfter(textnode, ctx->lastChild);
691 ctx->lastChild= ctx->lastAsText = textnode;
692 }
693 }
694 }
695
696 static void StartCdataHnd(void *userData)
697 {
698 wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;
699
700 wxXmlNode *textnode =
701 new wxXmlNode(wxXML_CDATA_SECTION_NODE, wxS("cdata"), wxS(""),
702 XML_GetCurrentLineNumber(ctx->parser));
703
704 ASSERT_LAST_CHILD_OK(ctx);
705 ctx->node->InsertChildAfter(textnode, ctx->lastChild);
706 ctx->lastChild= ctx->lastAsText = textnode;
707 }
708
709 static void EndCdataHnd(void *userData)
710 {
711 wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;
712
713 // we need to reset this pointer so that subsequent text nodes don't append
714 // their contents to this one but create new wxXML_TEXT_NODE objects (or
715 // not create anything at all if only white space follows the CDATA section
716 // and wxXMLDOC_KEEP_WHITESPACE_NODES is not used as is commonly the case)
717 ctx->lastAsText = NULL;
718 }
719
720 static void CommentHnd(void *userData, const char *data)
721 {
722 wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;
723
724 wxXmlNode *commentnode =
725 new wxXmlNode(wxXML_COMMENT_NODE,
726 wxS("comment"), CharToString(ctx->conv, data),
727 XML_GetCurrentLineNumber(ctx->parser));
728
729 ASSERT_LAST_CHILD_OK(ctx);
730 ctx->node->InsertChildAfter(commentnode, ctx->lastChild);
731 ctx->lastChild = commentnode;
732 ctx->lastAsText = NULL;
733 }
734
735 static void PIHnd(void *userData, const char *target, const char *data)
736 {
737 wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;
738
739 wxXmlNode *pinode =
740 new wxXmlNode(wxXML_PI_NODE, CharToString(ctx->conv, target),
741 CharToString(ctx->conv, data),
742 XML_GetCurrentLineNumber(ctx->parser));
743
744 ASSERT_LAST_CHILD_OK(ctx);
745 ctx->node->InsertChildAfter(pinode, ctx->lastChild);
746 ctx->lastChild = pinode;
747 ctx->lastAsText = NULL;
748 }
749
750 static void DefaultHnd(void *userData, const char *s, int len)
751 {
752 // XML header:
753 if (len > 6 && memcmp(s, "<?xml ", 6) == 0)
754 {
755 wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;
756
757 wxString buf = CharToString(ctx->conv, s, (size_t)len);
758 int pos;
759 pos = buf.Find(wxS("encoding="));
760 if (pos != wxNOT_FOUND)
761 ctx->encoding = buf.Mid(pos + 10).BeforeFirst(buf[(size_t)pos+9]);
762 pos = buf.Find(wxS("version="));
763 if (pos != wxNOT_FOUND)
764 ctx->version = buf.Mid(pos + 9).BeforeFirst(buf[(size_t)pos+8]);
765 }
766 }
767
768 static int UnknownEncodingHnd(void * WXUNUSED(encodingHandlerData),
769 const XML_Char *name, XML_Encoding *info)
770 {
771 // We must build conversion table for expat. The easiest way to do so
772 // is to let wxCSConv convert as string containing all characters to
773 // wide character representation:
774 wxCSConv conv(name);
775 char mbBuf[2];
776 wchar_t wcBuf[10];
777 size_t i;
778
779 mbBuf[1] = 0;
780 info->map[0] = 0;
781 for (i = 0; i < 255; i++)
782 {
783 mbBuf[0] = (char)(i+1);
784 if (conv.MB2WC(wcBuf, mbBuf, 2) == (size_t)-1)
785 {
786 // invalid/undefined byte in the encoding:
787 info->map[i+1] = -1;
788 }
789 info->map[i+1] = (int)wcBuf[0];
790 }
791
792 info->data = NULL;
793 info->convert = NULL;
794 info->release = NULL;
795
796 return 1;
797 }
798
799 } // extern "C"
800
801 bool wxXmlDocument::Load(wxInputStream& stream, const wxString& encoding, int flags)
802 {
803 #if wxUSE_UNICODE
804 (void)encoding;
805 #else
806 m_encoding = encoding;
807 #endif
808
809 const size_t BUFSIZE = 1024;
810 char buf[BUFSIZE];
811 wxXmlParsingContext ctx;
812 bool done;
813 XML_Parser parser = XML_ParserCreate(NULL);
814 wxXmlNode *root = new wxXmlNode(wxXML_DOCUMENT_NODE, wxEmptyString);
815
816 ctx.encoding = wxS("UTF-8"); // default in absence of encoding=""
817 ctx.conv = NULL;
818 #if !wxUSE_UNICODE
819 if ( encoding.CmpNoCase(wxS("UTF-8")) != 0 )
820 ctx.conv = new wxCSConv(encoding);
821 #endif
822 ctx.removeWhiteOnlyNodes = (flags & wxXMLDOC_KEEP_WHITESPACE_NODES) == 0;
823 ctx.parser = parser;
824 ctx.node = root;
825
826 XML_SetUserData(parser, (void*)&ctx);
827 XML_SetElementHandler(parser, StartElementHnd, EndElementHnd);
828 XML_SetCharacterDataHandler(parser, TextHnd);
829 XML_SetCdataSectionHandler(parser, StartCdataHnd, EndCdataHnd);;
830 XML_SetCommentHandler(parser, CommentHnd);
831 XML_SetProcessingInstructionHandler(parser, PIHnd);
832 XML_SetDefaultHandler(parser, DefaultHnd);
833 XML_SetUnknownEncodingHandler(parser, UnknownEncodingHnd, NULL);
834
835 bool ok = true;
836 do
837 {
838 size_t len = stream.Read(buf, BUFSIZE).LastRead();
839 done = (len < BUFSIZE);
840 if (!XML_Parse(parser, buf, len, done))
841 {
842 wxString error(XML_ErrorString(XML_GetErrorCode(parser)),
843 *wxConvCurrent);
844 wxLogError(_("XML parsing error: '%s' at line %d"),
845 error.c_str(),
846 (int)XML_GetCurrentLineNumber(parser));
847 ok = false;
848 break;
849 }
850 } while (!done);
851
852 if (ok)
853 {
854 if (!ctx.version.empty())
855 SetVersion(ctx.version);
856 if (!ctx.encoding.empty())
857 SetFileEncoding(ctx.encoding);
858 SetDocumentNode(root);
859 }
860 else
861 {
862 delete root;
863 }
864
865 XML_ParserFree(parser);
866 #if !wxUSE_UNICODE
867 if ( ctx.conv )
868 delete ctx.conv;
869 #endif
870
871 return ok;
872
873 }
874
875
876
877 //-----------------------------------------------------------------------------
878 // wxXmlDocument saving routines
879 //-----------------------------------------------------------------------------
880
881 // helpers for XML generation
882 namespace
883 {
884
885 // write string to output:
886 bool OutputString(wxOutputStream& stream,
887 const wxString& str,
888 wxMBConv *convMem,
889 wxMBConv *convFile)
890 {
891 if (str.empty())
892 return true;
893
894 #if wxUSE_UNICODE
895 wxUnusedVar(convMem);
896 if ( !convFile )
897 convFile = &wxConvUTF8;
898
899 const wxScopedCharBuffer buf(str.mb_str(*convFile));
900 if ( !buf.length() )
901 {
902 // conversion failed, can't write this string in an XML file in this
903 // (presumably non-UTF-8) encoding
904 return false;
905 }
906
907 stream.Write(buf, buf.length());
908 #else // !wxUSE_UNICODE
909 if ( convFile && convMem )
910 {
911 wxString str2(str.wc_str(*convMem), *convFile);
912 stream.Write(str2.mb_str(), str2.length());
913 }
914 else // no conversions to do
915 {
916 stream.Write(str.mb_str(), str.length());
917 }
918 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
919
920 return stream.IsOk();
921 }
922
923 enum EscapingMode
924 {
925 Escape_Text,
926 Escape_Attribute
927 };
928
929 // Same as above, but create entities first.
930 // Translates '<' to "&lt;", '>' to "&gt;" and so on, according to the spec:
931 // http://www.w3.org/TR/2000/WD-xml-c14n-20000119.html#charescaping
932 bool OutputEscapedString(wxOutputStream& stream,
933 const wxString& str,
934 wxMBConv *convMem,
935 wxMBConv *convFile,
936 EscapingMode mode)
937 {
938 wxString escaped;
939 escaped.reserve(str.length());
940
941 for ( wxString::const_iterator i = str.begin(); i != str.end(); ++i )
942 {
943 const wxChar c = *i;
944
945 switch ( c )
946 {
947 case wxS('<'):
948 escaped.append(wxS("&lt;"));
949 break;
950 case wxS('>'):
951 escaped.append(wxS("&gt;"));
952 break;
953 case wxS('&'):
954 escaped.append(wxS("&amp;"));
955 break;
956 case wxS('\r'):
957 escaped.append(wxS("&#xD;"));
958 break;
959 default:
960 if ( mode == Escape_Attribute )
961 {
962 switch ( c )
963 {
964 case wxS('"'):
965 escaped.append(wxS("&quot;"));
966 break;
967 case wxS('\t'):
968 escaped.append(wxS("&#x9;"));
969 break;
970 case wxS('\n'):
971 escaped.append(wxS("&#xA;"));
972 break;
973 default:
974 escaped.append(c);
975 }
976
977 }
978 else
979 {
980 escaped.append(c);
981 }
982 }
983 }
984
985 return OutputString(stream, escaped, convMem, convFile);
986 }
987
988 bool OutputIndentation(wxOutputStream& stream,
989 int indent,
990 wxMBConv *convMem,
991 wxMBConv *convFile)
992 {
993 wxString str(wxS("\n"));
994 str += wxString(indent, wxS(' '));
995 return OutputString(stream, str, convMem, convFile);
996 }
997
998 bool OutputNode(wxOutputStream& stream,
999 wxXmlNode *node,
1000 int indent,
1001 wxMBConv *convMem,
1002 wxMBConv *convFile,
1003 int indentstep)
1004 {
1005 bool rc;
1006 switch (node->GetType())
1007 {
1008 case wxXML_CDATA_SECTION_NODE:
1009 rc = OutputString(stream, wxS("<![CDATA["), convMem, convFile) &&
1010 OutputString(stream, node->GetContent(), convMem, convFile) &&
1011 OutputString(stream, wxS("]]>"), convMem, convFile);
1012 break;
1013
1014 case wxXML_TEXT_NODE:
1015 if (node->GetNoConversion())
1016 {
1017 stream.Write(node->GetContent().c_str(), node->GetContent().Length());
1018 rc = true;
1019 }
1020 else
1021 rc = OutputEscapedString(stream, node->GetContent(),
1022 convMem, convFile,
1023 Escape_Text);
1024 break;
1025
1026 case wxXML_ELEMENT_NODE:
1027 rc = OutputString(stream, wxS("<"), convMem, convFile) &&
1028 OutputString(stream, node->GetName(), convMem, convFile);
1029
1030 if ( rc )
1031 {
1032 for ( wxXmlAttribute *attr = node->GetAttributes();
1033 attr && rc;
1034 attr = attr->GetNext() )
1035 {
1036 rc = OutputString(stream,
1037 wxS(" ") + attr->GetName() + wxS("=\""),
1038 convMem, convFile) &&
1039 OutputEscapedString(stream, attr->GetValue(),
1040 convMem, convFile,
1041 Escape_Attribute) &&
1042 OutputString(stream, wxS("\""), convMem, convFile);
1043 }
1044 }
1045
1046 if ( node->GetChildren() )
1047 {
1048 rc = OutputString(stream, wxS(">"), convMem, convFile);
1049
1050 wxXmlNode *prev = NULL;
1051 for ( wxXmlNode *n = node->GetChildren();
1052 n && rc;
1053 n = n->GetNext() )
1054 {
1055 if ( indentstep >= 0 && n->GetType() != wxXML_TEXT_NODE )
1056 {
1057 rc = OutputIndentation(stream, indent + indentstep,
1058 convMem, convFile);
1059 }
1060
1061 if ( rc )
1062 rc = OutputNode(stream, n, indent + indentstep,
1063 convMem, convFile, indentstep);
1064
1065 prev = n;
1066 }
1067
1068 if ( rc && indentstep >= 0 &&
1069 prev && prev->GetType() != wxXML_TEXT_NODE )
1070 {
1071 rc = OutputIndentation(stream, indent, convMem, convFile);
1072 }
1073
1074 if ( rc )
1075 {
1076 rc = OutputString(stream, wxS("</"), convMem, convFile) &&
1077 OutputString(stream, node->GetName(),
1078 convMem, convFile) &&
1079 OutputString(stream, wxS(">"), convMem, convFile);
1080 }
1081 }
1082 else // no children, output "<foo/>"
1083 {
1084 rc = OutputString(stream, wxS("/>"), convMem, convFile);
1085 }
1086 break;
1087
1088 case wxXML_COMMENT_NODE:
1089 rc = OutputString(stream, wxS("<!--"), convMem, convFile) &&
1090 OutputString(stream, node->GetContent(), convMem, convFile) &&
1091 OutputString(stream, wxS("-->"), convMem, convFile);
1092 break;
1093
1094 case wxXML_PI_NODE:
1095 rc = OutputString(stream, wxT("<?"), convMem, convFile) &&
1096 OutputString(stream, node->GetName(), convMem, convFile) &&
1097 OutputString(stream, wxT(" "), convMem, convFile) &&
1098 OutputString(stream, node->GetContent(), convMem, convFile) &&
1099 OutputString(stream, wxT("?>"), convMem, convFile);
1100 break;
1101
1102 default:
1103 wxFAIL_MSG("unsupported node type");
1104 rc = false;
1105 }
1106
1107 return rc;
1108 }
1109
1110 } // anonymous namespace
1111
1112 bool wxXmlDocument::Save(wxOutputStream& stream, int indentstep) const
1113 {
1114 if ( !IsOk() )
1115 return false;
1116
1117 wxScopedPtr<wxMBConv> convMem, convFile;
1118
1119 #if wxUSE_UNICODE
1120 convFile.reset(new wxCSConv(GetFileEncoding()));
1121 #else
1122 if ( GetFileEncoding().CmpNoCase(GetEncoding()) != 0 )
1123 {
1124 convFile.reset(new wxCSConv(GetFileEncoding()));
1125 convMem.reset(new wxCSConv(GetEncoding()));
1126 }
1127 //else: file and in-memory encodings are the same, no conversion needed
1128 #endif
1129
1130 wxString dec = wxString::Format(
1131 wxS("<?xml version=\"%s\" encoding=\"%s\"?>\n"),
1132 GetVersion(), GetFileEncoding()
1133 );
1134 bool rc = OutputString(stream, dec, convMem.get(), convFile.get());
1135
1136 wxXmlNode *node = GetDocumentNode();
1137 if ( node )
1138 node = node->GetChildren();
1139
1140 while( rc && node )
1141 {
1142 rc = OutputNode(stream, node, 0, convMem.get(),
1143 convFile.get(), indentstep) &&
1144 OutputString(stream, wxS("\n"), convMem.get(), convFile.get());
1145 node = node->GetNext();
1146 }
1147 return rc;
1148 }
1149
1150 /*static*/ wxVersionInfo wxXmlDocument::GetLibraryVersionInfo()
1151 {
1152 return wxVersionInfo("expat",
1153 XML_MAJOR_VERSION,
1154 XML_MINOR_VERSION,
1155 XML_MICRO_VERSION);
1156 }
1157
1158 #endif // wxUSE_XML
wxWidgets (Impactor)