Forgot to commit

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

diff --git a/utils/ifacecheck/src/xmlparser.cpp b/utils/ifacecheck/src/xmlparser.cpp
index efbb82798db2bcaef32ed825450d6a0612322d0e..e0d5803c4c5b64d9c29d913a2001d90186424abf 100644 (file)
--- a/utils/ifacecheck/src/xmlparser.cpp
+++ b/utils/ifacecheck/src/xmlparser.cpp
@@ -40,6 +40,9 @@ WX_DEFINE_OBJARRAY(wxClassArray)
 // defined in ifacecheck.cpp
 extern bool g_verbose;
 
 // defined in ifacecheck.cpp
 extern bool g_verbose;
 

+// global variable:
+bool g_bLogEnabled = true;
+

 
 
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------


@@ -83,6 +86,18 @@ void wxType::SetTypeFromString(const wxString& t)
     m_strTypeClean.Replace("&", "");
     m_strTypeClean.Replace("[]", "");
     m_strTypeClean = m_strTypeClean.Strip(wxString::both);
     m_strTypeClean.Replace("&", "");
     m_strTypeClean.Replace("[]", "");
     m_strTypeClean = m_strTypeClean.Strip(wxString::both);

+
+    // to avoid false errors types like wxStandardPaths and wxStandardPathsBase
+    // need to be considered as the same type
+    if (m_strTypeClean.EndsWith("Base"))
+        m_strTypeClean = m_strTypeClean.Left(m_strTypeClean.Len()-4);
+
+    // ADHOC-FIX:
+    // doxygen likes to put wxDateTime:: in front of all wxDateTime enums;
+    // fix this to avoid false positives
+    m_strTypeClean.Replace("wxDateTime::", "");
+    m_strTypeClean.Replace("wxStockGDI::", "");     // same story for some other classes
+    m_strTypeClean.Replace("wxHelpEvent::", "");

 }
 
 bool wxType::IsOk() const
 }
 
 bool wxType::IsOk() const


@@ -105,6 +120,9 @@ bool wxType::operator==(const wxType& m) const
         IsReference() == m.IsReference())
         return true;
 
         IsReference() == m.IsReference())
         return true;
 

+    if (g_verbose)
+        LogMessage("Type '%s' does not match type '%s'", m_strType, m.m_strType);
+

     return false;
 }
 
     return false;
 }
 


@@ -115,23 +133,55 @@ bool wxType::operator==(const wxType& m) const
 
 void wxArgumentType::SetDefaultValue(const wxString& defval, const wxString& defvalForCmp)
 {
 
 void wxArgumentType::SetDefaultValue(const wxString& defval, const wxString& defvalForCmp)
 {

-    m_strDefaultValue=defval.Strip(wxString::both);
-    m_strDefaultValueForCmp=defvalForCmp.Strip(wxString::both);
+    m_strDefaultValue = defval.Strip(wxString::both);
+    m_strDefaultValueForCmp = defvalForCmp.IsEmpty() ? m_strDefaultValue : defvalForCmp.Strip(wxString::both);
+
+    // adjust aesthetic form of DefaultValue for the modify mode of ifacecheck:
+    // we may need to write it out in an interface header
+    if (m_strDefaultValue == "0u")
+        m_strDefaultValue = "0";

 
     // in order to make valid&simple comparison on argument defaults,
     // we reduce some of the multiple forms in which the same things may appear
     // to a single form:
 
     // in order to make valid&simple comparison on argument defaults,
     // we reduce some of the multiple forms in which the same things may appear
     // to a single form:

-    if (m_strDefaultValue == "0u")
-        m_strDefaultValue = "0";
+    if (m_strDefaultValueForCmp == "0u")
+        m_strDefaultValueForCmp = "0";
+
+    m_strDefaultValue.Replace("0x000000001", "1");
+    m_strDefaultValueForCmp.Replace("0x000000001", "1");
+
+    // fix for unicode strings:
+    m_strDefaultValue.Replace("\\000\\000\\000", "");
+    m_strDefaultValueForCmp.Replace("\\000\\000\\000", "");
+
+    if (m_strDefaultValueForCmp.StartsWith("wxT(") &&
+        m_strDefaultValueForCmp.EndsWith(")"))
+    {
+        // get rid of the wxT() part
+        unsigned int len = m_strDefaultValueForCmp.Len();
+        m_strDefaultValueForCmp = m_strDefaultValueForCmp.Mid(4,len-5);
+    }
+

 /*
     if (IsPointer())
 /*
     if (IsPointer())

-        m_strDefaultValue.Replace("0", "NULL");
+        m_strDefaultValueForCmp.Replace("0", "NULL");

     else
     else

-        m_strDefaultValue.Replace("NULL", "0");
+        m_strDefaultValueForCmp.Replace("NULL", "0");

 */
 */

+    // ADHOC-FIX:
+    // doxygen likes to put wxDateTime:: in front of all wxDateTime enums;
+    // fix this to avoid false positives
+    m_strDefaultValueForCmp.Replace("wxDateTime::", "");
+    m_strDefaultValueForCmp.Replace("wxStockGDI::", "");     // same story for some other classes
+    m_strDefaultValueForCmp.Replace("wxHelpEvent::", "");    // same story for some other classes
+
+    m_strDefaultValueForCmp.Replace("wxGet_wxConvLocal()", "wxConvLocal");

 
 

-    if (m_strDefaultValue.Contains("wxGetTranslation"))
-        m_strDefaultValue = "_(TOFIX)";     // TODO: wxGetTranslation gives problems to gccxml
+    m_strDefaultValueForCmp.Replace("* GetColour(COLOUR_BLACK)", "*wxBLACK");
+
+    // ADHOC-FIX:
+    if (m_strDefaultValueForCmp.Contains("wxGetTranslation"))
+        m_strDefaultValueForCmp = "_(TOFIX)";     // TODO: wxGetTranslation gives problems to gccxml

 }
 
 bool wxArgumentType::operator==(const wxArgumentType& m) const
 }
 
 bool wxArgumentType::operator==(const wxArgumentType& m) const


