[wxWidgets.git] / utils / ifacecheck / src / xmlparser.h

/////////////////////////////////////////////////////////////////////////////
// Name:        xmlparser.h
// Purpose:     Parser of the API/interface XML files
// Author:      Francesco Montorsi
// Created:     2008/03/17
// RCS-ID:      $Id$
// Copyright:   (c) 2008 Francesco Montorsi
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////


#ifndef _XMLPARSER_H_
#define _XMLPARSER_H_

#include <wx/txtstrm.h>
#include <wx/dynarray.h>
#include <wx/xml/xml.h>
#include <wx/platinfo.h>


/*
    IMPORTANT
    =========

    Any fix aimed to reduce "false positives" which involves
    references to a specific wxWidgets class is marked in
    ifacecheck sources with the string:

    // ADHOC-FIX:
    // ...fix description...
*/


// helper macros
#define LogMessage(fmt, ...)   { if (g_bLogEnabled) { wxPrintf(fmt "\n", __VA_ARGS__); fflush(stdout); }}
#define LogWarning(fmt, ...)   { if (g_bLogEnabled) { wxPrintf(fmt "\n", __VA_ARGS__); fflush(stdout); }}
#define LogError(fmt, ...)     { if (g_bLogEnabled) { wxPrintf("ERROR: " fmt "\n", __VA_ARGS__); fflush(stdout); }}
#define wxPrint(str)           { wxPrintf(str); fflush(stdout); }

// enable/disable logging
extern bool g_bLogEnabled;

class LogNull
{
public:
    LogNull() { g_bLogEnabled = false; }
    ~LogNull() { g_bLogEnabled = true; }
};


// ----------------------------------------------------------------------------
// Represents a type with or without const/static/ qualifier
// and with or without & and * operators
// ----------------------------------------------------------------------------
class wxType
{
public:
    wxType() {}
    wxType(const wxString& type)
        { SetTypeFromString(type); }

    void SetTypeFromString(const wxString& t);
    wxString GetAsString() const
        { return m_strType; }

    // returns this type _without_ any decoration,
    // including the & (which indicates this is a reference),
    // the * (which indicates this is a pointer), etc.
    wxString GetAsCleanString() const
        { return m_strTypeClean; }

    bool IsConst() const
        { return m_strType.Contains("const"); }
    bool IsStatic() const
        { return m_strType.Contains("static"); }
    bool IsPointer() const
        { return m_strType.Contains("*"); }
    bool IsReference() const
        { return m_strType.Contains("&"); }

    bool operator==(const wxType& m) const;
    bool operator!=(const wxType& m) const
        { return !(*this == m); }

    bool IsOk() const;

protected:
    wxString m_strType,
             m_strTypeClean;   // m_strType "cleaned" of its attributes
                               // (only for internal use)
};

extern wxType wxEmptyType;
WX_DECLARE_OBJARRAY(wxType, wxTypeArray);


// ----------------------------------------------------------------------------
// Represents a type used as argument for some wxMethod
// ----------------------------------------------------------------------------
class wxArgumentType : public wxType
{
public:
    wxArgumentType() {}
    wxArgumentType(const wxString& type, const wxString& defVal,
                   const wxString& argName = wxEmptyString)
        { SetTypeFromString(type); SetDefaultValue(defVal); m_strArgName = argName; }

    void SetArgumentName(const wxString& name)
        { m_strArgName=name.Strip(wxString::both); }
    wxString GetArgumentName() const
        { return m_strArgName; }

    void SetDefaultValue(const wxString& defval,
                         const wxString& defvalForCmp = wxEmptyString);
    wxString GetDefaultValue() const
        { return m_strDefaultValue; }

    // returns the default value used for comparisons
    wxString GetDefaultCleanValue() const
        { return m_strDefaultValueForCmp; }

    bool HasDefaultValue() const
        { return !m_strDefaultValue.IsEmpty(); }

    bool operator==(const wxArgumentType& m) const;
    bool operator!=(const wxArgumentType& m) const
        { return !(*this == m); }

protected:
    wxString m_strDefaultValue;

    // this string may differ from m_strDefaultValue if there were
    // preprocessor substitutions or other "replacements" done to
    // avoid false errors.
    wxString m_strDefaultValueForCmp;

    // the argument name
    wxString m_strArgName;
};

