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