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 enum wxMethodAccessSpecifier
154 // ----------------------------------------------------------------------------
155 // Represents a single prototype of a class' member.
156 // ----------------------------------------------------------------------------
161 { m_bConst
=m_bVirtual
=m_bPureVirtual
=m_bStatic
=m_bDeprecated
=false;
162 m_nLine
=-1; m_nAvailability
=wxPORT_UNKNOWN
; m_access
=wxMAS_PUBLIC
; }
164 wxMethod(const wxType
& rettype
, const wxString
& name
,
165 const wxArgumentTypeArray
& arguments
,
166 bool isConst
, bool isStatic
, bool isVirtual
)
167 : m_retType(rettype
), m_strName(name
.Strip(wxString::both
)),
168 m_bConst(isConst
), m_bStatic(isStatic
), m_bVirtual(isVirtual
)
169 { SetArgumentTypes(arguments
); m_nLine
=-1; }
174 // bWithArgumentNames = output argument names?
175 // bCleanDefaultValues = output clean argument default values?
176 // bDeprecated = output [deprecated] next to deprecated methods?
177 // bAccessSpec = output [public], [protected] or [private] next to method?
179 // TODO: convert to readable flags this set of bools
180 wxString
GetAsString(bool bWithArgumentNames
= true,
181 bool bCleanDefaultValues
= false,
182 bool bDeprecated
= false,
183 bool bAccessSpec
= false) const;
185 // parser of the prototype:
186 // all these functions return strings with spaces stripped
187 wxType
GetReturnType() const
188 { return m_retType
; }
189 wxString
GetName() const
190 { return m_strName
; }
191 wxArgumentTypeArray
GetArgumentTypes() const
193 int GetLocation() const
195 int GetAvailability() const
196 { return m_nAvailability
; }
197 wxMethodAccessSpecifier
GetAccessSpecifier() const
202 bool IsStatic() const
203 { return m_bStatic
; }
204 bool IsVirtual() const
205 { return m_bVirtual
; }
206 bool IsPureVirtual() const
207 { return m_bPureVirtual
; }
211 { return m_retType
==wxEmptyType
&& !m_strName
.StartsWith("~"); }
213 { return m_retType
==wxEmptyType
&& m_strName
.StartsWith("~"); }
215 bool IsDeprecated() const
216 { return m_bDeprecated
; }
221 void SetReturnType(const wxType
& t
)
223 void SetName(const wxString
& name
)
225 void SetArgumentTypes(const wxArgumentTypeArray
& arr
)
227 void SetConst(bool c
= true)
229 void SetStatic(bool c
= true)
231 void SetVirtual(bool c
= true)
233 void SetPureVirtual(bool c
= true)
236 if (c
) m_bVirtual
=c
; // pure virtual => virtual
238 void SetDeprecated(bool c
= true)
240 void SetLocation(int lineNumber
)
241 { m_nLine
=lineNumber
; }
242 void SetAvailability(int nAvail
)
243 { m_nAvailability
=nAvail
; }
244 void SetAccessSpecifier(wxMethodAccessSpecifier spec
)
249 bool operator==(const wxMethod
&) const;
250 bool operator!=(const wxMethod
& m
) const
251 { return !(*this == m
); }
253 // this function works like operator== but tests everything:
257 // except for the method attributes (const,static,virtual,pureVirtual,deprecated)
258 bool MatchesExceptForAttributes(const wxMethod
& m
) const;
260 void Dump(wxTextOutputStream
& stream
) const;
265 wxArgumentTypeArray m_args
;
274 // m_nLine can be -1 if no location infos are available
277 // this is a combination of wxPORT_* flags (see wxPortId) or wxPORT_UNKNOWN
278 // if this method should be available for all wxWidgets ports.
279 // NOTE: this is not used for comparing wxMethod objects
280 // (gccXML never gives this kind of info).
283 // the access specifier for this method
284 wxMethodAccessSpecifier m_access
;
287 WX_DECLARE_OBJARRAY(wxMethod
, wxMethodArray
);
288 WX_DEFINE_ARRAY(const wxMethod
*, wxMethodPtrArray
);
291 // we need wxClassPtrArray to be defined _before_ wxClass itself,
292 // since wxClass uses wxClassPtrArray.
294 WX_DEFINE_ARRAY(const wxClass
*, wxClassPtrArray
);
296 class wxXmlInterface
;
299 // ----------------------------------------------------------------------------
300 // Represents a class of the wx API/interface.
301 // ----------------------------------------------------------------------------
306 wxClass(const wxString
& name
, const wxString
& headername
)
307 : m_strName(name
), m_strHeader(headername
) {}
312 void SetHeader(const wxString
& header
)
313 { m_strHeader
=header
; }
314 void SetName(const wxString
& name
)
316 void SetAvailability(int nAvail
)
317 { m_nAvailability
=nAvail
; }
318 void SetParent(unsigned int k
, const wxString
& name
)
319 { m_parents
[k
]=name
; }
324 { return !m_strName
.IsEmpty() && !m_methods
.IsEmpty(); }
326 bool IsValidCtorForThisClass(const wxMethod
& m
) const;
327 bool IsValidDtorForThisClass(const wxMethod
& m
) const;
329 wxString
GetName() const
330 { return m_strName
; }
331 wxString
GetHeader() const
332 { return m_strHeader
; }
333 wxString
GetNameWithoutTemplate() const;
335 unsigned int GetMethodCount() const
336 { return m_methods
.GetCount(); }
337 wxMethod
& GetMethod(unsigned int n
) const
338 { return m_methods
[n
]; }
339 wxMethod
& GetLastMethod() const
340 { return m_methods
.Last(); }
342 int GetAvailability() const
343 { return m_nAvailability
; }
345 //const wxClass *GetParent(unsigned int i) const
346 const wxString
& GetParent(unsigned int i
) const
347 { return m_parents
[i
]; }
348 unsigned int GetParentCount() const
349 { return m_parents
.GetCount(); }
353 void AddMethod(const wxMethod
& func
)
354 { m_methods
.Add(func
); }
356 void AddParent(const wxString
& parent
)//wxClass* parent)
357 { m_parents
.Add(parent
); }
359 // returns a single result (the first, which is also the only
360 // one if CheckConsistency() return true)
361 const wxMethod
* FindMethod(const wxMethod
& m
) const;
363 // like FindMethod() but this one searches also recursively in
364 // the parents of this class.
365 const wxMethod
* RecursiveUpwardFindMethod(const wxMethod
& m
,
366 const wxXmlInterface
* allclasses
) const;
368 // returns an array of pointers to the overloaded methods with the
370 wxMethodPtrArray
FindMethodsNamed(const wxString
& name
) const;
372 // like FindMethodsNamed() but this one searches also recursively in
373 // the parents of this class.
374 wxMethodPtrArray
RecursiveUpwardFindMethodsNamed(const wxString
& name
,
375 const wxXmlInterface
* allclasses
) const;
377 // dumps all methods to the given output stream
378 void Dump(wxTextOutputStream
& stream
) const;
381 bool CheckConsistency() const;
385 wxString m_strHeader
;
386 wxMethodArray m_methods
;
388 // name of the base classes: we store the names and not the pointers
389 // because this makes _much_ easier the parsing process!
390 // (basically because when parsing class X which derives from Y,
391 // we may have not parsed yet class Y!)
392 wxArrayString m_parents
;
394 // see the wxMethod::m_nAvailability field for more info
398 WX_DECLARE_OBJARRAY(wxClass
, wxClassArray
);
402 // ----------------------------------------------------------------------------
404 // ----------------------------------------------------------------------------
410 const wxClass
* FindClass(const wxString
& classname
) const
412 for (unsigned int i
=0; i
<m_classes
.GetCount(); i
++)
413 if (m_classes
[i
].GetName() == classname
)
414 return &m_classes
[i
];
418 void Dump(const wxString
& filename
);
420 const wxClassArray
& GetClasses() const
421 { return m_classes
; }
423 unsigned int GetClassesCount() const
424 { return m_classes
.GetCount(); }
426 unsigned int GetMethodCount() const
428 unsigned int methods
= 0;
429 for (unsigned i
=0; i
< m_classes
.GetCount(); i
++)
430 methods
+= m_classes
[i
].GetMethodCount();
434 // pass a full-path header filename:
435 wxClassPtrArray
FindClassesDefinedIn(const wxString
& headerfile
) const;
438 { /*wxPrint(".");*/ }
440 bool CheckParseResults() const;
443 wxClassArray m_classes
;
447 // for wxTypeIdHashMap, keys == gccxml IDs and values == associated type strings
448 // e.g. key = "0x123f" and value = "const wxAboutDialogInfo&"
449 WX_DECLARE_HASH_MAP( unsigned long, wxString
,
450 wxIntegerHash
, wxIntegerEqual
,
453 WX_DECLARE_STRING_HASH_MAP( wxString
, wxStringHashMap
);
456 typedef std::basic_string
<char> stlString
;
457 typedef std::map
<unsigned long, stlString
> wxTypeIdHashMap
;
461 // ----------------------------------------------------------------------------
462 // Represents the real interface of wxWidgets
463 // Loads it from the XML produced by gccXML: http://www.gccxml.org
464 // ----------------------------------------------------------------------------
465 class wxXmlGccInterface
: public wxXmlInterface
470 // FIXME: we should retrieve this from the XML file!
471 // here we suppose the XML was created for the currently-running port
472 m_portId
= wxPlatformInfo::Get().GetPortId();
475 bool Parse(const wxString
& filename
);
476 bool ParseMethod(const wxXmlNode
*p
,
477 const wxTypeIdHashMap
& types
,
480 wxPortId
GetInterfacePort() const
483 wxString
GetInterfacePortName() const
484 { return wxPlatformInfo::GetPortIdName(m_portId
, false); }
487 // the port for which the gcc XML was generated
492 // ----------------------------------------------------------------------------
493 // Represents the interface of the doxygen headers of wxWidgets
494 // Loads it from the XML produced by Doxygen: http://www.doxygen.org
495 // ----------------------------------------------------------------------------
496 class wxXmlDoxygenInterface
: public wxXmlInterface
499 wxXmlDoxygenInterface() {}
502 // Using wxXmlDocument::Load as is, the entire XML file is parsed
503 // and an entire tree of wxXmlNodes is built in memory.
504 // We need however only small portions of the Doxygen-generated XML: to speedup the
505 // processing we could detach the expat callbacks when we detect the beginning of a
506 // node we're not interested about, or just don't create a wxXmlNode for it!
507 // This needs a modification of wxXml API.
509 bool Parse(const wxString
& filename
);
510 bool ParseCompoundDefinition(const wxString
& filename
);
511 bool ParseMethod(const wxXmlNode
*, wxMethod
&, wxString
& header
);
513 // this class can take advantage of the preprocessor output to give
514 // a minor number of false positive warnings in the final comparison
515 void AddPreprocessorValue(const wxString
& name
, const wxString
& val
)
516 { m_preproc
[name
]=val
; }
519 wxStringHashMap m_preproc
;
524 #endif // _XMLPARSER_H_