extern wxArgumentType wxEmptyArgumentType;
WX_DECLARE_OBJARRAY(wxArgumentType, wxArgumentTypeArray);


enum wxMethodAccessSpecifier
{
    wxMAS_PUBLIC,
    wxMAS_PROTECTED,
    wxMAS_PRIVATE
};

// ----------------------------------------------------------------------------
// Represents a single prototype of a class' member.
// ----------------------------------------------------------------------------
class wxMethod
{
public:
    wxMethod()
        { m_bConst=m_bVirtual=m_bPureVirtual=m_bStatic=m_bDeprecated=false;
          m_nLine=-1; m_nAvailability=wxPORT_UNKNOWN; m_access=wxMAS_PUBLIC; }

    wxMethod(const wxType& rettype, const wxString& name,
             const wxArgumentTypeArray& arguments,
             bool isConst, bool isStatic, bool isVirtual)
        : m_retType(rettype), m_strName(name.Strip(wxString::both)),
          m_bConst(isConst), m_bStatic(isStatic), m_bVirtual(isVirtual)
        { SetArgumentTypes(arguments); m_nLine=-1; }


public:     // getters

    // bWithArgumentNames = output argument names?
    // bCleanDefaultValues = output clean argument default values?
    // bDeprecated = output [deprecated] next to deprecated methods?
    // bAccessSpec = output [public], [protected] or [private] next to method?
    //
    // TODO: convert to readable flags this set of bools
    wxString GetAsString(bool bWithArgumentNames = true,
                         bool bCleanDefaultValues = false,
                         bool bDeprecated = false,
                         bool bAccessSpec = false) const;

    // parser of the prototype:
    // all these functions return strings with spaces stripped
    wxType GetReturnType() const
        { return m_retType; }
    wxString GetName() const
        { return m_strName; }
    wxArgumentTypeArray GetArgumentTypes() const
        { return m_args; }
    int GetLocation() const
        { return m_nLine; }
    int GetAvailability() const
        { return m_nAvailability; }
    wxMethodAccessSpecifier GetAccessSpecifier() const
        { return m_access; }

    bool IsConst() const
        { return m_bConst; }
    bool IsStatic() const
        { return m_bStatic; }
    bool IsVirtual() const
        { return m_bVirtual; }
    bool IsPureVirtual() const
        { return m_bPureVirtual; }

    bool IsOk() const;
    bool IsCtor() const
        { return m_retType==wxEmptyType && !m_strName.StartsWith("~"); }
    bool IsDtor() const
        { return m_retType==wxEmptyType && m_strName.StartsWith("~"); }

    bool IsDeprecated() const
        { return m_bDeprecated; }


public:     // setters

    void SetReturnType(const wxType& t)
        { m_retType=t; }
    void SetName(const wxString& name)
        { m_strName=name; }
    void SetArgumentTypes(const wxArgumentTypeArray& arr)
        { m_args=arr; }
    void SetConst(bool c = true)
        { m_bConst=c; }
    void SetStatic(bool c = true)
        { m_bStatic=c; }
    void SetVirtual(bool c = true)
        { m_bVirtual=c; }
    void SetPureVirtual(bool c = true)
        {
            m_bPureVirtual=c;
            if (c) m_bVirtual=c;        // pure virtual => virtual
        }
    void SetDeprecated(bool c = true)
        { m_bDeprecated=c; }
    void SetLocation(int lineNumber)
        { m_nLine=lineNumber; }
    void SetAvailability(int nAvail)
        { m_nAvailability=nAvail; }
    void SetAccessSpecifier(wxMethodAccessSpecifier spec)
        { m_access=spec; }

public:     // misc

    bool operator==(const wxMethod&) const;
    bool operator!=(const wxMethod& m) const
        { return !(*this == m); }

    // this function works like operator== but tests everything:
    // - method name
    // - return type
    // - argument types
    // except for the method attributes (const,static,virtual,pureVirtual,deprecated)
    bool MatchesExceptForAttributes(const wxMethod& m) const;

    void Dump(wxTextOutputStream& stream) const;

protected:
    wxType m_retType;
    wxString m_strName;
    wxArgumentTypeArray m_args;

    // misc attributes:
    bool m_bConst;
    bool m_bStatic;
    bool m_bVirtual;
    bool m_bPureVirtual;
    bool m_bDeprecated;

