1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: Parser of the API/interface XML files
4 // Author: Francesco Montorsi
7 // Copyright: (c) 2008 Francesco Montorsi
8 // Licence: wxWindows licence
9 /////////////////////////////////////////////////////////////////////////////
15 #include <wx/txtstrm.h>
16 #include <wx/dynarray.h>
17 #include <wx/xml/xml.h>
18 #include <wx/platinfo.h>
25 Any fix aimed to reduce "false positives" which involves
26 references to a specific wxWidgets class is marked in
27 ifacecheck sources with the string:
36 #define LogMessage(fmt, ...) { if (g_bLogEnabled) { wxPrintf(fmt "\n", __VA_ARGS__); fflush(stdout); }}
37 #define LogWarning(fmt, ...) { if (g_bLogEnabled) { wxPrintf(fmt "\n", __VA_ARGS__); fflush(stdout); }}
38 #define LogError(fmt, ...) { if (g_bLogEnabled) { wxPrintf("ERROR: " fmt "\n", __VA_ARGS__); fflush(stdout); }}
39 #define wxPrint(str) { wxPrintf(str); fflush(stdout); }
41 // enable/disable logging
42 extern bool g_bLogEnabled
;
47 LogNull() { g_bLogEnabled
= false; }
48 ~LogNull() { g_bLogEnabled
= true; }
53 // ----------------------------------------------------------------------------
54 // Represents a type with or without const/static/ qualifier
55 // and with or without & and * operators
56 // ----------------------------------------------------------------------------
61 wxType(const wxString
& type
)
62 { SetTypeFromString(type
); }
64 void SetTypeFromString(const wxString
& t
);
65 wxString
GetAsString() const
68 // returns this type _without_ any decoration,
69 // including the & (which indicates this is a reference),
70 // the * (which indicates this is a pointer), etc.
71 wxString
GetAsCleanString() const
72 { return m_strTypeClean
; }
75 { return m_strType
.Contains("const"); }
77 { return m_strType
.Contains("static"); }
78 bool IsPointer() const
79 { return m_strType
.Contains("*"); }
80 bool IsReference() const
81 { return m_strType
.Contains("&"); }
83 bool operator==(const wxType
& m
) const;
84 bool operator!=(const wxType
& m
) const
85 { return !(*this == m
); }
91 m_strTypeClean
; // m_strType "cleaned" of its attributes
92 // (only for internal use)
95 extern wxType wxEmptyType
;
96 WX_DECLARE_OBJARRAY(wxType
, wxTypeArray
);
99 // ----------------------------------------------------------------------------
100 // Represents a type used as argument for some wxMethod
101 // ----------------------------------------------------------------------------
102 class wxArgumentType
: public wxType
106 wxArgumentType(const wxString
& type
, const wxString
& defVal
,
107 const wxString
& argName
= wxEmptyString
)
108 { SetTypeFromString(type
); SetDefaultValue(defVal
); m_strArgName
= argName
; }
110 void SetArgumentName(const wxString
& name
)
111 { m_strArgName
=name
.Strip(wxString::both
); }
112 wxString
GetArgumentName() const
113 { return m_strArgName
; }
115 void SetDefaultValue(const wxString
& defval
,
116 const wxString
& defvalForCmp
= wxEmptyString
);
117 wxString
GetDefaultValue() const
118 { return m_strDefaultValue
; }
120 // returns the default value used for comparisons
121 wxString
GetDefaultCleanValue() const
122 { return m_strDefaultValueForCmp
; }
124 bool HasDefaultValue() const
125 { return !m_strDefaultValue
.IsEmpty(); }
127 bool operator==(const wxArgumentType
& m
) const;
128 bool operator!=(const wxArgumentType
& m
) const
129 { return !(*this == m
); }
132 wxString m_strDefaultValue
;
134 // this string may differ from m_strDefaultValue if there were
135 // preprocessor substitutions or other "replacements" done to
136 // avoid false errors.
137 wxString m_strDefaultValueForCmp
;
140 wxString m_strArgName
;
143 extern wxArgumentType wxEmptyArgumentType
;
144 WX_DECLARE_OBJARRAY(wxArgumentType
, wxArgumentTypeArray
);
147 // ----------------------------------------------------------------------------
148 // Represents a single prototype of a class' member.
149 // ----------------------------------------------------------------------------
154 { m_bConst
=m_bVirtual
=m_bPureVirtual
=m_bStatic
=m_bDeprecated
=false;
155 m_nLine
=-1; m_nAvailability
=wxPORT_UNKNOWN
; }
157 wxMethod(const wxType
& rettype
, const wxString
& name
,
158 const wxArgumentTypeArray
& arguments
,
159 bool isConst
, bool isStatic
, bool isVirtual
)
160 : m_retType(rettype
), m_strName(name
.Strip(wxString::both
)),
161 m_bConst(isConst
), m_bStatic(isStatic
), m_bVirtual(isVirtual
)
162 { SetArgumentTypes(arguments
); m_nLine
=-1; }
167 // bWithArgumentNames = output argument names?
168 // bClean = output type names or type _clean_ names (see wxType::GetAsCleanString)
169 // bDeprecated = output [deprecated] next to deprecated methods?
170 wxString
GetAsString(bool bWithArgumentNames
= true,
172 bool bDeprecated
= false) const;
174 // parser of the prototype:
175 // all these functions return strings with spaces stripped
176 wxType
GetReturnType() const
177 { return m_retType
; }
178 wxString
GetName() const
179 { return m_strName
; }
180 wxArgumentTypeArray
GetArgumentTypes() const
182 int GetLocation() const
184 int GetAvailability() const
185 { return m_nAvailability
; }
189 bool IsStatic() const
190 { return m_bStatic
; }
191 bool IsVirtual() const
192 { return m_bVirtual
; }
193 bool IsPureVirtual() const
194 { return m_bPureVirtual
; }
198 { return m_retType
==wxEmptyType
&& !m_strName
.StartsWith("~"); }
200 { return m_retType
==wxEmptyType
&& m_strName
.StartsWith("~"); }
202 bool IsDeprecated() const
203 { return m_bDeprecated
; }
208 void SetReturnType(const wxType
& t
)
210 void SetName(const wxString
& name
)
212 void SetArgumentTypes(const wxArgumentTypeArray
& arr
)
214 void SetConst(bool c
= true)
216 void SetStatic(bool c
= true)
218 void SetVirtual(bool c
= true)
220 void SetPureVirtual(bool c
= true)
223 if (c
) m_bVirtual
=c
; // pure virtual => virtual
225 void SetDeprecated(bool c
= true)
227 void SetLocation(int lineNumber
)
228 { m_nLine
=lineNumber
; }
229 void SetAvailability(int nAvail
)
230 { m_nAvailability
=nAvail
; }
234 bool operator==(const wxMethod
&) const;
235 bool operator!=(const wxMethod
& m
) const
236 { return !(*this == m
); }
238 // this function works like operator== but tests everything:
242 // except for the method attributes (const,static,virtual,pureVirtual,deprecated)
243 bool MatchesExceptForAttributes(const wxMethod
& m
) const;
245 void Dump(wxTextOutputStream
& stream
) const;
250 wxArgumentTypeArray m_args
;
259 // m_nLine can be -1 if no location infos are available
262 // this is a combination of wxPORT_* flags (see wxPortId) or wxPORT_UNKNOWN
263 // if this method should be available for all wxWidgets ports.
264 // NOTE: this is not used for comparing wxMethod objects
265 // (gccXML never gives this kind of info).
269 WX_DECLARE_OBJARRAY(wxMethod
, wxMethodArray
);
270 WX_DEFINE_ARRAY(const wxMethod
*, wxMethodPtrArray
);
273 // ----------------------------------------------------------------------------
274 // Represents a class of the wx API/interface.
275 // ----------------------------------------------------------------------------
280 wxClass(const wxString
& name
, const wxString
& headername
)
281 : m_strName(name
), m_strHeader(headername
) {}
286 void SetHeader(const wxString
& header
)
287 { m_strHeader
=header
; }
288 void SetName(const wxString
& name
)
290 void SetAvailability(int nAvail
)
291 { m_nAvailability
=nAvail
; }
297 { return !m_strName
.IsEmpty() && !m_methods
.IsEmpty(); }
299 bool IsValidCtorForThisClass(const wxMethod
& m
) const;
300 bool IsValidDtorForThisClass(const wxMethod
& m
) const;
302 wxString
GetName() const
303 { return m_strName
; }
304 wxString
GetHeader() const
305 { return m_strHeader
; }
306 wxString
GetNameWithoutTemplate() const;
308 unsigned int GetMethodCount() const
309 { return m_methods
.GetCount(); }
310 wxMethod
& GetMethod(unsigned int n
) const
311 { return m_methods
[n
]; }
312 wxMethod
& GetLastMethod() const
313 { return m_methods
.Last(); }
315 int GetAvailability() const
316 { return m_nAvailability
; }
320 void AddMethod(const wxMethod
& func
)
321 { m_methods
.Add(func
); }
323 // returns a single result (the first, which is also the only
324 // one if CheckConsistency() return true)
325 const wxMethod
* FindMethod(const wxMethod
& m
) const;
327 // returns an array of pointers to the overloaded methods with the
329 wxMethodPtrArray
FindMethodsNamed(const wxString
& m
) const;
331 // dumps all methods to the given output stream
332 void Dump(wxTextOutputStream
& stream
) const;
335 bool CheckConsistency() const;
339 wxString m_strHeader
;
340 wxMethodArray m_methods
;
342 // see the wxMethod::m_nAvailability field for more info
346 WX_DECLARE_OBJARRAY(wxClass
, wxClassArray
);
347 WX_DEFINE_ARRAY(const wxClass
*, wxClassPtrArray
);
351 // ----------------------------------------------------------------------------
353 // ----------------------------------------------------------------------------
359 const wxClass
* FindClass(const wxString
& classname
) const
361 for (unsigned int i
=0; i
<m_classes
.GetCount(); i
++)
362 if (m_classes
[i
].GetName() == classname
)
363 return &m_classes
[i
];
367 void Dump(const wxString
& filename
);
369 const wxClassArray
& GetClasses() const
370 { return m_classes
; }
372 unsigned int GetClassesCount() const
373 { return m_classes
.GetCount(); }
375 unsigned int GetMethodCount() const
377 unsigned int methods
= 0;
378 for (unsigned i
=0; i
< m_classes
.GetCount(); i
++)
379 methods
+= m_classes
[i
].GetMethodCount();
383 // pass a full-path header filename:
384 wxClassPtrArray
FindClassesDefinedIn(const wxString
& headerfile
) const;
387 { /*wxPrint(".");*/ }
389 bool CheckParseResults() const;
392 wxClassArray m_classes
;
396 // for wxTypeIdHashMap, keys == gccxml IDs and values == associated type strings
397 // e.g. key = "0x123f" and value = "const wxAboutDialogInfo&"
398 WX_DECLARE_HASH_MAP( unsigned long, wxString
,
399 wxIntegerHash
, wxIntegerEqual
,
402 WX_DECLARE_STRING_HASH_MAP( wxString
, wxStringHashMap
);
405 typedef std::basic_string
<char> stlString
;
406 typedef std::map
<unsigned long, stlString
> wxTypeIdHashMap
;
410 // ----------------------------------------------------------------------------
411 // Represents the real interface of wxWidgets
412 // Loads it from the XML produced by gccXML: http://www.gccxml.org
413 // ----------------------------------------------------------------------------
414 class wxXmlGccInterface
: public wxXmlInterface
419 // FIXME: we should retrieve this from the XML file!
420 // here we suppose the XML was created for the currently-running port
421 m_portId
= wxPlatformInfo::Get().GetPortId();
424 bool Parse(const wxString
& filename
);
425 bool ParseMethod(const wxXmlNode
*p
,
426 const wxTypeIdHashMap
& types
,
429 wxPortId
GetInterfacePort() const
432 wxString
GetInterfacePortName() const
433 { return wxPlatformInfo::GetPortIdName(m_portId
, false); }
436 // the port for which the gcc XML was generated
441 // ----------------------------------------------------------------------------
442 // Represents the interface of the doxygen headers of wxWidgets
443 // Loads it from the XML produced by Doxygen: http://www.doxygen.org
444 // ----------------------------------------------------------------------------
445 class wxXmlDoxygenInterface
: public wxXmlInterface
448 wxXmlDoxygenInterface() {}
451 // Using wxXmlDocument::Load as is, the entire XML file is parsed
452 // and an entire tree of wxXmlNodes is built in memory.
453 // We need however only small portions of the Doxygen-generated XML: to speedup the
454 // processing we could detach the expat callbacks when we detect the beginning of a
455 // node we're not interested about, or just don't create a wxXmlNode for it!
456 // This needs a modification of wxXml API.
458 bool Parse(const wxString
& filename
);
459 bool ParseCompoundDefinition(const wxString
& filename
);
460 bool ParseMethod(const wxXmlNode
*, wxMethod
&, wxString
& header
);
462 // this class can take advantage of the preprocessor output to give
463 // a minor number of false positive warnings in the final comparison
464 void AddPreprocessorValue(const wxString
& name
, const wxString
& val
)
465 { m_preproc
[name
]=val
; }
468 wxStringHashMap m_preproc
;
473 #endif // _XMLPARSER_H_