@@ -139,22 +189,44 @@ bool wxArgumentType::operator==(const wxArgumentType& m) const
     if ((const wxType&)(*this) != (const wxType&)m)
         return false;
 
     if ((const wxType&)(*this) != (const wxType&)m)
         return false;
 

-    const wxString& def1 = m_strDefaultValueForCmp.IsEmpty() ? m_strDefaultValue : m_strDefaultValueForCmp;
-    const wxString& def2 = m.m_strDefaultValueForCmp.IsEmpty() ? m.m_strDefaultValue : m.m_strDefaultValueForCmp;
+    // ADHOC-FIX:
+    // default values for style attributes of wxWindow-derived classes in gccxml appear as raw
+    // numbers; avoid false positives in this case!
+    if (m_strArgName == m.m_strArgName && m_strArgName == "style" &&
+        (m_strDefaultValueForCmp.IsNumber() || m.m_strDefaultValueForCmp.IsNumber()))
+        return true;
+
+    // fix for default values which were replaced by gcc-xml with their numeric values
+    // (at this point we know that m_strTypeClean == m.m_strTypeClean):
+    if (m_strTypeClean == "long" || m_strTypeClean == "int")
+    {
+        if ((m_strDefaultValueForCmp.IsNumber() && m.m_strDefaultValueForCmp.StartsWith("wx")) ||
+            (m.m_strDefaultValueForCmp.IsNumber() && m_strDefaultValueForCmp.StartsWith("wx")))
+        {
+            if (g_verbose)
+                LogMessage("Supposing '%s'  default value to be the same of '%s'...",
+                           m_strDefaultValueForCmp, m.m_strDefaultValueForCmp);
+
+            return true;
+        }
+    }

 
 

-    if (def1 != def2)
+    if (m_strDefaultValueForCmp != m.m_strDefaultValueForCmp)

     {
         // maybe the default values are numbers.
         // in this case gccXML gives as default values things like '-0x0000001' instead of just '-1'.
         // To handle these cases, we try to convert the default value strings to numbers:
         long def1val, def2val;
     {
         // maybe the default values are numbers.
         // in this case gccXML gives as default values things like '-0x0000001' instead of just '-1'.
         // To handle these cases, we try to convert the default value strings to numbers:
         long def1val, def2val;

-        if (def1.ToLong(&def1val, 0 /* auto-detect */) &&
-            def2.ToLong(&def2val, 0 /* auto-detect */))
+        if (m_strDefaultValueForCmp.ToLong(&def1val, 0 /* auto-detect */) &&
+            m.m_strDefaultValueForCmp.ToLong(&def2val, 0 /* auto-detect */))

         {
             if (def1val == def2val)
                 return true;        // the default values match
         }
 
         {
             if (def1val == def2val)
                 return true;        // the default values match
         }
 

+        if (g_verbose)
+            LogMessage("Argument type '%s = %s' has different default value from '%s = %s'",
+                       m_strType, m_strDefaultValueForCmp, m.m_strType, m.m_strDefaultValueForCmp);

         return false;
     }
 
         return false;
     }
 