    // m_nLine can be -1 if no location infos are available
    int m_nLine;

    // this is a combination of wxPORT_* flags (see wxPortId) or wxPORT_UNKNOWN
    // if this method should be available for all wxWidgets ports.
    // NOTE: this is not used for comparing wxMethod objects
    //       (gccXML never gives this kind of info).
    int m_nAvailability;

    // the access specifier for this method
    wxMethodAccessSpecifier m_access;
};

WX_DECLARE_OBJARRAY(wxMethod, wxMethodArray);
WX_DEFINE_ARRAY(const wxMethod*, wxMethodPtrArray);


// we need wxClassPtrArray to be defined _before_ wxClass itself,
// since wxClass uses wxClassPtrArray.
class wxClass;
WX_DEFINE_ARRAY(const wxClass*, wxClassPtrArray);

class wxXmlInterface;


// ----------------------------------------------------------------------------
// Represents a class of the wx API/interface.
// ----------------------------------------------------------------------------
class wxClass
{
public:
    wxClass() {}
    wxClass(const wxString& name, const wxString& headername)
        : m_strName(name), m_strHeader(headername) {}


public:     // setters

    void SetHeader(const wxString& header)
        { m_strHeader=header; }
    void SetName(const wxString& name)
        { m_strName=name; }
    void SetAvailability(int nAvail)
        { m_nAvailability=nAvail; }
    void SetParent(unsigned int k, const wxString& name)
        { m_parents[k]=name; }

public:     // getters

    bool IsOk() const
        { return !m_strName.IsEmpty() && !m_methods.IsEmpty(); }

    bool IsValidCtorForThisClass(const wxMethod& m) const;
    bool IsValidDtorForThisClass(const wxMethod& m) const;

    wxString GetName() const
        { return m_strName; }
    wxString GetHeader() const
        { return m_strHeader; }
    wxString GetNameWithoutTemplate() const;

    unsigned int GetMethodCount() const
        { return m_methods.GetCount(); }
    wxMethod& GetMethod(unsigned int n) const
        { return m_methods[n]; }
    wxMethod& GetLastMethod() const
        { return m_methods.Last(); }

    int GetAvailability() const
        { return m_nAvailability; }

    //const wxClass *GetParent(unsigned int i) const
    const wxString& GetParent(unsigned int i) const
        { return m_parents[i]; }
    unsigned int GetParentCount() const
        { return m_parents.GetCount(); }

public:     // misc

    void AddMethod(const wxMethod& func)
        { m_methods.Add(func); }

    void AddParent(const wxString& parent)//wxClass* parent)
        { m_parents.Add(parent); }

    // returns a single result (the first, which is also the only
    // one if CheckConsistency() return true)
    const wxMethod* FindMethod(const wxMethod& m) const;

    // like FindMethod() but this one searches also recursively in
    // the parents of this class.
    const wxMethod* RecursiveUpwardFindMethod(const wxMethod& m,
                                              const wxXmlInterface* allclasses) const;

    // returns an array of pointers to the overloaded methods with the
    // same given name
    wxMethodPtrArray FindMethodsNamed(const wxString& name) const;

    // like FindMethodsNamed() but this one searches also recursively in
    // the parents of this class.
    wxMethodPtrArray RecursiveUpwardFindMethodsNamed(const wxString& name,
                                                     const wxXmlInterface* allclasses) const;

    // dumps all methods to the given output stream
    void Dump(wxTextOutputStream& stream) const;

    // slow check
    bool CheckConsistency() const;

protected:
    wxString m_strName;
    wxString m_strHeader;
    wxMethodArray m_methods;

    // name of the base classes: we store the names and not the pointers
    // because this makes _much_ easier the parsing process!
    // (basically because when parsing class X which derives from Y,
    //  we may have not parsed yet class Y!)
    wxArrayString m_parents;

    // see the wxMethod::m_nAvailability field for more info
    int m_nAvailability;
};

WX_DECLARE_OBJARRAY(wxClass, wxClassArray);


// ----------------------------------------------------------------------------
// wxXmlInterface
// ----------------------------------------------------------------------------
class wxXmlInterface
{
public:
    wxXmlInterface() {}

    const wxClass* FindClass(const wxString& classname) const
        {
            for (unsigned int i=0; i<m_classes.GetCount(); i++)
                if (m_classes[i].GetName() == classname)
                    return &m_classes[i];
            return NULL;
        }

