]> git.saurik.com Git - wxWidgets.git/blame_incremental - utils/ifacecheck/src/xmlparser.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Fix a crash in wxExecute() in wxMSW too.
[wxWidgets.git] / utils / ifacecheck / src / xmlparser.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: xmlparser.cpp
3// Purpose: Parser of the API/interface XML files
4// Author: Francesco Montorsi
5// Created: 2008/03/17
6// RCS-ID: $Id$
7// Copyright: (c) 2008 Francesco Montorsi
8// Licence: wxWindows licence
9/////////////////////////////////////////////////////////////////////////////
10
11// For compilers that support precompilation, includes "wx/wx.h".
12#include "wx/wxprec.h"
13
14#ifdef __BORLANDC__
15 #pragma hdrstop
16#endif
17
18// for all others, include the necessary headers
19#ifndef WX_PRECOMP
20 #include "wx/crt.h"
21#endif
22
23#include "wx/xml/xml.h"
24#include "wx/wfstream.h"
25#include "wx/hashmap.h"
26#include "wx/filename.h"
27#include "xmlparser.h"
28#include <errno.h>
29
30#include <wx/arrimpl.cpp>
31WX_DEFINE_OBJARRAY(wxTypeArray)
32WX_DEFINE_OBJARRAY(wxArgumentTypeArray)
33WX_DEFINE_OBJARRAY(wxMethodArray)
34WX_DEFINE_OBJARRAY(wxClassArray)
35
36
37#define PROGRESS_RATE 1000 // each PROGRESS_RATE nodes processed print a dot
38#define ESTIMATED_NUM_CLASSES 600 // used by both wxXmlInterface-derived classes to prealloc mem
39
40
41// defined in ifacecheck.cpp
42extern bool g_verbose;
43
44// global variable:
45bool g_bLogEnabled = true;
46
47
48
49// ----------------------------------------------------------------------------
50// wxType
51// ----------------------------------------------------------------------------
52
53wxType wxEmptyType;
54
55void wxType::SetTypeFromString(const wxString& t)
56{
57 /*
58 TODO: optimize the following code writing a single function
59 which works at char-level and does everything in a single pass
60 */
61
62 // clean the type string
63 // ---------------------
64
65 m_strType = t;
66
67 // [] is the same as * for gccxml
68 m_strType.Replace("[]", "*");
69 m_strType.Replace("long int", "long"); // in wx typically we never write "long int", just "long"
70 m_strType.Replace("long unsigned int", "unsigned long");
71 m_strType.Replace("short unsigned int", "unsigned short");
72
73 // make sure the * and & operator always use the same spacing rules
74 // (to make sure GetAsString() output is always consistent)
75 m_strType.Replace("*", "* ");
76 m_strType.Replace("&", "& ");
77 m_strType.Replace(" *", "*");
78 m_strType.Replace(" &", "&");
79
80 while (m_strType.Contains(" "))
81 m_strType.Replace(" ", " "); // do it once again
82
83 m_strType.Replace(" ,", ",");
84
85 // ADHOC-FIX
86 m_strType.Replace("_wxArraywxArrayStringBase", "wxString");
87 m_strType.Replace("ExitCode", "void*"); // used in wxThread stuff
88
89 m_strType = m_strType.Strip(wxString::both);
90
91
92
93 // clean the type string (this time for the comparison)
94 // ----------------------------------------------------
95
96 m_strTypeClean = m_strType; // begin with the already-cleaned string
97 m_strTypeClean.Replace("const", "");
98 m_strTypeClean.Replace("static", "");
99 m_strTypeClean.Replace("*", "");
100 m_strTypeClean.Replace("&", "");
101 m_strTypeClean.Replace("[]", "");
102 m_strTypeClean = m_strTypeClean.Strip(wxString::both);
103
104 // to avoid false errors types like wxStandardPaths and wxStandardPathsBase
105 // need to be considered as the same type
106 if (m_strTypeClean.EndsWith("Base"))
107 m_strTypeClean = m_strTypeClean.Left(m_strTypeClean.Len()-4);
108
109 // remove the namespace from the types; there's no problem of conflicts
110 // (except for templates) and this avoids tons of false warnings
111 if (m_strTypeClean.Contains("::") && !m_strTypeClean.Contains("<"))
112 m_strTypeClean = m_strTypeClean.Mid(m_strTypeClean.Find("::")+2);
113
114 // ADHOC-FIX:
115 m_strTypeClean.Replace("wxWindowID", "int");
116}
117
118bool wxType::IsOk() const
119{
120 // NB: m_strType can contain the :: operator; think to e.g. the
121 // "reverse_iterator_impl<wxString::const_iterator>" type
122 // It can also contain commas, * and & operators etc
123
124 return !m_strTypeClean.IsEmpty();
125}
126
127bool wxType::operator==(const wxType& m) const
128{
129 // brain-dead comparison:
130
131 if (m_strTypeClean == m.m_strTypeClean &&
132 IsConst() == m.IsConst() &&
133 IsStatic() == m.IsStatic() &&
134 IsPointer() == m.IsPointer() &&
135 IsReference() == m.IsReference())
136 return true;
137
138 if (g_verbose)
139 {
140 wxLogMessage("Type '%s' does not match type '%s'", m_strType, m.m_strType);
141 wxLogMessage(" => TypeClean %s / %s; IsConst %d / %d; IsStatic %d / %d; IsPointer %d / %d; IsReference %d / %d",
142 m_strTypeClean, m.m_strTypeClean, IsConst(), m.IsConst(),
143 IsStatic(), m.IsStatic(), IsPointer(), m.IsPointer(),
144 IsReference(), m.IsReference());
145 }
146
147 return false;
148}
149
150
151// ----------------------------------------------------------------------------
152// wxArgumentType
153// ----------------------------------------------------------------------------
154
155void wxArgumentType::SetDefaultValue(const wxString& defval, const wxString& defvalForCmp)
156{
157 m_strDefaultValue = defval.Strip(wxString::both);
158 m_strDefaultValueForCmp = defvalForCmp.IsEmpty() ?
159 m_strDefaultValue : defvalForCmp.Strip(wxString::both);
160
161
162 // clean the default argument strings
163 // ----------------------------------
164
165 // Note: we adjust the aesthetic form of the m_strDefaultValue string for the "modify mode"
166 // of ifacecheck: we may need to write it out in an interface header
167
168 wxString *p = NULL;
169 for (int i=0; i<2; i++) // to avoid copying&pasting the code!
170 {
171 if (i == 0) p = &m_strDefaultValue;
172 if (i == 1) p = &m_strDefaultValueForCmp;
173
174 if (*p == "0u" || *p == "0l") *p = "0";
175
176 p->Replace("0x000000001", "1");
177 p->Replace("\\000\\000\\000", ""); // fix for unicode strings:
178 p->Replace("\\011", "\\t");
179 p->Replace("e+0", "");
180 p->Replace("2147483647", "__INT_MAX__");
181
182 // ADHOC-FIX: for wxConv* default values
183 p->Replace("wxConvAuto(wxFONTENCODING_DEFAULT)", "wxConvAuto()");
184 p->Replace("wxGet_wxConvUTF8()", "wxConvUTF8");
185 p->Replace("wxGet_wxConvLocal()", "wxConvLocal");
186 }
187
188
189 // clean ONLY the default argument string specific for comparison
190 // --------------------------------------------------------------
191
192 if (m_strDefaultValueForCmp.StartsWith("wxT(") &&
193 m_strDefaultValueForCmp.EndsWith(")"))
194 {
195 // get rid of the wxT() part
196 unsigned int len = m_strDefaultValueForCmp.Len();
197 m_strDefaultValueForCmp = m_strDefaultValueForCmp.Mid(4,len-5);
198 }
199
200 // ADHOC-FIX:
201 // doxygen likes to put wxDateTime:: in front of all wxDateTime enums;
202 // fix this to avoid false positives
203 m_strDefaultValueForCmp.Replace("wxDateTime::", "");
204 m_strDefaultValueForCmp.Replace("wxStockGDI::", ""); // same story for some other classes
205 m_strDefaultValueForCmp.Replace("wxHelpEvent::", ""); // same story for some other classes
206 m_strDefaultValueForCmp.Replace("* GetColour(COLOUR_BLACK)", "*wxBLACK");
207
208 // ADHOC-FIX:
209 if (m_strDefaultValueForCmp.Contains("wxGetTranslation"))
210 m_strDefaultValueForCmp = "_(TOFIX)"; // TODO: wxGetTranslation gives problems to gccxml
211}
212
213bool wxArgumentType::operator==(const wxArgumentType& m) const
214{
215 if ((const wxType&)(*this) != (const wxType&)m)
216 return false;
217
218 // check if the default values match
219 // ---------------------------------
220
221
222 // ADHOC-FIX:
223 // default values for style attributes of wxWindow-derived classes in gccxml appear as raw
224 // numbers; avoid false positives in this case!
225 if (m_strArgName == m.m_strArgName && m_strArgName == "style" &&
226 (m_strDefaultValueForCmp.IsNumber() || m.m_strDefaultValueForCmp.IsNumber()))
227 return true;
228
229 // fix for default values which were replaced by gcc-xml with their numeric values
230 // (at this point we know that m_strTypeClean == m.m_strTypeClean):
231 if (m_strTypeClean == "long" || m_strTypeClean == "int")
232 {
233 if ((m_strDefaultValueForCmp.IsNumber() && m.m_strDefaultValueForCmp.StartsWith("wx")) ||
234 (m.m_strDefaultValueForCmp.IsNumber() && m_strDefaultValueForCmp.StartsWith("wx")))
235 {
236 if (g_verbose)
237 {
238 wxLogMessage("Supposing '%s' default value to be the same of '%s'...",
239 m_strDefaultValueForCmp, m.m_strDefaultValueForCmp);
240 }
241
242 return true;
243 }
244 }
245 else if (m_strTypeClean == "float" || m_strTypeClean == "double")
246 // gccXML translates the default floating values in a hardly usable
247 // format; e.g. 25.2 => 2.51999999999999992894572642398998141288757324219e+1
248 // we avoid check on these...
249 return true;
250
251 if (m_strDefaultValueForCmp != m.m_strDefaultValueForCmp)
252 {
253 // maybe the default values are numbers.
254 // in this case gccXML gives as default values things like '-0x0000001' instead of just '-1'.
255 // To handle these cases, we try to convert the default value strings to numbers:
256 long def1val, def2val;
257 if (m_strDefaultValueForCmp.ToLong(&def1val, 0 /* auto-detect */) &&
258 m.m_strDefaultValueForCmp.ToLong(&def2val, 0 /* auto-detect */))
259 {
260 if (def1val == def2val)
261 return true; // the default values match
262 }
263
264 if (g_verbose)
265 {
266 wxLogMessage("Argument type '%s = %s' has different default value from '%s = %s'",
267 m_strType, m_strDefaultValueForCmp, m.m_strType, m.m_strDefaultValueForCmp);
268 }
269 return false;
270 }
271
272 // we deliberately avoid checks on the argument name
273
274 return true;
275}
276
277
278// ----------------------------------------------------------------------------
279// wxMethod
280// ----------------------------------------------------------------------------
281
282bool wxMethod::IsOk() const
283{
284 // NOTE: m_retType can be a wxEmptyType, and means that this method
285 // is a ctor or a dtor.
286 if (!m_retType.IsOk() && m_retType!=wxEmptyType) {
287 wxLogError("'%s' method has invalid return type: %s", m_retType.GetAsString());
288 return false;
289 }
290
291 if (m_strName.IsEmpty())
292 return false;
293
294 // a function can't be both const and static or virtual and static!
295 if ((m_bConst && m_bStatic) || ((m_bVirtual || m_bPureVirtual) && m_bStatic)) {
296 wxLogError("'%s' method can't be both const/static or virtual/static", m_strName);
297 return false;
298 }
299
300 wxASSERT(!m_bPureVirtual || (m_bPureVirtual && m_bVirtual));
301
302 for (unsigned int i=0; i<m_args.GetCount(); i++)
303 if (!m_args[i].IsOk()) {
304 wxLogError("'%s' method has invalid %d-th argument type: %s",
305 m_strName, i+1, m_args[i].GetAsString());
306 return false;
307 }
308
309 // NB: the default value of the arguments can contain pretty much everything
310 // (think to e.g. wxPoint(3+4/2,0) or *wxBLACK or someClass<type>)
311 // so we don't do any test on their contents
312 if (m_args.GetCount()>0)
313 {
314 bool previousArgHasDefault = m_args[0].HasDefaultValue();
315 for (unsigned int i=1; i<m_args.GetCount(); i++)
316 {
317 if (previousArgHasDefault && !m_args[i].HasDefaultValue()) {
318 wxLogError("'%s' method has %d-th argument which has no default value "
319 "(while the previous one had one!)",
320 m_strName, i+1);
321 return false;
322 }
323
324 previousArgHasDefault = m_args[i].HasDefaultValue();
325 }
326 }
327
328 return true;
329}
330
331bool wxMethod::MatchesExceptForAttributes(const wxMethod& m) const
332{
333 if (GetReturnType() != m.GetReturnType() ||
334 GetName() != m.GetName())
335 {
336 if (g_verbose)
337 {
338 wxLogMessage("The method '%s' does not match method '%s'; different names/rettype", GetName(), m.GetName());
339 }
340 return false;
341 }
342
343 if (m_args.GetCount()!=m.m_args.GetCount()) {
344 if (g_verbose)
345 {
346 wxLogMessage("Method '%s' has %d arguments while '%s' has %d arguments",
347 m_strName, m_args.GetCount(), m_strName, m.m_args.GetCount());
348 }
349 return false;
350 }
351
352 // compare argument types
353 for (unsigned int i=0; i<m_args.GetCount(); i++)
354 if (m_args[i] != m.m_args[i])
355 return false;
356
357 return true;
358}
359
360bool wxMethod::ActsAsDefaultCtor() const
361{
362 if (!IsCtor())
363 return false;
364
365 for (unsigned int i=0; i<m_args.GetCount(); i++)
366 if (!m_args[i].HasDefaultValue())
367 return false;
368
369 return true;
370}
371
372bool wxMethod::operator==(const wxMethod& m) const
373{
374 // check attributes
375 if (IsConst() != m.IsConst() ||
376 IsStatic() != m.IsStatic() ||
377 IsVirtual() != m.IsVirtual() ||
378 IsPureVirtual() != m.IsPureVirtual() ||
379 IsDeprecated() != m.IsDeprecated() ||
380 GetAccessSpecifier() != m.GetAccessSpecifier())
381 {
382 if (g_verbose)
383 {
384 wxLogMessage("The method '%s' does not match method '%s'; different attributes", GetName(), m.GetName());
385 }
386
387 return false;
388 }
389
390 // check everything else
391 return MatchesExceptForAttributes(m);
392}
393
394wxString wxMethod::GetAsString(bool bWithArgumentNames, bool bCleanDefaultValues,
395 bool bDeprecated, bool bAccessSpec) const
396{
397 wxString ret;
398
399 // NOTE: for return and argument types, never use wxType::GetAsCleanString
400 // since in that way we'd miss important decorators like &,*,const etc
401
402 if (m_retType!=wxEmptyType)
403 ret += m_retType.GetAsString() + " ";
404 //else; this is a ctor or dtor
405
406 ret += m_strName + "(";
407
408 for (unsigned int i=0; i<m_args.GetCount(); i++)
409 {
410 ret += m_args[i].GetAsString();
411
412 const wxString& name = m_args[i].GetArgumentName();
413 if (bWithArgumentNames && !name.IsEmpty())
414 ret += " " + name;
415
416 const wxString& def = bCleanDefaultValues ?
417 m_args[i].GetDefaultCleanValue() : m_args[i].GetDefaultValue();
418 if (!def.IsEmpty())
419 ret += " = " + def;
420
421 ret += ", ";
422 }
423
424 if (m_args.GetCount()>0)
425 ret = ret.Left(ret.Len()-2);
426
427 ret += ")";
428
429 if (m_bConst)
430 ret += " const";
431 if (m_bStatic)
432 ret = "static " + ret;
433 if (m_bVirtual || m_bPureVirtual)
434 ret = "virtual " + ret;
435 if (m_bPureVirtual)
436 ret += " = 0";
437 if (m_bDeprecated && bDeprecated)
438 ret += " [deprecated]";
439
440 if (bAccessSpec)
441 {
442 switch (m_access)
443 {
444 case wxMAS_PUBLIC:
445 ret += " [public]";
446 break;
447 case wxMAS_PROTECTED:
448 ret += " [protected]";
449 break;
450 case wxMAS_PRIVATE:
451 ret += " [private]";
452 break;
453 }
454 }
455
456 return ret;
457}
458
459void wxMethod::Dump(wxTextOutputStream& stream) const
460{
461 stream << "[" + m_retType.GetAsString() + "]";
462 stream << "[" + m_strName + "]";
463
464 for (unsigned int i=0; i<m_args.GetCount(); i++)
465 stream << "[" + m_args[i].GetAsString() + " " + m_args[i].GetArgumentName() +
466 "=" + m_args[i].GetDefaultValue() + "]";
467
468 if (IsConst())
469 stream << " CONST";
470 if (IsStatic())
471 stream << " STATIC";
472 if (IsVirtual())
473 stream << " VIRTUAL";
474 if (IsPureVirtual())
475 stream << " PURE-VIRTUAL";
476 if (IsDeprecated())
477 stream << " DEPRECATED";
478
479 // no final newline
480}
481
482// ----------------------------------------------------------------------------
483// wxClass
484// ----------------------------------------------------------------------------
485
486wxString wxClass::GetNameWithoutTemplate() const
487{
488 // NB: I'm not sure this is the right terminology for this function!
489
490 if (m_strName.Contains("<"))
491 return m_strName.Left(m_strName.Find("<"));
492 return m_strName;
493}
494
495bool wxClass::IsValidCtorForThisClass(const wxMethod& m) const
496{
497 // remember that e.g. the ctor for wxWritableCharTypeBuffer<wchar_t> is
498 // named wxWritableCharTypeBuffer, without the <...> part!
499
500 if (m.IsCtor() && m.GetName() == GetNameWithoutTemplate())
501 return true;
502
503 return false;
504}
505
506bool wxClass::IsValidDtorForThisClass(const wxMethod& m) const
507{
508 if (m.IsDtor() && m.GetName() == "~" + GetNameWithoutTemplate())
509 return true;
510
511 return false;
512}
513
514void wxClass::Dump(wxTextOutputStream& out) const
515{
516 out << m_strName + "\n";
517
518 for (unsigned int i=0; i<m_methods.GetCount(); i++) {
519
520 // dump all our methods
521 out << "|- ";
522 m_methods[i].Dump(out);
523 out << "\n";
524 }
525
526 out << "\n";
527}
528
529bool wxClass::CheckConsistency() const
530{
531 for (unsigned int i=0; i<m_methods.GetCount(); i++)
532 for (unsigned int j=0; j<m_methods.GetCount(); j++)
533 if (i!=j && m_methods[i] == m_methods[j])
534 {
535 wxLogError("class %s has two methods with the same prototype: '%s'",
536 m_strName, m_methods[i].GetAsString());
537 return false;
538
539 // fix the problem?
540 //((wxClass*)this)->m_methods.RemoveAt(j);
541 //j--;
542 }
543
544 return true;
545}
546
547const wxMethod* wxClass::FindMethod(const wxMethod& m) const
548{
549 for (unsigned int i=0; i<m_methods.GetCount(); i++)
550 if (m_methods[i] == m)
551 return &m_methods[i];
552 return NULL;
553}
554
555const wxMethod* wxClass::RecursiveUpwardFindMethod(const wxMethod& m,
556 const wxXmlInterface* allclasses) const
557{
558 // first, search into *this
559 const wxMethod* ret = FindMethod(m);
560 if (ret)
561 return ret;
562
563 // then, search into its parents
564 for (unsigned int i=0; i<m_parents.GetCount(); i++)
565 {
566 // ignore non-wx-classes parents
567 // AD-HOC FIX: discard wxScrolledT_Helper parent as it always gives errors
568 if (m_parents[i].StartsWith("wx") && m_parents[i] != "wxScrolledT_Helper")
569 {
570 const wxClass *parent = allclasses->FindClass(m_parents[i]);
571 if (!parent) {
572 wxLogError("Could not find parent '%s' of class '%s'...",
573 m_parents[i], GetName());
574 return false;
575 }
576
577 const wxMethod *parentMethod = parent->RecursiveUpwardFindMethod(m, allclasses);
578 if (parentMethod)
579 return parentMethod;
580 }
581 }
582
583 // could not find anything even in parent classes...
584 return NULL;
585}
586
587wxMethodPtrArray wxClass::FindMethodsNamed(const wxString& name) const
588{
589 wxMethodPtrArray ret;
590
591 for (unsigned int i=0; i<m_methods.GetCount(); i++)
592 if (m_methods[i].GetName() == name)
593 ret.Add(&m_methods[i]);
594
595 return ret;
596}
597
598
599wxMethodPtrArray wxClass::RecursiveUpwardFindMethodsNamed(const wxString& name,
600 const wxXmlInterface* allclasses) const
601{
602 // first, search into *this
603 wxMethodPtrArray ret = FindMethodsNamed(name);
604 if (ret.GetCount()>0)
605 return ret; // stop here, don't look upward in the parents
606
607 // then, search into parents of this class
608 for (unsigned int i=0; i<m_parents.GetCount(); i++)
609 {
610 // AD-HOC FIX: discard wxScrolledT_Helper parent as it always gives errors
611 if (m_parents[i].StartsWith("wx") && m_parents[i] != "wxScrolledT_Helper")
612 {
613 const wxClass *parent = allclasses->FindClass(m_parents[i]);
614 if (!parent) {
615 wxLogError("Could not find parent '%s' of class '%s'...",
616 m_parents[i], GetName());
617 return false;
618 }
619
620 wxMethodPtrArray temp = parent->RecursiveUpwardFindMethodsNamed(name, allclasses);
621 WX_APPEND_ARRAY(ret, temp);
622 }
623 }
624
625 return ret;
626}
627
628
629
630// ----------------------------------------------------------------------------
631// wxXmlInterface
632// ----------------------------------------------------------------------------
633
634WX_DEFINE_SORTED_ARRAY(wxClass*, wxSortedClassArray);
635
636int CompareWxClassObjects(wxClass *item1, wxClass *item2)
637{
638 // sort alphabetically
639 return item1->GetName().Cmp(item2->GetName());
640}
641
642void wxXmlInterface::Dump(const wxString& filename)
643{
644 wxFFileOutputStream apioutput( filename );
645 wxTextOutputStream apiout( apioutput );
646
647 // dump the classes in alphabetical order
648 wxSortedClassArray sorted(CompareWxClassObjects);
649 sorted.Alloc(m_classes.GetCount());
650
651 unsigned i;
652 for (i=0; i<m_classes.GetCount(); i++)
653 sorted.Add(&m_classes[i]);
654
655 // now they have been sorted
656 for (i=0; i<sorted.GetCount(); i++)
657 sorted[i]->Dump(apiout);
658}
659
660bool wxXmlInterface::CheckConsistency() const
661{
662 // this check can be quite slow, so do it only for debug releases:
663//#ifdef __WXDEBUG__
664 for (unsigned int i=0; i<m_classes.GetCount(); i++)
665 {
666 if (!m_classes[i].CheckConsistency())
667 return false;
668
669 for (unsigned int j=0; j<m_classes.GetCount(); j++)
670 if (i!=j && m_classes[i].GetName() == m_classes[j].GetName())
671 {
672 wxLogError("two classes have the same name: %s",
673 m_classes[i].GetName());
674 return false;
675 }
676 }
677//#endif
678
679 return true;
680}
681
682wxClassPtrArray wxXmlInterface::FindClassesDefinedIn(const wxString& headerfile) const
683{
684 wxClassPtrArray ret;
685
686 for (unsigned int i=0; i<m_classes.GetCount(); i++)
687 if (m_classes[i].GetHeader() == headerfile)
688 ret.Add(&m_classes[i]);
689
690 return ret;
691}
692
693
694// ----------------------------------------------------------------------------
695// wxXmlGccInterface helper declarations
696// ----------------------------------------------------------------------------
697
698// or-able flags for a toResolveTypeItem->attrib:
699#define ATTRIB_CONST 1
700#define ATTRIB_REFERENCE 2
701#define ATTRIB_POINTER 4
702#define ATTRIB_ARRAY 8
703
704// it may sound strange but gccxml, in order to produce shorter ID names
705// uses (after the underscore) characters in range 0-9 and a-z in the ID names;
706// in order to be able to translate such strings into numbers using strtoul()
707// we use as base 10 (possible digits) + 25 (possible characters) = 35
708#define GCCXML_BASE 35
709
710class toResolveTypeItem
711{
712public:
713 toResolveTypeItem() { attribs=0; }
714 toResolveTypeItem(unsigned int refID, unsigned int attribint)
715 : ref(refID), attribs(attribint) {}
716
717 unsigned long ref, // the referenced type's ID
718 attribs; // the attributes of this reference
719};
720
721#if 1
722
723// for wxToResolveTypeHashMap, keys == gccXML IDs and values == toResolveTypeItem
724WX_DECLARE_HASH_MAP( unsigned long, toResolveTypeItem,
725 wxIntegerHash, wxIntegerEqual,
726 wxToResolveTypeHashMap );
727
728// for wxClassMemberIdHashMap, keys == gccXML IDs and values == wxClass which owns that member ID
729WX_DECLARE_HASH_MAP( unsigned long, wxClass*,
730 wxIntegerHash, wxIntegerEqual,
731 wxClassMemberIdHashMap );
732
733#else
734#include <map>
735typedef std::map<unsigned long, toResolveTypeItem> wxToResolveTypeHashMap;
736#endif
737
738
739// utility to parse gccXML ID values;
740// this function is equivalent to wxString(str).Mid(1).ToULong(&id, GCCXML_BASE)
741// but is a little bit faster
742bool getID(unsigned long *id, const wxString& str)
743{
744 const wxStringCharType * const start = str.wx_str()+1;
745 wxStringCharType *end;
746#if wxUSE_UNICODE_WCHAR
747 unsigned long val = wcstoul(start, &end, GCCXML_BASE);
748#else
749 unsigned long val = strtoul(start, &end, GCCXML_BASE);
750#endif
751
752 // return true only if scan was stopped by the terminating NUL and
753 // if the string was not empty to start with and no under/overflow
754 // occurred:
755 if ( *end != '\0' || end == start || errno == ERANGE || errno == EINVAL )
756 return false;
757
758 *id = val;
759 return true;
760}
761
762// utility specialized to parse efficiently the gccXML list of IDs which occur
763// in nodes like <Class> ones... i.e. numeric values separated by " _" token
764bool getMemberIDs(wxClassMemberIdHashMap* map, wxClass* p, const wxString& str)
765{
766 const wxStringCharType * const start = str.wx_str();
767#if wxUSE_UNICODE_WCHAR
768 size_t len = wcslen(start);
769#else
770 size_t len = strlen(start);
771#endif
772
773 if (len == 0 || start[0] != '_')
774 return false;
775
776 const wxStringCharType *curpos = start,
777 *end = start + len;
778 wxStringCharType *nexttoken;
779
780 while (curpos < end)
781 {
782 // curpos always points to the underscore of the next token to parse:
783#if wxUSE_UNICODE_WCHAR
784 unsigned long id = wcstoul(curpos+1, &nexttoken, GCCXML_BASE);
785#else
786 unsigned long id = strtoul(curpos+1, &nexttoken, GCCXML_BASE);
787#endif
788 if ( *nexttoken != ' ' || errno == ERANGE || errno == EINVAL )
789 return false;
790
791 // advance current position
792 curpos = nexttoken + 1;
793
794 // add this ID to the hashmap
795 wxClassMemberIdHashMap::value_type v(id, p);
796 map->insert(v);
797 }
798
799 return true;
800}
801
802
803// ----------------------------------------------------------------------------
804// wxXmlGccInterface
805// ----------------------------------------------------------------------------
806
807bool wxXmlGccInterface::Parse(const wxString& filename)
808{
809 wxXmlDocument doc;
810 wxXmlNode *child;
811 int nodes = 0;
812
813 wxLogMessage("Parsing %s...", filename);
814
815 if (!doc.Load(filename)) {
816 wxLogError("can't load %s", filename);
817 return false;
818 }
819
820 // start processing the XML file
821 if (doc.GetRoot()->GetName() != "GCC_XML") {
822 wxLogError("invalid root node for %s", filename);
823 return false;
824 }
825
826 wxString version = doc.GetRoot()->GetAttribute("cvs_revision");
827 bool old = false;
828
829#define MIN_REVISION 120
830
831 if (!version.StartsWith("1."))
832 old = true;
833 if (!old)
834 {
835 unsigned long rev = 0;
836 if (!version.Mid(2).ToULong(&rev))
837 old = true;
838 else
839 if (rev < MIN_REVISION)
840 old = true;
841 }
842
843 if (old)
844 {
845 wxLogError("The version of GCC-XML used for the creation of %s is too old; "
846 "the cvs_revision attribute of the root node reports '%s', "
847 "minimal required is 1.%d.", filename, version, MIN_REVISION);
848 return false;
849 }
850
851 wxToResolveTypeHashMap toResolveTypes;
852 wxClassMemberIdHashMap members;
853 wxTypeIdHashMap types;
854 wxTypeIdHashMap files;
855 wxTypeIdHashMap typedefs;
856
857 // prealloc quite a lot of memory!
858 m_classes.Alloc(ESTIMATED_NUM_CLASSES);
859
860 // build a list of wx classes and in general of all existent types
861 child = doc.GetRoot()->GetChildren();
862 while (child)
863 {
864 const wxString& n = child->GetName();
865
866 unsigned long id = 0;
867 if (!getID(&id, child->GetAttribute("id")) || (id == 0 && n != "File")) {
868
869 // NOTE: <File> nodes can have an id == "f0"...
870
871 wxLogError("Invalid id for node %s: %s", n, child->GetAttribute("id"));
872 return false;
873 }
874
875 if (n == "Class")
876 {
877 wxString cname = child->GetAttribute("name");
878 if (cname.IsEmpty()) {
879 wxLogError("Invalid empty name for '%s' node", n);
880 return false;
881 }
882
883 // only register wx classes (do remember also the IDs of their members)
884 if (cname.StartsWith("wx"))
885 {
886 // NB: "file" attribute contains an ID value that we'll resolve later
887 m_classes.Add(wxClass(cname, child->GetAttribute("file")));
888
889 // the just-inserted class:
890 wxClass *newClass = &m_classes.Last();
891
892 // now get a list of the base classes:
893 wxXmlNode *baseNode = child->GetChildren();
894 while (baseNode)
895 {
896 // for now we store as "parents" only the parent IDs...
897 // later we will resolve them into full class names
898 if (baseNode->GetName() == "Base")
899 newClass->AddParent(baseNode->GetAttribute("type"));
900
901 baseNode = baseNode->GetNext();
902 }
903
904 const wxString& ids = child->GetAttribute("members");
905 if (ids.IsEmpty())
906 {
907 if (child->GetAttribute("incomplete") != "1") {
908 wxLogError("Invalid member IDs for '%s' class node: %s",
909 cname, child->GetAttribute("id"));
910 return false;
911 }
912 //else: don't warn the user; it looks like "incomplete" classes
913 // never have any member...
914 }
915 else
916 {
917 // decode the non-empty list of IDs:
918 if (!getMemberIDs(&members, newClass, ids)) {
919 wxLogError("Invalid member IDs for '%s' class node: %s",
920 cname, child->GetAttribute("id"));
921 return false;
922 }
923 }
924 }
925
926 // register this class also as possible return/argument type:
927 types[id] = cname;
928 }
929 else if (n == "Typedef")
930 {
931 unsigned long typeId = 0;
932 if (!getID(&typeId, child->GetAttribute("type"))) {
933 wxLogError("Invalid type for node %s: %s", n, child->GetAttribute("type"));
934 return false;
935 }
936
937 // this typedef node tell us that every type referenced with the
938 // "typeId" ID should be called with another name:
939 wxString name = child->GetAttribute("name");
940
941 // save this typedef in a separate hashmap...
942 typedefs[typeId] = name;
943
944 types[id] = name;
945 }
946 else if (n == "PointerType" || n == "ReferenceType" ||
947 n == "CvQualifiedType" || n == "ArrayType")
948 {
949 unsigned long type = 0;
950 if (!getID(&type, child->GetAttribute("type")) || type == 0) {
951 wxLogError("Invalid type for node %s: %s", n, child->GetAttribute("type"));
952 return false;
953 }
954
955 unsigned long attr = 0;
956 if (n == "PointerType")
957 attr = ATTRIB_POINTER;
958 else if (n == "ReferenceType")
959 attr = ATTRIB_REFERENCE;
960 else if (n == "CvQualifiedType" && child->GetAttribute("const") == "1")
961 attr = ATTRIB_CONST;
962 else if (n == "ArrayType")
963 attr = ATTRIB_ARRAY;
964
965 // these nodes make reference to other types... we'll resolve them later
966 toResolveTypes[id] = toResolveTypeItem(type, attr);
967 }
968 else if (n == "FunctionType" || n == "MethodType")
969 {
970 /*
971 TODO: parsing FunctionType and MethodType nodes is not as easy
972 as for other "simple" types.
973 */
974
975 wxString argstr;
976 wxXmlNode *arg = child->GetChildren();
977 while (arg)
978 {
979 if (arg->GetName() == "Argument")
980 argstr += arg->GetAttribute("type") + ", ";
981 arg = arg->GetNext();
982 }
983
984 if (argstr.Len() > 0)
985 argstr = argstr.Left(argstr.Len()-2); // remove final comma
986
987 // these nodes make reference to other types... we'll resolve them later
988 //toResolveTypes[id] = toResolveTypeItem(ret, 0);
989 //types[id] = child->GetAttribute("returns") + "(" + argstr + ")";
990
991 types[id] = "TOFIX"; // typically this type will be "fixed" thanks
992 // to a typedef later...
993 }
994 else if (n == "File")
995 {
996 if (!child->GetAttribute("id").StartsWith("f")) {
997 wxLogError("Unexpected file ID: %s", child->GetAttribute("id"));
998 return false;
999 }
1000
1001 // just ignore this node... all file IDs/names were already parsed
1002 files[id] = child->GetAttribute("name");
1003 }
1004 else
1005 {
1006 // we register everything else as a possible return/argument type:
1007 const wxString& name = child->GetAttribute("name");
1008
1009 if (!name.IsEmpty())
1010 {
1011 //typeIds.Add(id);
1012 //typeNames.Add(name);
1013 types[id] = name;
1014 }
1015 else
1016 {
1017 // this may happen with unnamed structs/union, special ctors,
1018 // or other exotic things which we are not interested to, since
1019 // they're never used as return/argument types by wxWidgets methods
1020
1021 if (g_verbose)
1022 {
1023 wxLogWarning("Type node '%s' with ID '%s' does not have name attribute",
1024 n, child->GetAttribute("id"));
1025 }
1026
1027 types[id] = "TOFIX";
1028 }
1029 }
1030
1031 child = child->GetNext();
1032
1033 // give feedback to the user about the progress...
1034 if ((++nodes%PROGRESS_RATE)==0) ShowProgress();
1035 }
1036
1037 // some nodes with IDs referenced by methods as return/argument types, do reference
1038 // in turn other nodes (see PointerType, ReferenceType and CvQualifierType above);
1039 // thus we need to resolve their name iteratively:
1040 while (toResolveTypes.size()>0)
1041 {
1042 if (g_verbose)
1043 {
1044 wxLogMessage("%d types were collected; %d types need yet to be resolved...",
1045 types.size(), toResolveTypes.size());
1046 }
1047
1048 for (wxToResolveTypeHashMap::iterator i = toResolveTypes.begin();
1049 i != toResolveTypes.end();)
1050 {
1051 unsigned long id = i->first;
1052 unsigned long referenced = i->second.ref;
1053
1054 wxTypeIdHashMap::iterator primary = types.find(referenced);
1055 if (primary != types.end())
1056 {
1057 // this to-resolve-type references a "primary" type
1058
1059 wxString newtype = primary->second;
1060 int attribs = i->second.attribs;
1061
1062 // attribs may contain a combination of ATTRIB_* flags:
1063 if (attribs & ATTRIB_CONST)
1064 newtype = "const " + newtype;
1065 if (attribs & ATTRIB_REFERENCE)
1066 newtype = newtype + "&";
1067 if (attribs & ATTRIB_POINTER)
1068 newtype = newtype + "*";
1069 if (attribs & ATTRIB_ARRAY)
1070 newtype = newtype + "[]";
1071
1072 // add the resolved type to the list of "primary" types
1073 if (newtype.Contains("TOFIX") && typedefs[id] != "")
1074 types[id] = typedefs[id]; // better use a typedef for this type!
1075 else
1076 types[id] = newtype;
1077
1078 // this one has been resolved; erase it through its iterator!
1079 toResolveTypes.erase(i);
1080
1081 // now iterator i is invalid; assign it again to the beginning
1082 i = toResolveTypes.begin();
1083 }
1084 else
1085 {
1086 // then search in the referenced types themselves:
1087 wxToResolveTypeHashMap::iterator idx2 = toResolveTypes.find(referenced);
1088 if (idx2 != toResolveTypes.end())
1089 {
1090 // merge this to-resolve-type with the idx2->second type
1091 i->second.ref = idx2->second.ref;
1092 i->second.attribs |= idx2->second.attribs;
1093
1094 // this type will eventually be solved in the next while() iteration
1095 i++;
1096 }
1097 else
1098 {
1099 wxLogError("Cannot solve '%d' reference type!", referenced);
1100 return false;
1101 }
1102 }
1103 }
1104 }
1105
1106 // resolve header names
1107 unsigned i;
1108 for (i=0; i<m_classes.GetCount(); i++)
1109 {
1110 unsigned long fileID = 0;
1111 if (!getID(&fileID, m_classes[i].GetHeader()) || fileID == 0) {
1112 wxLogError("invalid header id: %s", m_classes[i].GetHeader());
1113 return false;
1114 }
1115
1116 // search this file
1117 wxTypeIdHashMap::const_iterator idx = files.find(fileID);
1118 if (idx == files.end())
1119 {
1120 // this is an error!
1121 wxLogError("couldn't find file ID '%s'", m_classes[i].GetHeader());
1122 }
1123 else
1124 m_classes[i].SetHeader(idx->second);
1125 }
1126
1127 // resolve parent names
1128 for (i=0; i<m_classes.GetCount(); i++)
1129 {
1130 for (unsigned int k=0; k<m_classes[i].GetParentCount(); k++)
1131 {
1132 unsigned long id;
1133
1134 if (!getID(&id, m_classes[i].GetParent(k))) {
1135 wxLogError("invalid parent class ID for '%s'", m_classes[i].GetName());
1136 return false;
1137 }
1138
1139 wxTypeIdHashMap::const_iterator idx = types.find(id);
1140 if (idx == types.end())
1141 {
1142 // this is an error!
1143 wxLogError("couldn't find parent class ID '%d'", id);
1144 }
1145 else
1146 // replace k-th parent with its true name:
1147 m_classes[i].SetParent(k, idx->second);
1148 }
1149 }
1150
1151 // build the list of the wx methods
1152 child = doc.GetRoot()->GetChildren();
1153 while (child)
1154 {
1155 wxString n = child->GetName(), acc = child->GetAttribute("access");
1156
1157 // only register public&protected methods
1158 if ((acc == "public" || acc == "protected") &&
1159 (n == "Method" || n == "Constructor" || n == "Destructor" || n == "OperatorMethod"))
1160 {
1161 unsigned long id = 0;
1162 if (!getID(&id, child->GetAttribute("id"))) {
1163 wxLogError("invalid ID for node '%s' with ID '%s'", n, child->GetAttribute("id"));
1164 return false;
1165 }
1166
1167 wxClassMemberIdHashMap::const_iterator it = members.find(id);
1168 if (it != members.end())
1169 {
1170 wxClass *p = it->second;
1171
1172 // this <Method> node is a method of the i-th class!
1173 wxMethod newfunc;
1174 if (!ParseMethod(child, types, newfunc)) {
1175 wxLogError("The method '%s' could not be added to class '%s'",
1176 child->GetAttribute("demangled"), p->GetName());
1177 return false;
1178 }
1179
1180 // do some additional check that we can do only here:
1181
1182 if (newfunc.IsCtor() && !p->IsValidCtorForThisClass(newfunc)) {
1183 wxLogError("The method '%s' does not seem to be a ctor for '%s'",
1184 newfunc.GetName(), p->GetName());
1185 return false;
1186 }
1187 if (newfunc.IsDtor() && !p->IsValidDtorForThisClass(newfunc)) {
1188 wxLogError("The method '%s' does not seem to be a dtor for '%s'",
1189 newfunc.GetName(), p->GetName());
1190 return false;
1191 }
1192
1193 p->AddMethod(newfunc);
1194 }
1195 }
1196
1197 child = child->GetNext();
1198
1199 // give feedback to the user about the progress...
1200 if ((++nodes%PROGRESS_RATE)==0) ShowProgress();
1201 }
1202
1203 if (!CheckConsistency())
1204 return false; // the check failed
1205
1206 return true;
1207}
1208
1209bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p,
1210 const wxTypeIdHashMap& types,
1211 wxMethod& m)
1212{
1213 // get the real name
1214 wxString name = p->GetAttribute("name").Strip(wxString::both);
1215 if (p->GetName() == "Destructor")
1216 name = "~" + name;
1217 else if (p->GetName() == "OperatorMethod")
1218 name = "operator" + name;
1219
1220 // resolve return type
1221 wxType ret;
1222 unsigned long retid = 0;
1223 if (!getID(&retid, p->GetAttribute("returns")) || retid == 0)
1224 {
1225 if (p->GetName() != "Destructor" && p->GetName() != "Constructor") {
1226 wxLogError("Empty return ID for method '%s', with ID '%s'",
1227 name, p->GetAttribute("id"));
1228 return false;
1229 }
1230 }
1231 else
1232 {
1233 wxTypeIdHashMap::const_iterator retidx = types.find(retid);
1234 if (retidx == types.end()) {
1235 wxLogError("Could not find return type ID '%s'", retid);
1236 return false;
1237 }
1238
1239 ret = wxType(retidx->second);
1240 if (!ret.IsOk()) {
1241 wxLogError("Invalid return type '%s' for method '%s', with ID '%s'",
1242 retidx->second, name, p->GetAttribute("id"));
1243 return false;
1244 }
1245 }
1246
1247 // resolve argument types
1248 wxArgumentTypeArray argtypes;
1249 wxXmlNode *arg = p->GetChildren();
1250 while (arg)
1251 {
1252 if (arg->GetName() == "Argument")
1253 {
1254 unsigned long id = 0;
1255 if (!getID(&id, arg->GetAttribute("type")) || id == 0) {
1256 wxLogError("Invalid argument type ID '%s' for method '%s' with ID %s",
1257 arg->GetAttribute("type"), name, p->GetAttribute("id"));
1258 return false;
1259 }
1260
1261 wxTypeIdHashMap::const_iterator idx = types.find(id);
1262 if (idx == types.end()) {
1263 wxLogError("Could not find argument type ID '%s'", id);
1264 return false;
1265 }
1266
1267 argtypes.Add(wxArgumentType(idx->second,
1268 arg->GetAttribute("default"),
1269 arg->GetAttribute("name")));
1270 }
1271
1272 arg = arg->GetNext();
1273 }
1274
1275 m.SetReturnType(ret);
1276 m.SetName(name);
1277 m.SetArgumentTypes(argtypes);
1278 m.SetConst(p->GetAttribute("const") == "1");
1279 m.SetStatic(p->GetAttribute("static") == "1");
1280
1281 // NOTE: gccxml is smart enough to mark as virtual those functions
1282 // which are declared virtual in base classes but don't have
1283 // the "virtual" keyword explicitly indicated in the derived
1284 // classes... so we don't need any further logic for virtuals
1285
1286 m.SetVirtual(p->GetAttribute("virtual") == "1");
1287 m.SetPureVirtual(p->GetAttribute("pure_virtual") == "1");
1288 m.SetDeprecated(p->GetAttribute("attributes") == "deprecated");
1289
1290 // decode access specifier
1291 if (p->GetAttribute("access") == "public")
1292 m.SetAccessSpecifier(wxMAS_PUBLIC);
1293 else if (p->GetAttribute("access") == "protected")
1294 m.SetAccessSpecifier(wxMAS_PROTECTED);
1295 else if (p->GetAttribute("access") == "private")
1296 m.SetAccessSpecifier(wxMAS_PRIVATE);
1297
1298 if (!m.IsOk()) {
1299 wxLogError("The prototype '%s' is not valid!", m.GetAsString());
1300 return false;
1301 }
1302
1303 return true;
1304}
1305
1306
1307
1308// ----------------------------------------------------------------------------
1309// wxXmlDoxygenInterface global helpers
1310// ----------------------------------------------------------------------------
1311
1312static wxString GetTextFromChildren(const wxXmlNode *n)
1313{
1314 wxString text;
1315
1316 // consider the tree
1317 //
1318 // <a><b>this</b> is a <b>string</b></a>
1319 //
1320 // <a>
1321 // |- <b>
1322 // | |- this
1323 // |- is a
1324 // |- <b>
1325 // |- string
1326 //
1327 // unlike wxXmlNode::GetNodeContent() which would return " is a "
1328 // this function returns "this is a string"
1329
1330 wxXmlNode *ref = n->GetChildren();
1331 while (ref) {
1332 if (ref->GetType() == wxXML_ELEMENT_NODE)
1333 text += ref->GetNodeContent();
1334 else if (ref->GetType() == wxXML_TEXT_NODE)
1335 text += ref->GetContent();
1336 else
1337 wxLogWarning("Unexpected node type while getting text from '%s' node", n->GetName());
1338
1339 ref = ref->GetNext();
1340 }
1341
1342 return text;
1343}
1344
1345static bool HasTextNodeContaining(const wxXmlNode *parent, const wxString& name)
1346{
1347 if (!parent)
1348 return false;
1349
1350 wxXmlNode *p = parent->GetChildren();
1351 while (p)
1352 {
1353 switch (p->GetType())
1354 {
1355 case wxXML_TEXT_NODE:
1356 if (p->GetContent() == name)
1357 return true;
1358 break;
1359
1360 case wxXML_ELEMENT_NODE:
1361 // recurse into this node...
1362 if (HasTextNodeContaining(p, name))
1363 return true;
1364 break;
1365
1366 default:
1367 // skip it
1368 break;
1369 }
1370
1371 p = p->GetNext();
1372 }
1373
1374 return false;
1375}
1376
1377static const wxXmlNode* FindNodeNamed(const wxXmlNode* parent, const wxString& name)
1378{
1379 if (!parent)
1380 return NULL;
1381
1382 const wxXmlNode *p = parent->GetChildren();
1383 while (p)
1384 {
1385 if (p->GetName() == name)
1386 return p; // found!
1387
1388 // search recursively in the children of this node
1389 const wxXmlNode *ret = FindNodeNamed(p, name);
1390 if (ret)
1391 return ret;
1392
1393 p = p->GetNext();
1394 }
1395
1396 return NULL;
1397}
1398
1399int GetAvailabilityFor(const wxXmlNode *node)
1400{
1401 // identify <onlyfor> custom XML tags
1402 const wxXmlNode* onlyfor = FindNodeNamed(node, "onlyfor");
1403 if (!onlyfor)
1404 return wxPORT_UNKNOWN;
1405
1406 wxArrayString ports = wxSplit(onlyfor->GetNodeContent(), ',');
1407 int nAvail = wxPORT_UNKNOWN;
1408 for (unsigned int i=0; i < ports.GetCount(); i++)
1409 {
1410 if (!ports[i].StartsWith("wx")) {
1411 wxLogError("unexpected port ID '%s'", ports[i]);
1412 return false;
1413 }
1414
1415 nAvail |= wxPlatformInfo::GetPortId(ports[i].Mid(2));
1416 }
1417
1418 return nAvail;
1419}
1420
1421
1422// ----------------------------------------------------------------------------
1423// wxXmlDoxygenInterface
1424// ----------------------------------------------------------------------------
1425
1426bool wxXmlDoxygenInterface::Parse(const wxString& filename)
1427{
1428 wxXmlDocument index;
1429 wxXmlNode *compound;
1430
1431 wxLogMessage("Parsing %s...", filename);
1432
1433 if (!index.Load(filename)) {
1434 wxLogError("can't load %s", filename);
1435 return false;
1436 }
1437
1438 // start processing the index:
1439 if (index.GetRoot()->GetName() != "doxygenindex") {
1440 wxLogError("invalid root node for %s", filename);
1441 return false;
1442 }
1443
1444 /*
1445 NB: we may need in future to do a version-check here if the
1446 format of the XML generated by doxygen changes.
1447 For now (doxygen version 1.5.5), this check is not required
1448 since AFAIK the XML format never changed since it was introduced.
1449 */
1450
1451 m_classes.Alloc(ESTIMATED_NUM_CLASSES);
1452
1453 // process files referenced by this index file
1454 compound = index.GetRoot()->GetChildren();
1455 while (compound)
1456 {
1457 if (compound->GetName() == "compound" &&
1458 compound->GetAttribute("kind") == "class")
1459 {
1460 wxString refid = compound->GetAttribute("refid");
1461
1462 wxFileName fn(filename);
1463 if (!ParseCompoundDefinition(fn.GetPath(wxPATH_GET_SEPARATOR) + refid + ".xml"))
1464 return false;
1465 }
1466
1467 compound = compound->GetNext();
1468 }
1469 //wxPrint("\n");
1470
1471 if (!CheckConsistency())
1472 return false; // the check failed
1473
1474 return true;
1475}
1476
1477bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename)
1478{
1479 wxClassMemberIdHashMap parents;
1480 wxXmlDocument doc;
1481 wxXmlNode *child;
1482 int nodes = 0;
1483
1484 if (g_verbose)
1485 {
1486 wxLogMessage("Parsing %s...", filename);
1487 }
1488
1489 if (!doc.Load(filename)) {
1490 wxLogError("can't load %s", filename);
1491 return false;
1492 }
1493
1494 // start processing this compound definition XML
1495 if (doc.GetRoot()->GetName() != "doxygen") {
1496 wxLogError("invalid root node for %s", filename);
1497 return false;
1498 }
1499
1500 // build a list of wx classes
1501 child = doc.GetRoot()->GetChildren();
1502 while (child)
1503 {
1504 if (child->GetName() == "compounddef" &&
1505 child->GetAttribute("kind") == "class")
1506 {
1507 // parse this class
1508 wxClass klass;
1509 wxString absoluteFile, header;
1510
1511 wxXmlNode *subchild = child->GetChildren();
1512 while (subchild)
1513 {
1514 // NOTE: when documenting functions using the //@{ and //@}
1515 // tags to create function groups, doxygen puts the
1516 // contained methods into a "user-defined" section
1517 // so we _must_ use the "prot" attribute to distinguish
1518 // public/protected methods from private ones and cannot
1519 // rely on the kind="public" attribute of <sectiondef>
1520 if (subchild->GetName() == "sectiondef")
1521 {
1522 wxXmlNode *membernode = subchild->GetChildren();
1523 while (membernode)
1524 {
1525 const wxString& accessSpec = membernode->GetAttribute("prot");
1526
1527 // parse only public&protected functions:
1528 if (membernode->GetName() == "memberdef" &&
1529 membernode->GetAttribute("kind") == "function" &&
1530 (accessSpec == "public" || accessSpec == "protected"))
1531 {
1532 wxMethod m;
1533 if (!ParseMethod(membernode, m, header)) {
1534 wxLogError("The method '%s' could not be added to class '%s'",
1535 m.GetName(), klass.GetName());
1536 return false;
1537 }
1538
1539 if (accessSpec == "public")
1540 m.SetAccessSpecifier(wxMAS_PUBLIC);
1541 else if (accessSpec == "protected")
1542 m.SetAccessSpecifier(wxMAS_PROTECTED);
1543 else if (accessSpec == "private")
1544 m.SetAccessSpecifier(wxMAS_PRIVATE);
1545
1546 if (absoluteFile.IsEmpty())
1547 absoluteFile = header;
1548 else if (header != absoluteFile)
1549 {
1550 wxLogError("Found inconsistency in the XML file '%s': "
1551 "the method '%s' is documented in the "
1552 "file '%s' but the other methods of the same "
1553 "class are documented in the file '%s'",
1554 filename, m.GetName(), header, absoluteFile);
1555 return false;
1556 }
1557
1558 klass.AddMethod(m);
1559 }
1560
1561 membernode = membernode->GetNext();
1562 }
1563
1564 // all methods of this class were taken from the header "absoluteFile":
1565 klass.SetHeader(absoluteFile);
1566 }
1567 else if (subchild->GetName() == "compoundname")
1568 {
1569 klass.SetName(subchild->GetNodeContent());
1570 }
1571 /*else if (subchild->GetName() == "includes")
1572 {
1573 // NOTE: we'll get the header from the <location> tags
1574 // scattered inside <memberdef> tags instead of
1575 // this <includes> tag since it does not contain
1576 // the absolute path of the header
1577
1578 klass.SetHeader(subchild->GetNodeContent());
1579 }*/
1580 else if (subchild->GetName() == "detaileddescription")
1581 {
1582 // identify <onlyfor> custom XML tags
1583 klass.SetAvailability(GetAvailabilityFor(subchild));
1584 }
1585 else if (subchild->GetName() == "basecompoundref")
1586 {
1587 // add the name of this parent to the list of klass' parents
1588 klass.AddParent(subchild->GetNodeContent());
1589 }
1590
1591 subchild = subchild->GetNext();
1592 }
1593
1594 // add a new class
1595 if (klass.IsOk())
1596 {
1597 m_classes.Add(klass);
1598 }
1599 else if (g_verbose)
1600 {
1601 wxLogWarning("discarding class '%s' with %d methods...",
1602 klass.GetName(), klass.GetMethodCount());
1603 }
1604 }
1605
1606 child = child->GetNext();
1607
1608 // give feedback to the user about the progress...
1609 if ((++nodes%PROGRESS_RATE)==0) ShowProgress();
1610 }
1611
1612 return true;
1613}
1614
1615bool wxXmlDoxygenInterface::ParseMethod(const wxXmlNode* p, wxMethod& m, wxString& header)
1616{
1617 wxArgumentTypeArray args;
1618 long line;
1619
1620 wxXmlNode *child = p->GetChildren();
1621 while (child)
1622 {
1623 if (child->GetName() == "name")
1624 m.SetName(child->GetNodeContent());
1625 else if (child->GetName() == "type")
1626 m.SetReturnType(wxType(GetTextFromChildren(child)));
1627 else if (child->GetName() == "param")
1628 {
1629 wxString typestr, namestr, defstr, arrstr;
1630 wxXmlNode *n = child->GetChildren();
1631 while (n)
1632 {
1633 if (n->GetName() == "type")
1634 // if the <type> node has children, they should be all TEXT and <ref> nodes
1635 // and we need to take the text they contain, in the order they appear
1636 typestr = GetTextFromChildren(n);
1637 else if (n->GetName() == "declname")
1638 namestr = GetTextFromChildren(n);
1639 else if (n->GetName() == "defval")
1640 defstr = GetTextFromChildren(n).Strip(wxString::both);
1641 else if (n->GetName() == "array")
1642 arrstr = GetTextFromChildren(n);
1643
1644 n = n->GetNext();
1645 }
1646
1647 if (typestr.IsEmpty()) {
1648 wxLogError("cannot find type node for a param in method '%s'", m.GetName());
1649 return false;
1650 }
1651
1652 wxArgumentType newarg(typestr + arrstr, defstr, namestr);
1653
1654 // can we use preprocessor output to transform the default value
1655 // into the same form which gets processed by wxXmlGccInterface?
1656 wxStringHashMap::const_iterator it = m_preproc.find(defstr);
1657 if (it != m_preproc.end())
1658 newarg.SetDefaultValue(defstr, it->second);
1659
1660 args.Add(newarg);
1661 }
1662 else if (child->GetName() == "location")
1663 {
1664 line = -1;
1665 if (child->GetAttribute("line").ToLong(&line))
1666 m.SetLocation((int)line);
1667 header = child->GetAttribute("file");
1668 }
1669 else if (child->GetName() == "detaileddescription")
1670 {
1671 // when a method has a @deprecated tag inside its description,
1672 // Doxygen outputs somewhere nested inside <detaileddescription>
1673 // a <xreftitle>Deprecated</xreftitle> tag.
1674 m.SetDeprecated(HasTextNodeContaining(child, "Deprecated"));
1675
1676 // identify <onlyfor> custom XML tags
1677 m.SetAvailability(GetAvailabilityFor(child));
1678 }
1679
1680 child = child->GetNext();
1681 }
1682
1683 m.SetArgumentTypes(args);
1684 m.SetConst(p->GetAttribute("const")=="yes");
1685 m.SetStatic(p->GetAttribute("static")=="yes");
1686
1687 // NOTE: Doxygen is smart enough to mark as virtual those functions
1688 // which are declared virtual in base classes but don't have
1689 // the "virtual" keyword explicitly indicated in the derived
1690 // classes... so we don't need any further logic for virtuals
1691
1692 m.SetVirtual(p->GetAttribute("virt")=="virtual");
1693 m.SetPureVirtual(p->GetAttribute("virt")=="pure-virtual");
1694
1695 if (!m.IsOk()) {
1696 wxLogError("The prototype '%s' is not valid!", m.GetAsString());
1697 return false;
1698 }
1699
1700 return true;
1701}
wxWidgets (Impactor)