@@ -217,20 +289,20 @@ bool wxMethod::IsOk() const
     return true;
 }
 
     return true;
 }
 

-bool wxMethod::operator==(const wxMethod& m) const
+bool wxMethod::MatchesExceptForAttributes(const wxMethod& m) const

 {
     if (GetReturnType() != m.GetReturnType() ||
 {
     if (GetReturnType() != m.GetReturnType() ||

-        GetName() != m.GetName() ||
-        IsConst() != m.IsConst() ||
-        IsStatic() != m.IsStatic() ||
-        IsVirtual() != m.IsVirtual() ||
-        IsPureVirtual() != m.IsPureVirtual() ||
-        IsDeprecated() != m.IsDeprecated())
+        GetName() != m.GetName())

         return false;
 
         return false;
 

-    if (m_args.GetCount()!=m.m_args.GetCount())
+    if (m_args.GetCount()!=m.m_args.GetCount()) {
+        if (g_verbose)
+            LogMessage("Method '%s' has %d arguments while '%s' has %d arguments",
+                       m_strName, m_args.GetCount(), m_strName, m.m_args.GetCount());

         return false;
         return false;

+    }

 
 

+    // compare argument types

     for (unsigned int i=0; i<m_args.GetCount(); i++)
         if (m_args[i] != m.m_args[i])
             return false;
     for (unsigned int i=0; i<m_args.GetCount(); i++)
         if (m_args[i] != m.m_args[i])
             return false;


@@ -238,10 +310,29 @@ bool wxMethod::operator==(const wxMethod& m) const
     return true;
 }
 
     return true;
 }
 

-wxString wxMethod::GetAsString(bool bWithArgumentNames) const
+bool wxMethod::operator==(const wxMethod& m) const
+{
+    // check attributes
+    if (IsConst() != m.IsConst() ||
+        IsStatic() != m.IsStatic() ||
+        IsVirtual() != m.IsVirtual() ||
+        IsPureVirtual() != m.IsPureVirtual() ||
+        IsDeprecated() != m.IsDeprecated() ||
+        GetAccessSpecifier() != m.GetAccessSpecifier())
+        return false;
+
+    // check everything else
+    return MatchesExceptForAttributes(m);
+}
+
+wxString wxMethod::GetAsString(bool bWithArgumentNames, bool bCleanDefaultValues,
+                               bool bDeprecated, bool bAccessSpec) const

 {
     wxString ret;
 
 {
     wxString ret;
 

+    // NOTE: for return and argument types, never use wxType::GetAsCleanString
+    //       since in that way we'd miss important decorators like &,*,const etc
+

     if (m_retType!=wxEmptyType)
         ret += m_retType.GetAsString() + " ";
     //else; this is a ctor or dtor
     if (m_retType!=wxEmptyType)
         ret += m_retType.GetAsString() + " ";
     //else; this is a ctor or dtor


@@ -256,7 +347,8 @@ wxString wxMethod::GetAsString(bool bWithArgumentNames) const
         if (bWithArgumentNames && !name.IsEmpty())
             ret += " " + name;
 
         if (bWithArgumentNames && !name.IsEmpty())
             ret += " " + name;
 

-        const wxString& def = m_args[i].GetDefaultValue();
+        const wxString& def = bCleanDefaultValues ?
+            m_args[i].GetDefaultCleanValue() : m_args[i].GetDefaultValue();

         if (!def.IsEmpty())
             ret += " = " + def;
 
         if (!def.IsEmpty())
             ret += " = " + def;
 


@@ -275,11 +367,25 @@ wxString wxMethod::GetAsString(bool bWithArgumentNames) const
     if (m_bVirtual || m_bPureVirtual)
         ret = "virtual " + ret;
     if (m_bPureVirtual)
     if (m_bVirtual || m_bPureVirtual)
         ret = "virtual " + ret;
     if (m_bPureVirtual)

-        ret = ret + " = 0";
+        ret += " = 0";
+    if (m_bDeprecated && bDeprecated)
+        ret += " [deprecated]";

 
 

-    // in doxygen headers we don't need wxDEPRECATED:
-    //if (m_bDeprecated)
-    //    ret = "wxDEPRECATED( " + ret + " )";
+    if (bAccessSpec)
+    {
+        switch (m_access)
+        {
+        case wxMAS_PUBLIC:
+            ret += " [public]";
+            break;
+        case wxMAS_PROTECTED:
+            ret += " [protected]";
+            break;
+        case wxMAS_PRIVATE:
+            ret += " [private]";
+            break;
+        }
+    }

 
     return ret;
 }
 
     return ret;
 }