    void Dump(const wxString& filename);

    const wxClassArray& GetClasses() const
        { return m_classes; }

    unsigned int GetClassesCount() const
        { return m_classes.GetCount(); }

    unsigned int GetMethodCount() const
        {
            unsigned int methods = 0;
            for (unsigned i=0; i < m_classes.GetCount(); i++)
                methods += m_classes[i].GetMethodCount();
            return methods;
        }

    // pass a full-path header filename:
    wxClassPtrArray FindClassesDefinedIn(const wxString& headerfile) const;

    void ShowProgress()
        { /*wxPrint(".");*/ }

    bool CheckParseResults() const;

protected:
    wxClassArray m_classes;
};

#if 1
// for wxTypeIdHashMap, keys == gccxml IDs  and  values == associated type strings
// e.g. key = "0x123f" and value = "const wxAboutDialogInfo&"
WX_DECLARE_HASH_MAP( unsigned long, wxString,
                     wxIntegerHash, wxIntegerEqual,
                     wxTypeIdHashMap );

WX_DECLARE_STRING_HASH_MAP( wxString, wxStringHashMap );
#else
#include <map>
typedef std::basic_string<char> stlString;
typedef std::map<unsigned long, stlString> wxTypeIdHashMap;
#endif


// ----------------------------------------------------------------------------
// Represents the real interface of wxWidgets
// Loads it from the XML produced by gccXML: http://www.gccxml.org
// ----------------------------------------------------------------------------
class wxXmlGccInterface : public wxXmlInterface
{
public:
    wxXmlGccInterface()
    {
        // FIXME: we should retrieve this from the XML file!
        //        here we suppose the XML was created for the currently-running port
        m_portId = wxPlatformInfo::Get().GetPortId();
    }

    bool Parse(const wxString& filename);
    bool ParseMethod(const wxXmlNode *p,
                     const wxTypeIdHashMap& types,
                     wxMethod& m);

    wxPortId GetInterfacePort() const
        { return m_portId; }

    wxString GetInterfacePortName() const
        { return wxPlatformInfo::GetPortIdName(m_portId, false); }

protected:
    // the port for which the gcc XML was generated
    wxPortId m_portId;
};


// ----------------------------------------------------------------------------
// Represents the interface of the doxygen headers of wxWidgets
// Loads it from the XML produced by Doxygen: http://www.doxygen.org
// ----------------------------------------------------------------------------
class wxXmlDoxygenInterface : public wxXmlInterface
{
public:
    wxXmlDoxygenInterface() {}

    // !!SPEEDUP-TODO!!
    // Using wxXmlDocument::Load as is, the entire XML file is parsed
    // and an entire tree of wxXmlNodes is built in memory.
    // We need however only small portions of the Doxygen-generated XML: to speedup the
    // processing we could detach the expat callbacks when we detect the beginning of a
    // node we're not interested about, or just don't create a wxXmlNode for it!
    // This needs a modification of wxXml API.

    bool Parse(const wxString& filename);
    bool ParseCompoundDefinition(const wxString& filename);
    bool ParseMethod(const wxXmlNode*, wxMethod&, wxString& header);

    // this class can take advantage of the preprocessor output to give
    // a minor number of false positive warnings in the final comparison
    void AddPreprocessorValue(const wxString& name, const wxString& val)
        { m_preproc[name]=val; }

protected:
    wxStringHashMap m_preproc;
};


#endif      // _XMLPARSER_H_
Commit	Line	Data
5934cda1 FM	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: xmlparser.h
	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
	12	#ifndef _XMLPARSER_H_
	13	#define _XMLPARSER_H_
	14
	15	#include <wx/txtstrm.h>
	16	#include <wx/dynarray.h>
	17	#include <wx/xml/xml.h>
d2367a0f	18	#include <wx/platinfo.h>
5934cda1	19
97f0dbd6 FM	20
	21	/*
	22	IMPORTANT
	23	=========
	24
	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:
	28
	29	// ADHOC-FIX:
723de43b	30	// ...fix description...
97f0dbd6 FM	31	*/
	32
	33
	34
5934cda1	35	// helper macros
97f0dbd6 FM	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); }}
5934cda1 FM	39	#define wxPrint(str) { wxPrintf(str); fflush(stdout); }
5934cda1 FM	40
97f0dbd6 FM	41	// enable/disable logging
	42	extern bool g_bLogEnabled;
	43
	44	class LogNull
	45	{
	46	public:
	47	LogNull() { g_bLogEnabled = false; }
	48	~LogNull() { g_bLogEnabled = true; }
	49	};
	50
	51
5934cda1 FM	52
	53	// ----------------------------------------------------------------------------
	54	// Represents a type with or without const/static/ qualifier
	55	// and with or without & and * operators
	56	// ----------------------------------------------------------------------------
	57	class wxType
	58	{
	59	public:
	60	wxType() {}
	61	wxType(const wxString& type)
f270e1dd	62	{ SetTypeFromString(type); }
5934cda1	63
f270e1dd	64	void SetTypeFromString(const wxString& t);
5934cda1 FM	65	wxString GetAsString() const
5934cda1 FM	66	{ return m_strType; }
2cb3a02f FM	67
	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.
97f0dbd6 FM	71	wxString GetAsCleanString() const
97f0dbd6 FM	72	{ return m_strTypeClean; }
5934cda1	73
5934cda1 FM	74	bool IsConst() const
	75	{ return m_strType.Contains("const"); }
	76	bool IsStatic() 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("&"); }
	82
	83	bool operator==(const wxType& m) const;
	84	bool operator!=(const wxType& m) const
	85	{ return !(*this == m); }
	86
	87	bool IsOk() const;
	88
	89	protected:
658d9804 FM	90	wxString m_strType,
	91	m_strTypeClean; // m_strType "cleaned" of its attributes
	92	// (only for internal use)
5934cda1 FM	93	};
	94
	95	extern wxType wxEmptyType;
	96	WX_DECLARE_OBJARRAY(wxType, wxTypeArray);
	97
	98
f270e1dd FM	99	// ----------------------------------------------------------------------------
	100	// Represents a type used as argument for some wxMethod
	101	// ----------------------------------------------------------------------------
	102	class wxArgumentType : public wxType
	103	{
	104	public:
	105	wxArgumentType() {}
	106	wxArgumentType(const wxString& type, const wxString& defVal,
	107	const wxString& argName = wxEmptyString)
	108	{ SetTypeFromString(type); SetDefaultValue(defVal); m_strArgName = argName; }
	109
	110	void SetArgumentName(const wxString& name)
	111	{ m_strArgName=name.Strip(wxString::both); }
	112	wxString GetArgumentName() const
	113	{ return m_strArgName; }
	114
2cb3a02f FM	115	void SetDefaultValue(const wxString& defval,
2cb3a02f FM	116	const wxString& defvalForCmp = wxEmptyString);
f270e1dd FM	117	wxString GetDefaultValue() const
f270e1dd FM	118	{ return m_strDefaultValue; }
2cb3a02f FM	119
2cb3a02f FM	120	// returns the default value used for comparisons
97f0dbd6	121	wxString GetDefaultCleanValue() const
2cb3a02f	122	{ return m_strDefaultValueForCmp; }
f270e1dd	123
203ba76a FM	124	bool HasDefaultValue() const
	125	{ return !m_strDefaultValue.IsEmpty(); }
	126
f270e1dd FM	127	bool operator==(const wxArgumentType& m) const;
	128	bool operator!=(const wxArgumentType& m) const
	129	{ return !(*this == m); }
	130
	131	protected:
	132	wxString m_strDefaultValue;
5570107a FM	133
5570107a FM	134	// this string may differ from m_strDefaultValue if there were
2cb3a02f FM	135	// preprocessor substitutions or other "replacements" done to
2cb3a02f FM	136	// avoid false errors.
5570107a FM	137	wxString m_strDefaultValueForCmp;
5570107a FM	138
2cb3a02f FM	139	// the argument name
2cb3a02f FM	140	wxString m_strArgName;
f270e1dd FM	141	};
	142
	143	extern wxArgumentType wxEmptyArgumentType;
	144	WX_DECLARE_OBJARRAY(wxArgumentType, wxArgumentTypeArray);
	145
5934cda1	146
8cd22478 FM	147	enum wxMethodAccessSpecifier
	148	{
	149	wxMAS_PUBLIC,
	150	wxMAS_PROTECTED,
	151	wxMAS_PRIVATE
	152	};
	153