@@ -363,6 +469,8 @@ bool wxClass::CheckConsistency() const
                 LogError("class %s has two methods with the same prototype: '%s'",
                          m_strName, m_methods[i].GetAsString());
                 return false;
                 LogError("class %s has two methods with the same prototype: '%s'",
                          m_strName, m_methods[i].GetAsString());
                 return false;

+                ((wxClass*)this)->m_methods.RemoveAt(j);
+                j--;

             }
 
     return true;
             }
 
     return true;


@@ -376,7 +484,39 @@ const wxMethod* wxClass::FindMethod(const wxMethod& m) const
     return NULL;
 }
 
     return NULL;
 }
 

-wxMethodPtrArray wxClass::FindMethodNamed(const wxString& name) const
+const wxMethod* wxClass::RecursiveUpwardFindMethod(const wxMethod& m,
+                                                   const wxXmlInterface* allclasses) const
+{
+    // first, search into *this
+    const wxMethod* ret = FindMethod(m);
+    if (ret)
+        return ret;
+
+    // then, search into its parents
+    for (unsigned int i=0; i<m_parents.GetCount(); i++)
+    {
+        // ignore non-wx-classes parents
+        // AD-HOC FIX: discard wxScrolledT_Helper parent as it always gives errors
+        if (m_parents[i].StartsWith("wx") && m_parents[i] != "wxScrolledT_Helper")
+        {
+            const wxClass *parent = allclasses->FindClass(m_parents[i]);
+            if (!parent) {
+                LogError("Could not find parent '%s' of class '%s'...",
+                         m_parents[i], GetName());
+                return false;
+            }
+
+            const wxMethod *parentMethod = parent->RecursiveUpwardFindMethod(m, allclasses);
+            if (parentMethod)
+                return parentMethod;
+        }
+    }
+
+    // could not find anything even in parent classes...
+    return NULL;
+}
+
+wxMethodPtrArray wxClass::FindMethodsNamed(const wxString& name) const

 {
     wxMethodPtrArray ret;
 
 {
     wxMethodPtrArray ret;
 


@@ -388,6 +528,37 @@ wxMethodPtrArray wxClass::FindMethodNamed(const wxString& name) const
 }
 
 
 }
 
 

+wxMethodPtrArray wxClass::RecursiveUpwardFindMethodsNamed(const wxString& name,
+                                                          const wxXmlInterface* allclasses) const
+{
+    // first, search into *this
+    wxMethodPtrArray ret = FindMethodsNamed(name);
+    if (ret.GetCount()>0)
+        return ret;         // stop here, don't look upward in the parents
+
+    // then, search into parents of this class
+    for (unsigned int i=0; i<m_parents.GetCount(); i++)
+    {
+        // AD-HOC FIX: discard wxScrolledT_Helper parent as it always gives errors
+        if (m_parents[i].StartsWith("wx") && m_parents[i] != "wxScrolledT_Helper")
+        {
+            const wxClass *parent = allclasses->FindClass(m_parents[i]);
+            if (!parent) {
+                LogError("Could not find parent '%s' of class '%s'...",
+                         m_parents[i], GetName());
+                return false;
+            }
+
+            wxMethodPtrArray temp = parent->RecursiveUpwardFindMethodsNamed(name, allclasses);
+            WX_APPEND_ARRAY(ret, temp);
+        }
+    }
+
+    return ret;
+}
+
+
+

 // ----------------------------------------------------------------------------
 // wxXmlInterface
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxXmlInterface
 // ----------------------------------------------------------------------------