5934cda1 FM	154	// ----------------------------------------------------------------------------
	155	// Represents a single prototype of a class' member.
	156	// ----------------------------------------------------------------------------
	157	class wxMethod
	158	{
	159	public:
0403e5dc	160	wxMethod()
03d4f7b9	161	{ m_bConst=m_bVirtual=m_bPureVirtual=m_bStatic=m_bDeprecated=false;
8cd22478	162	m_nLine=-1; m_nAvailability=wxPORT_UNKNOWN; m_access=wxMAS_PUBLIC; }
0403e5dc	163
5934cda1	164	wxMethod(const wxType& rettype, const wxString& name,
f270e1dd	165	const wxArgumentTypeArray& arguments,
5934cda1 FM	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)
f270e1dd	169	{ SetArgumentTypes(arguments); m_nLine=-1; }
5934cda1 FM	170
	171
	172	public: // getters
	173
97f0dbd6	174	// bWithArgumentNames = output argument names?
8cd22478	175	// bCleanDefaultValues = output clean argument default values?
97f0dbd6	176	// bDeprecated = output [deprecated] next to deprecated methods?
8cd22478 FM	177	// bAccessSpec = output [public], [protected] or [private] next to method?
	178	//
	179	// TODO: convert to readable flags this set of bools
97f0dbd6	180	wxString GetAsString(bool bWithArgumentNames = true,
8cd22478 FM	181	bool bCleanDefaultValues = false,
	182	bool bDeprecated = false,
	183	bool bAccessSpec = false) const;
5934cda1 FM	184
	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; }
f270e1dd	191	wxArgumentTypeArray GetArgumentTypes() const
5934cda1	192	{ return m_args; }
5934cda1 FM	193	int GetLocation() const
5934cda1 FM	194	{ return m_nLine; }
03d4f7b9 FM	195	int GetAvailability() const
03d4f7b9 FM	196	{ return m_nAvailability; }
8cd22478 FM	197	wxMethodAccessSpecifier GetAccessSpecifier() const
8cd22478 FM	198	{ return m_access; }
5934cda1 FM	199
	200	bool IsConst() const
	201	{ return m_bConst; }
	202	bool IsStatic() const
	203	{ return m_bStatic; }
	204	bool IsVirtual() const
	205	{ return m_bVirtual; }
a7be99c8 FM	206	bool IsPureVirtual() const
a7be99c8 FM	207	{ return m_bPureVirtual; }
5934cda1 FM	208
	209	bool IsOk() const;
	210	bool IsCtor() const
	211	{ return m_retType==wxEmptyType && !m_strName.StartsWith("~"); }
	212	bool IsDtor() const
	213	{ return m_retType==wxEmptyType && m_strName.StartsWith("~"); }
	214
0403e5dc FM	215	bool IsDeprecated() const
	216	{ return m_bDeprecated; }
	217
5934cda1 FM	218
	219	public: // setters
	220
	221	void SetReturnType(const wxType& t)
	222	{ m_retType=t; }
	223	void SetName(const wxString& name)
	224	{ m_strName=name; }
f270e1dd FM	225	void SetArgumentTypes(const wxArgumentTypeArray& arr)
f270e1dd FM	226	{ m_args=arr; }
5934cda1 FM	227	void SetConst(bool c = true)
	228	{ m_bConst=c; }
	229	void SetStatic(bool c = true)
	230	{ m_bStatic=c; }
	231	void SetVirtual(bool c = true)
	232	{ m_bVirtual=c; }
a7be99c8	233	void SetPureVirtual(bool c = true)
d5978709 FM	234	{
	235	m_bPureVirtual=c;
	236	if (c) m_bVirtual=c; // pure virtual => virtual
	237	}
0403e5dc FM	238	void SetDeprecated(bool c = true)
0403e5dc FM	239	{ m_bDeprecated=c; }
5934cda1 FM	240	void SetLocation(int lineNumber)
5934cda1 FM	241	{ m_nLine=lineNumber; }
03d4f7b9 FM	242	void SetAvailability(int nAvail)
03d4f7b9 FM	243	{ m_nAvailability=nAvail; }
8cd22478 FM	244	void SetAccessSpecifier(wxMethodAccessSpecifier spec)
8cd22478 FM	245	{ m_access=spec; }
5934cda1 FM	246
	247	public: // misc
	248
	249	bool operator==(const wxMethod&) const;
	250	bool operator!=(const wxMethod& m) const
	251	{ return !(*this == m); }
	252
97f0dbd6 FM	253	// this function works like operator== but tests everything:
	254	// - method name
	255	// - return type
	256	// - argument types
	257	// except for the method attributes (const,static,virtual,pureVirtual,deprecated)
	258	bool MatchesExceptForAttributes(const wxMethod& m) const;
	259
5934cda1 FM	260	void Dump(wxTextOutputStream& stream) const;
	261
	262	protected:
	263	wxType m_retType;
	264	wxString m_strName;
f270e1dd	265	wxArgumentTypeArray m_args;
03d4f7b9 FM	266
03d4f7b9 FM	267	// misc attributes:
5934cda1 FM	268	bool m_bConst;
	269	bool m_bStatic;
	270	bool m_bVirtual;
a7be99c8	271	bool m_bPureVirtual;
0403e5dc	272	bool m_bDeprecated;
03d4f7b9 FM	273
03d4f7b9 FM	274	// m_nLine can be -1 if no location infos are available
5934cda1	275	int m_nLine;
03d4f7b9 FM	276
	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).
	281	int m_nAvailability;
8cd22478 FM	282
	283	// the access specifier for this method
	284	wxMethodAccessSpecifier m_access;
5934cda1 FM	285	};
	286
	287	WX_DECLARE_OBJARRAY(wxMethod, wxMethodArray);
	288	WX_DEFINE_ARRAY(const wxMethod*, wxMethodPtrArray);
	289
	290
673ae68a FM	291	// we need wxClassPtrArray to be defined _before_ wxClass itself,
	292	// since wxClass uses wxClassPtrArray.
	293	class wxClass;
	294	WX_DEFINE_ARRAY(const wxClass*, wxClassPtrArray);
	295
	296	class wxXmlInterface;
	297
	298
5934cda1 FM	299	// ----------------------------------------------------------------------------
	300	// Represents a class of the wx API/interface.
	301	// ----------------------------------------------------------------------------
	302	class wxClass
	303	{
	304	public:
	305	wxClass() {}
	306	wxClass(const wxString& name, const wxString& headername)
	307	: m_strName(name), m_strHeader(headername) {}
	308
03d4f7b9 FM	309
03d4f7b9 FM	310	public: // setters
5934cda1 FM	311
	312	void SetHeader(const wxString& header)
	313	{ m_strHeader=header; }
	314	void SetName(const wxString& name)
	315	{ m_strName=name; }
03d4f7b9 FM	316	void SetAvailability(int nAvail)
03d4f7b9 FM	317	{ m_nAvailability=nAvail; }
673ae68a FM	318	void SetParent(unsigned int k, const wxString& name)
673ae68a FM	319	{ m_parents[k]=name; }
03d4f7b9 FM	320
03d4f7b9 FM	321	public: // getters
5934cda1 FM	322
	323	bool IsOk() const
	324	{ return !m_strName.IsEmpty() && !m_methods.IsEmpty(); }
	325
	326	bool IsValidCtorForThisClass(const wxMethod& m) const;
	327	bool IsValidDtorForThisClass(const wxMethod& m) const;
	328
03d4f7b9 FM	329	wxString GetName() const
	330	{ return m_strName; }
	331	wxString GetHeader() const
	332	{ return m_strHeader; }
	333	wxString GetNameWithoutTemplate() const;
	334
5934cda1 FM	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(); }
	341
03d4f7b9 FM	342	int GetAvailability() const
	343	{ return m_nAvailability; }
	344
673ae68a FM	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(); }
	350
03d4f7b9 FM	351	public: // misc
	352
	353	void AddMethod(const wxMethod& func)
	354	{ m_methods.Add(func); }
	355
673ae68a FM	356	void AddParent(const wxString& parent)//wxClass* parent)
	357	{ m_parents.Add(parent); }
	358
5934cda1 FM	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;
	362
673ae68a FM	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;
	367
5934cda1 FM	368	// returns an array of pointers to the overloaded methods with the
5934cda1 FM	369	// same given name
673ae68a FM	370	wxMethodPtrArray FindMethodsNamed(const wxString& name) const;
	371
	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;