@@ -444,11 +615,16 @@ wxClassPtrArray wxXmlInterface::FindClassesDefinedIn(const wxString& headerfile)
 // wxXmlGccInterface helper declarations
 // ----------------------------------------------------------------------------
 
 // wxXmlGccInterface helper declarations
 // ----------------------------------------------------------------------------
 

+// or-able flags for a toResolveTypeItem->attrib:

 #define ATTRIB_CONST        1
 #define ATTRIB_REFERENCE    2
 #define ATTRIB_POINTER      4
 #define ATTRIB_ARRAY        8
 
 #define ATTRIB_CONST        1
 #define ATTRIB_REFERENCE    2
 #define ATTRIB_POINTER      4
 #define ATTRIB_ARRAY        8
 

+// it may sound strange but gccxml, in order to produce shorter ID names
+// uses (after the underscore) characters in range 0-9 and a-z in the ID names;
+// in order to be able to translate such strings into numbers using strtoul()
+// we use as base 10 (possible digits) + 25 (possible characters) = 35

 #define GCCXML_BASE         35
 
 class toResolveTypeItem
 #define GCCXML_BASE         35
 
 class toResolveTypeItem


@@ -458,7 +634,8 @@ public:
     toResolveTypeItem(unsigned int refID, unsigned int attribint)
         : ref(refID), attribs(attribint) {}
 
     toResolveTypeItem(unsigned int refID, unsigned int attribint)
         : ref(refID), attribs(attribint) {}
 

-    unsigned long ref, attribs;
+    unsigned long ref,       // the referenced type's ID
+                  attribs;   // the attributes of this reference

 };
 
 #if 1
 };
 
 #if 1