5934cda1 FM	376
	377	// dumps all methods to the given output stream
	378	void Dump(wxTextOutputStream& stream) const;
	379
	380	// slow check
	381	bool CheckConsistency() const;
	382
	383	protected:
	384	wxString m_strName;
	385	wxString m_strHeader;
	386	wxMethodArray m_methods;
03d4f7b9	387
673ae68a FM	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;
	393
03d4f7b9 FM	394	// see the wxMethod::m_nAvailability field for more info
03d4f7b9 FM	395	int m_nAvailability;
5934cda1 FM	396	};
	397
	398	WX_DECLARE_OBJARRAY(wxClass, wxClassArray);
5934cda1 FM	399
	400
	401
	402	// ----------------------------------------------------------------------------
	403	// wxXmlInterface
	404	// ----------------------------------------------------------------------------
	405	class wxXmlInterface
	406	{
	407	public:
	408	wxXmlInterface() {}
	409
	410	const wxClass* FindClass(const wxString& classname) const
	411	{
	412	for (unsigned int i=0; i<m_classes.GetCount(); i++)
	413	if (m_classes[i].GetName() == classname)
	414	return &m_classes[i];
	415	return NULL;
	416	}
	417
	418	void Dump(const wxString& filename);
	419
	420	const wxClassArray& GetClasses() const
	421	{ return m_classes; }
	422
	423	unsigned int GetClassesCount() const
	424	{ return m_classes.GetCount(); }
	425
	426	unsigned int GetMethodCount() const
	427	{
	428	unsigned int methods = 0;
	429	for (unsigned i=0; i < m_classes.GetCount(); i++)
	430	methods += m_classes[i].GetMethodCount();
	431	return methods;
	432	}
	433
7fbadf87 FM	434	// pass a full-path header filename:
	435	wxClassPtrArray FindClassesDefinedIn(const wxString& headerfile) const;
	436
5934cda1 FM	437	void ShowProgress()
	438	{ /wxPrint(".");/ }
	439
	440	bool CheckParseResults() const;
	441
	442	protected:
	443	wxClassArray m_classes;
	444	};
	445
	446	#if 1
74bda203 FM	447	// for wxTypeIdHashMap, keys == gccxml IDs and values == associated type strings
74bda203 FM	448	// e.g. key = "0x123f" and value = "const wxAboutDialogInfo&"
fdd4a897 FM	449	WX_DECLARE_HASH_MAP( unsigned long, wxString,
	450	wxIntegerHash, wxIntegerEqual,
	451	wxTypeIdHashMap );
5570107a FM	452
5570107a FM	453	WX_DECLARE_STRING_HASH_MAP( wxString, wxStringHashMap );
5934cda1 FM	454	#else
	455	#include <map>
	456	typedef std::basic_string<char> stlString;
fdd4a897	457	typedef std::map<unsigned long, stlString> wxTypeIdHashMap;
5934cda1 FM	458	#endif
	459
	460
	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
	466	{
	467	public:
03d4f7b9 FM	468	wxXmlGccInterface()
	469	{
	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();
	473	}
5934cda1	474
5934cda1 FM	475	bool Parse(const wxString& filename);
5934cda1 FM	476	bool ParseMethod(const wxXmlNode *p,
fdd4a897	477	const wxTypeIdHashMap& types,
5934cda1	478	wxMethod& m);
03d4f7b9 FM	479
	480	wxPortId GetInterfacePort() const
	481	{ return m_portId; }
	482
	483	wxString GetInterfacePortName() const
	484	{ return wxPlatformInfo::GetPortIdName(m_portId, false); }
	485
	486	protected:
	487	// the port for which the gcc XML was generated
	488	wxPortId m_portId;
5934cda1 FM	489	};
	490
	491
	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
	497	{
	498	public:
	499	wxXmlDoxygenInterface() {}
	500
	501	// !!SPEEDUP-TODO!!
	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.
	508
	509	bool Parse(const wxString& filename);
	510	bool ParseCompoundDefinition(const wxString& filename);
	511	bool ParseMethod(const wxXmlNode*, wxMethod&, wxString& header);
5570107a FM	512
	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; }
	517
	518	protected:
	519	wxStringHashMap m_preproc;
5934cda1 FM	520	};
	521
	522
	523
	524	#endif // _XMLPARSER_H_
	525