@@ -472,6 +649,7 @@ WX_DECLARE_HASH_MAP( unsigned long, toResolveTypeItem,
 WX_DECLARE_HASH_MAP( unsigned long, wxClass*,
                      wxIntegerHash, wxIntegerEqual,
                      wxClassMemberIdHashMap );
 WX_DECLARE_HASH_MAP( unsigned long, wxClass*,
                      wxIntegerHash, wxIntegerEqual,
                      wxClassMemberIdHashMap );

+

 #else
 #include <map>
 typedef std::map<unsigned long, toResolveTypeItem> wxToResolveTypeHashMap;
 #else
 #include <map>
 typedef std::map<unsigned long, toResolveTypeItem> wxToResolveTypeHashMap;


@@ -484,10 +662,10 @@ typedef std::map<unsigned long, toResolveTypeItem> wxToResolveTypeHashMap;
 bool getID(unsigned long *id, const wxStringCharType* str)
 {
     wxStringCharType *end;
 bool getID(unsigned long *id, const wxStringCharType* str)
 {
     wxStringCharType *end;

-#if wxUSE_UNICODE_UTF8
-    unsigned long val = strtoul(str+1, &end, GCCXML_BASE);
-#else
+#if wxUSE_UNICODE_WCHAR

     unsigned long val = wcstoul(str+1, &end, GCCXML_BASE);
     unsigned long val = wcstoul(str+1, &end, GCCXML_BASE);

+#else
+    unsigned long val = strtoul(str+1, &end, GCCXML_BASE);

 #endif
 
     // return true only if scan was stopped by the terminating NUL and
 #endif
 
     // return true only if scan was stopped by the terminating NUL and


@@ -504,10 +682,10 @@ bool getID(unsigned long *id, const wxStringCharType* str)
 // in nodes like <Class> ones... i.e. numeric values separed by " _" token
 bool getMemberIDs(wxClassMemberIdHashMap* map, wxClass* p, const wxStringCharType* str)
 {
 // in nodes like <Class> ones... i.e. numeric values separed by " _" token
 bool getMemberIDs(wxClassMemberIdHashMap* map, wxClass* p, const wxStringCharType* str)
 {

-#if wxUSE_UNICODE_UTF8
-    size_t len = strlen(str);
-#else
+#if wxUSE_UNICODE_WCHAR

     size_t len = wcslen(str);
     size_t len = wcslen(str);

+#else
+    size_t len = strlen(str);

 #endif
 
     if (len == 0 || str[0] != '_')
 #endif
 
     if (len == 0 || str[0] != '_')


@@ -520,10 +698,10 @@ bool getMemberIDs(wxClassMemberIdHashMap* map, wxClass* p, const wxStringCharTyp
     while (curpos < end)
     {
         // curpos always points to the underscore of the next token to parse:
     while (curpos < end)
     {
         // curpos always points to the underscore of the next token to parse:

-#if wxUSE_UNICODE_UTF8
-        unsigned long id = strtoul(curpos+1, &nexttoken, GCCXML_BASE);
-#else
+#if wxUSE_UNICODE_WCHAR

         unsigned long id = wcstoul(curpos+1, &nexttoken, GCCXML_BASE);
         unsigned long id = wcstoul(curpos+1, &nexttoken, GCCXML_BASE);

+#else
+        unsigned long id = strtoul(curpos+1, &nexttoken, GCCXML_BASE);

 #endif
         if ( *nexttoken != ' ' || errno == ERANGE || errno == EINVAL )
             return false;
 #endif
         if ( *nexttoken != ' ' || errno == ERANGE || errno == EINVAL )
             return false;


@@ -592,6 +770,7 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
     wxClassMemberIdHashMap members;
     wxTypeIdHashMap types;
     wxTypeIdHashMap files;
     wxClassMemberIdHashMap members;
     wxTypeIdHashMap types;
     wxTypeIdHashMap files;

+    wxTypeIdHashMap typedefs;

 
     // prealloc quite a lot of memory!
     m_classes.Alloc(ESTIMATED_NUM_CLASSES);
 
     // prealloc quite a lot of memory!
     m_classes.Alloc(ESTIMATED_NUM_CLASSES);


@@ -625,6 +804,21 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
                 // NB: "file" attribute contains an ID value that we'll resolve later
                 m_classes.Add(wxClass(cname, child->GetAttribute("file")));
 
                 // NB: "file" attribute contains an ID value that we'll resolve later
                 m_classes.Add(wxClass(cname, child->GetAttribute("file")));
 

+                // the just-inserted class:
+                wxClass *newClass = &m_classes.Last();
+
+                // now get a list of the base classes:
+                wxXmlNode *baseNode = child->GetChildren();
+                while (baseNode)
+                {
+                    // for now we store as "parents" only the parent IDs...
+                    // later we will resolve them into full class names
+                    if (baseNode->GetName() == "Base")
+                        newClass->AddParent(baseNode->GetAttribute("type"));
+
+                    baseNode = baseNode->GetNext();
+                }
+

                 const wxString& ids = child->GetAttribute("members");
                 if (ids.IsEmpty())
                 {
                 const wxString& ids = child->GetAttribute("members");
                 if (ids.IsEmpty())
                 {


@@ -639,7 +833,7 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
                 else
                 {
                     // decode the non-empty list of IDs:
                 else
                 {
                     // decode the non-empty list of IDs:

-                    if (!getMemberIDs(&members, &m_classes.Last(), ids)) {
+                    if (!getMemberIDs(&members, newClass, ids)) {

                         LogError("Invalid member IDs for '%s' class node: %s",
                                 cname, child->GetAttribute("id"));
                         return false;
                         LogError("Invalid member IDs for '%s' class node: %s",
                                 cname, child->GetAttribute("id"));
                         return false;


@@ -650,6 +844,23 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
             // register this class also as possible return/argument type:
             types[id] = cname;
         }
             // register this class also as possible return/argument type:
             types[id] = cname;
         }

+        else if (n == "Typedef")
+        {
+            unsigned long typeId = 0;
+            if (!getID(&typeId, child->GetAttribute("type"))) {
+                LogError("Invalid type for node %s: %s", n, child->GetAttribute("type"));
+                return false;
+            }
+
+            // this typedef node tell us that every type referenced with the
+            // "typeId" ID should be called with another name:
+            wxString name = child->GetAttribute("name");
+
+            // save this typedef in a separate hashmap...
+            typedefs[typeId] = name;
+
+            types[id] = name;
+        }

         else if (n == "PointerType" || n == "ReferenceType" ||
                  n == "CvQualifiedType" || n == "ArrayType")
         {
         else if (n == "PointerType" || n == "ReferenceType" ||
                  n == "CvQualifiedType" || n == "ArrayType")
         {


@@ -689,11 +900,14 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
             }
 
             if (argstr.Len() > 0)
             }
 
             if (argstr.Len() > 0)

-                argstr = argstr.Left(argstr.Len()-2);
+                argstr = argstr.Left(argstr.Len()-2);       // remove final comma

 
             // these nodes make reference to other types... we'll resolve them later
             //toResolveTypes[id] = toResolveTypeItem(ret, 0);
 
             // these nodes make reference to other types... we'll resolve them later
             //toResolveTypes[id] = toResolveTypeItem(ret, 0);

-            types[id] = child->GetAttribute("returns") + "(" + argstr + ")";
+            //types[id] = child->GetAttribute("returns") + "(" + argstr + ")";
+
+            types[id] = "TOFIX";   // typically this type will be "fixed" thanks
+                                   // to a typedef later...

         }
         else if (n == "File")
         {
         }
         else if (n == "File")
         {


@@ -737,7 +951,7 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
     }
 
     // some nodes with IDs referenced by methods as return/argument types, do reference
     }
 
     // some nodes with IDs referenced by methods as return/argument types, do reference

-    // in turn o ther nodes (see PointerType, ReferenceType and CvQualifierType above);
+    // in turn other nodes (see PointerType, ReferenceType and CvQualifierType above);

     // thus we need to resolve their name iteratively:
     while (toResolveTypes.size()>0)
     {
     // thus we need to resolve their name iteratively:
     while (toResolveTypes.size()>0)
     {


@@ -770,7 +984,10 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
                     newtype = newtype + "[]";
 
                 // add the resolved type to the list of "primary" types
                     newtype = newtype + "[]";
 
                 // add the resolved type to the list of "primary" types

-                types[id] = newtype;
+                if (newtype.Contains("TOFIX") && typedefs[id] != "")
+                    types[id] = typedefs[id];       // better use a typedef for this type!
+                else
+                    types[id] = newtype;

 
                 // this one has been resolved; erase it through its iterator!
                 toResolveTypes.erase(i);
 
                 // this one has been resolved; erase it through its iterator!
                 toResolveTypes.erase(i);


@@ -793,7 +1010,7 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
                 }
                 else
                 {
                 }
                 else
                 {

-                    LogError("Cannot solve '%s' reference type!", referenced);
+                    LogError("Cannot solve '%d' reference type!", referenced);

                     return false;
                 }
             }
                     return false;
                 }
             }


@@ -820,14 +1037,38 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
             m_classes[i].SetHeader(idx->second);
     }
 
             m_classes[i].SetHeader(idx->second);
     }
 

+    // resolve parent names
+    for (unsigned int i=0; i<m_classes.GetCount(); i++)
+    {
+        for (unsigned int k=0; k<m_classes[i].GetParentCount(); k++)
+        {
+            unsigned long id;
+
+            if (!getID(&id, m_classes[i].GetParent(k))) {
+                LogError("invalid parent class ID for '%s'", m_classes[i].GetName());
+                return false;
+            }
+
+            wxTypeIdHashMap::const_iterator idx = types.find(id);
+            if (idx == types.end())
+            {
+                // this is an error!
+                LogError("couldn't find parent class ID '%d'", id);
+            }
+            else
+                // replace k-th parent with its true name:
+                m_classes[i].SetParent(k, idx->second);
+        }
+    }
+

     // build the list of the wx methods
     child = doc.GetRoot()->GetChildren();
     while (child)
     {
     // build the list of the wx methods
     child = doc.GetRoot()->GetChildren();
     while (child)
     {

-        wxString n = child->GetName();
+        wxString n = child->GetName(), acc = child->GetAttribute("access");

 
 

-        // only register public methods
-        if (child->GetAttribute("access") == "public" &&
+        // only register public&protected methods
+        if ((acc == "public" || acc == "protected") &&

             (n == "Method" || n == "Constructor" || n == "Destructor" || n == "OperatorMethod"))
         {
             unsigned long id = 0;
             (n == "Method" || n == "Constructor" || n == "Destructor" || n == "OperatorMethod"))
         {
             unsigned long id = 0;


@@ -849,6 +1090,8 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
                     return false;
                 }
 
                     return false;
                 }
 

+                // do some additional check that we can do only here:
+

                 if (newfunc.IsCtor() && !p->IsValidCtorForThisClass(newfunc)) {
                     LogError("The method '%s' does not seem to be a ctor for '%s'",
                              newfunc.GetName(), p->GetName());
                 if (newfunc.IsCtor() && !p->IsValidCtorForThisClass(newfunc)) {
                     LogError("The method '%s' does not seem to be a ctor for '%s'",
                              newfunc.GetName(), p->GetName());


@@ -934,7 +1177,9 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p,
                 return false;
             }
 
                 return false;
             }
 

-            argtypes.Add(wxArgumentType(idx->second, arg->GetAttribute("default")));
+            argtypes.Add(wxArgumentType(idx->second,
+                                        arg->GetAttribute("default"),
+                                        arg->GetAttribute("name")));

         }
 
         arg = arg->GetNext();
         }
 
         arg = arg->GetNext();


@@ -955,6 +1200,14 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p,
     m.SetPureVirtual(p->GetAttribute("pure_virtual") == "1");
     m.SetDeprecated(p->GetAttribute("attributes") == "deprecated");
 
     m.SetPureVirtual(p->GetAttribute("pure_virtual") == "1");
     m.SetDeprecated(p->GetAttribute("attributes") == "deprecated");
 

+    // decode access specifier
+    if (p->GetAttribute("access") == "public")
+        m.SetAccessSpecifier(wxMAS_PUBLIC);
+    else if (p->GetAttribute("access") == "protected")
+        m.SetAccessSpecifier(wxMAS_PROTECTED);
+    else if (p->GetAttribute("access") == "private")
+        m.SetAccessSpecifier(wxMAS_PRIVATE);
+

     if (!m.IsOk()) {
         LogError("The prototype '%s' is not valid!", m.GetAsString());
         return false;
     if (!m.IsOk()) {
         LogError("The prototype '%s' is not valid!", m.GetAsString());
         return false;


@@ -1136,6 +1389,7 @@ bool wxXmlDoxygenInterface::Parse(const wxString& filename)
 
 bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename)
 {
 
 bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename)
 {

+    wxClassMemberIdHashMap parents;

     wxXmlDocument doc;
     wxXmlNode *child;
     int nodes = 0;
     wxXmlDocument doc;
     wxXmlNode *child;
     int nodes = 0;


@@ -1168,8 +1422,11 @@ bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename)
             wxXmlNode *subchild = child->GetChildren();
             while (subchild)
             {
             wxXmlNode *subchild = child->GetChildren();
             while (subchild)
             {

+                wxString kind = subchild->GetAttribute("kind");
+
+                // parse only public&protected functions:

                 if (subchild->GetName() == "sectiondef" &&
                 if (subchild->GetName() == "sectiondef" &&

-                    subchild->GetAttribute("kind") == "public-func")
+                    (kind == "public-func" || kind == "protected-func"))

                 {
 
                     wxXmlNode *membernode = subchild->GetChildren();
                 {
 
                     wxXmlNode *membernode = subchild->GetChildren();


@@ -1186,6 +1443,13 @@ bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename)
                                 return false;
                             }
 
                                 return false;
                             }
 

+                            if (kind == "public-func")
+                                m.SetAccessSpecifier(wxMAS_PUBLIC);
+                            else if (kind == "protected-func")
+                                m.SetAccessSpecifier(wxMAS_PROTECTED);
+                            else if (kind == "private-func")
+                                m.SetAccessSpecifier(wxMAS_PRIVATE);
+

                             if (absoluteFile.IsEmpty())
                                 absoluteFile = header;
                             else if (header != absoluteFile)
                             if (absoluteFile.IsEmpty())
                                 absoluteFile = header;
                             else if (header != absoluteFile)


@@ -1223,6 +1487,11 @@ bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename)
                     // identify <onlyfor> custom XML tags
                     klass.SetAvailability(GetAvailabilityFor(subchild));
                 }
                     // identify <onlyfor> custom XML tags
                     klass.SetAvailability(GetAvailabilityFor(subchild));
                 }

+                else if (subchild->GetName() == "basecompoundref")
+                {
+                    // add the name of this parent to the list of klass' parents
+                    klass.AddParent(subchild->GetNodeContent());
+                }

 
                 subchild = subchild->GetNext();
             }
 
                 subchild = subchild->GetNext();
             }