]> git.saurik.com Git - wxWidgets.git/blobdiff - utils/ifacecheck/src/xmlparser.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fix handling of not fully specified min/max size in wxBoxSizer.
[wxWidgets.git] / utils / ifacecheck / src / xmlparser.cpp
diff --git a/utils/ifacecheck/src/xmlparser.cpp b/utils/ifacecheck/src/xmlparser.cpp
index 43892d970d5627283f6384354aefeea716981915..86247d1122a45e215b64ed4dfc0144a0fcb184fa 100644 (file)
--- a/utils/ifacecheck/src/xmlparser.cpp
+++ b/utils/ifacecheck/src/xmlparser.cpp
@@ -17,6 +17,7 @@
 
 // for all others, include the necessary headers
 #ifndef WX_PRECOMP
 
 // for all others, include the necessary headers
 #ifndef WX_PRECOMP
+    #include "wx/crt.h"
 #endif
 
 #include "wx/xml/xml.h"
 #endif
 
 #include "wx/xml/xml.h"
@@ -40,6 +41,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;
+
 
 
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
@@ -55,11 +59,16 @@ void wxType::SetTypeFromString(const wxString& t)
               which works at char-level and does everything in a single pass
     */
 
               which works at char-level and does everything in a single pass
     */
 
+    // clean the type string
+    // ---------------------
+
     m_strType = t;
 
     // [] is the same as * for gccxml
     m_strType.Replace("[]", "*");
     m_strType.Replace("long int", "long");      // in wx typically we never write "long int", just "long"
     m_strType = t;
 
     // [] is the same as * for gccxml
     m_strType.Replace("[]", "*");
     m_strType.Replace("long int", "long");      // in wx typically we never write "long int", just "long"
+    m_strType.Replace("long unsigned int", "unsigned long");
+    m_strType.Replace("short unsigned int", "unsigned short");
 
     // make sure the * and & operator always use the same spacing rules
     // (to make sure GetAsString() output is always consistent)
 
     // make sure the * and & operator always use the same spacing rules
     // (to make sure GetAsString() output is always consistent)
@@ -73,7 +82,37 @@ void wxType::SetTypeFromString(const wxString& t)
 
     m_strType.Replace(" ,", ",");
 
 
     m_strType.Replace(" ,", ",");
 
+    // ADHOC-FIX
+    m_strType.Replace("_wxArraywxArrayStringBase", "wxString");
+    m_strType.Replace("ExitCode", "void*");     // used in wxThread stuff
+
     m_strType = m_strType.Strip(wxString::both);
     m_strType = m_strType.Strip(wxString::both);
+
+
+
+    // clean the type string (this time for the comparison)
+    // ----------------------------------------------------
+
+    m_strTypeClean = m_strType;     // begin with the already-cleaned string
+    m_strTypeClean.Replace("const", "");
+    m_strTypeClean.Replace("static", "");
+    m_strTypeClean.Replace("*", "");
+    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);
+
+    // remove the namespace from the types; there's no problem of conflicts
+    // (except for templates) and this avoids tons of false warnings
+    if (m_strTypeClean.Contains("::") && !m_strTypeClean.Contains("<"))
+        m_strTypeClean = m_strTypeClean.Mid(m_strTypeClean.Find("::")+2);
+
+    // ADHOC-FIX:
+    m_strTypeClean.Replace("wxWindowID", "int");
 }
 
 bool wxType::IsOk() const
 }
 
 bool wxType::IsOk() const
@@ -82,31 +121,29 @@ bool wxType::IsOk() const
     //     "reverse_iterator_impl<wxString::const_iterator>" type
     //     It can also contain commas, * and & operators etc
 
     //     "reverse_iterator_impl<wxString::const_iterator>" type
     //     It can also contain commas, * and & operators etc
 
-    return !GetClean().IsEmpty();
-}
-
-wxString wxType::GetClean() const
-{
-    wxString ret(m_strType);
-    ret.Replace("const", "");
-    ret.Replace("static", "");
-    ret.Replace("*", "");
-    ret.Replace("&", "");
-    ret.Replace("[]", "");
-    return ret.Strip(wxString::both);
+    return !m_strTypeClean.IsEmpty();
 }
 
 bool wxType::operator==(const wxType& m) const
 {
     // brain-dead comparison:
 
 }
 
 bool wxType::operator==(const wxType& m) const
 {
     // brain-dead comparison:
 
-    if (GetClean() == m.GetClean() &&
+    if (m_strTypeClean == m.m_strTypeClean &&
         IsConst() == m.IsConst() &&
         IsStatic() == m.IsStatic() &&
         IsPointer() == m.IsPointer() &&
         IsReference() == m.IsReference())
         return true;
 
         IsConst() == m.IsConst() &&
         IsStatic() == m.IsStatic() &&
         IsPointer() == m.IsPointer() &&
         IsReference() == m.IsReference())
         return true;
 
+    if (g_verbose)
+    {
+        wxLogMessage("Type '%s' does not match type '%s'", m_strType, m.m_strType);
+        wxLogMessage(" => TypeClean %s / %s;  IsConst %d / %d; IsStatic %d / %d; IsPointer %d / %d; IsReference %d / %d",
+                   m_strTypeClean, m.m_strTypeClean, IsConst(), m.IsConst(),
+                   IsStatic(), m.IsStatic(), IsPointer(), m.IsPointer(),
+                   IsReference(), m.IsReference());
+    }
+
     return false;
 }
 
     return false;
 }
 
@@ -117,22 +154,60 @@ 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);
-/*
-    // 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:
-    m_strDefaultValue.Replace("0u", "0");
-
-    if (IsPointer())
-        m_strDefaultValue.Replace("0", "NULL");
-    else
-        m_strDefaultValue.Replace("NULL", "0");
-*/
+    m_strDefaultValue = defval.Strip(wxString::both);
+    m_strDefaultValueForCmp = defvalForCmp.IsEmpty() ?
+                m_strDefaultValue : defvalForCmp.Strip(wxString::both);
+
+
+    // clean the default argument strings
+    // ----------------------------------
+
+    // Note: we adjust the aesthetic form of the m_strDefaultValue string for the "modify mode"
+    //       of ifacecheck: we may need to write it out in an interface header
+
+    wxString *p = NULL;
+    for (int i=0; i<2; i++)     // to avoid copying&pasting the code!
+    {
+        if (i == 0) p = &m_strDefaultValue;
+        if (i == 1) p = &m_strDefaultValueForCmp;
+
+        if (*p == "0u" || *p == "0l") *p = "0";
+
+        p->Replace("0x000000001", "1");
+        p->Replace("\\000\\000\\000", "");    // fix for unicode strings:
+        p->Replace("\\011", "\\t");
+        p->Replace("e+0", "");
+        p->Replace("2147483647", "__INT_MAX__");
 
 
-    if (m_strDefaultValue.Contains("wxGetTranslation"))
-        m_strDefaultValue = "_(TOFIX)";     // TODO: wxGetTranslation gives problems to gccxml
+        // ADHOC-FIX: for wxConv* default values
+        p->Replace("wxConvAuto(wxFONTENCODING_DEFAULT)", "wxConvAuto()");
+        p->Replace("wxGet_wxConvUTF8()", "wxConvUTF8");
+        p->Replace("wxGet_wxConvLocal()", "wxConvLocal");
+    }
+
+
+    // clean ONLY the default argument string specific for comparison
+    // --------------------------------------------------------------
+
+    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);
+    }
+
+    // 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("* 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
@@ -140,11 +215,59 @@ 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;
+    // check if the default values match
+    // ---------------------------------
 
 
-    if (def1 != def2)
+
+    // 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)
+            {
+                wxLogMessage("Supposing '%s'  default value to be the same of '%s'...",
+                           m_strDefaultValueForCmp, m.m_strDefaultValueForCmp);
+            }
+
+            return true;
+        }
+    }
+    else if (m_strTypeClean == "float" || m_strTypeClean == "double")
+        // gccXML translates the default floating values in a hardly usable
+        // format; e.g. 25.2 => 2.51999999999999992894572642398998141288757324219e+1
+        // we avoid check on these...
+        return true;
+
+    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;
+        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 (g_verbose)
+        {
+            wxLogMessage("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;
+    }
 
     // we deliberately avoid checks on the argument name
 
 
     // we deliberately avoid checks on the argument name
 
@@ -161,7 +284,7 @@ bool wxMethod::IsOk() const
     // NOTE: m_retType can be a wxEmptyType, and means that this method
     //       is a ctor or a dtor.
     if (!m_retType.IsOk() && m_retType!=wxEmptyType) {
     // NOTE: m_retType can be a wxEmptyType, and means that this method
     //       is a ctor or a dtor.
     if (!m_retType.IsOk() && m_retType!=wxEmptyType) {
-        LogError("'%s' method has invalid return type: %s", m_retType.GetAsString());
+        wxLogError("'%s' method has invalid return type: %s", m_retType.GetAsString());
         return false;
     }
 
         return false;
     }
 
@@ -170,7 +293,7 @@ bool wxMethod::IsOk() const
 
     // a function can't be both const and static or virtual and static!
     if ((m_bConst && m_bStatic) || ((m_bVirtual || m_bPureVirtual) && m_bStatic)) {
 
     // a function can't be both const and static or virtual and static!
     if ((m_bConst && m_bStatic) || ((m_bVirtual || m_bPureVirtual) && m_bStatic)) {
-        LogError("'%s' method can't be both const/static or virtual/static", m_strName);
+        wxLogError("'%s' method can't be both const/static or virtual/static", m_strName);
         return false;
     }
 
         return false;
     }
 
@@ -178,7 +301,7 @@ bool wxMethod::IsOk() const
 
     for (unsigned int i=0; i<m_args.GetCount(); i++)
         if (!m_args[i].IsOk()) {
 
     for (unsigned int i=0; i<m_args.GetCount(); i++)
         if (!m_args[i].IsOk()) {
-            LogError("'%s' method has invalid %d-th argument type: %s",
+            wxLogError("'%s' method has invalid %d-th argument type: %s",
                      m_strName, i+1, m_args[i].GetAsString());
             return false;
         }
                      m_strName, i+1, m_args[i].GetAsString());
             return false;
         }
@@ -192,7 +315,7 @@ bool wxMethod::IsOk() const
         for (unsigned int i=1; i<m_args.GetCount(); i++)
         {
             if (previousArgHasDefault && !m_args[i].HasDefaultValue()) {
         for (unsigned int i=1; i<m_args.GetCount(); i++)
         {
             if (previousArgHasDefault && !m_args[i].HasDefaultValue()) {
-                LogError("'%s' method has %d-th argument which has no default value "
+                wxLogError("'%s' method has %d-th argument which has no default value "
                          "(while the previous one had one!)",
                          m_strName, i+1);
                 return false;
                          "(while the previous one had one!)",
                          m_strName, i+1);
                 return false;
@@ -205,20 +328,28 @@ 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())
+    {
+        if (g_verbose)
+        {
+            wxLogMessage("The method '%s' does not match method '%s'; different names/rettype", 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)
+        {
+            wxLogMessage("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;
@@ -226,10 +357,48 @@ bool wxMethod::operator==(const wxMethod& m) const
     return true;
 }
 
     return true;
 }
 
-wxString wxMethod::GetAsString(bool bWithArgumentNames) const
+bool wxMethod::ActsAsDefaultCtor() const
+{
+    if (!IsCtor())
+        return false;
+
+    for (unsigned int i=0; i<m_args.GetCount(); i++)
+        if (!m_args[i].HasDefaultValue())
+            return false;
+
+    return true;
+}
+
+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())
+    {
+        if (g_verbose)
+        {
+            wxLogMessage("The method '%s' does not match method '%s'; different attributes", GetName(), m.GetName());
+        }
+
+        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
@@ -244,7 +413,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;
 
@@ -263,11 +433,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;
 }
@@ -348,9 +532,13 @@ bool wxClass::CheckConsistency() const
         for (unsigned int j=0; j<m_methods.GetCount(); j++)
             if (i!=j && m_methods[i] == m_methods[j])
             {
         for (unsigned int j=0; j<m_methods.GetCount(); j++)
             if (i!=j && m_methods[i] == m_methods[j])
             {
-                LogError("class %s has two methods with the same prototype: '%s'",
+                wxLogError("class %s has two methods with the same prototype: '%s'",
                          m_strName, m_methods[i].GetAsString());
                 return false;
                          m_strName, m_methods[i].GetAsString());
                 return false;
+
+                // fix the problem?
+                //((wxClass*)this)->m_methods.RemoveAt(j);
+                //j--;
             }
 
     return true;
             }
 
     return true;
@@ -364,7 +552,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) {
+                wxLogError("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;
 
@@ -376,6 +596,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) {
+                wxLogError("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
 // ----------------------------------------------------------------------------
@@ -396,21 +647,33 @@ void wxXmlInterface::Dump(const wxString& filename)
     // dump the classes in alphabetical order
     wxSortedClassArray sorted(CompareWxClassObjects);
     sorted.Alloc(m_classes.GetCount());
     // dump the classes in alphabetical order
     wxSortedClassArray sorted(CompareWxClassObjects);
     sorted.Alloc(m_classes.GetCount());
-    for (unsigned int i=0; i<m_classes.GetCount(); i++)
+
+    unsigned i;
+    for (i=0; i<m_classes.GetCount(); i++)
         sorted.Add(&m_classes[i]);
 
     // now they have been sorted
         sorted.Add(&m_classes[i]);
 
     // now they have been sorted
-    for (unsigned int i=0; i<sorted.GetCount(); i++)
+    for (i=0; i<sorted.GetCount(); i++)
         sorted[i]->Dump(apiout);
 }
 
         sorted[i]->Dump(apiout);
 }
 
-bool wxXmlInterface::CheckParseResults() const
+bool wxXmlInterface::CheckConsistency() const
 {
     // this check can be quite slow, so do it only for debug releases:
 //#ifdef __WXDEBUG__
     for (unsigned int i=0; i<m_classes.GetCount(); i++)
 {
     // this check can be quite slow, so do it only for debug releases:
 //#ifdef __WXDEBUG__
     for (unsigned int i=0; i<m_classes.GetCount(); i++)
+    {
         if (!m_classes[i].CheckConsistency())
             return false;
         if (!m_classes[i].CheckConsistency())
             return false;
+
+        for (unsigned int j=0; j<m_classes.GetCount(); j++)
+            if (i!=j && m_classes[i].GetName() == m_classes[j].GetName())
+            {
+                wxLogError("two classes have the same name: %s",
+                         m_classes[i].GetName());
+                return false;
+            }
+    }
 //#endif
 
     return true;
 //#endif
 
     return true;
@@ -432,11 +695,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
@@ -446,7 +714,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
@@ -460,6 +729,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;
@@ -469,19 +739,20 @@ typedef std::map<unsigned long, toResolveTypeItem> wxToResolveTypeHashMap;
 // utility to parse gccXML ID values;
 // this function is equivalent to wxString(str).Mid(1).ToULong(&id, GCCXML_BASE)
 // but is a little bit faster
 // utility to parse gccXML ID values;
 // this function is equivalent to wxString(str).Mid(1).ToULong(&id, GCCXML_BASE)
 // but is a little bit faster
-bool getID(unsigned long *id, const wxStringCharType* str)
+bool getID(unsigned long *id, const wxString& str)
 {
 {
+    const wxStringCharType * const start = str.wx_str()+1;
     wxStringCharType *end;
     wxStringCharType *end;
-#if wxUSE_UNICODE_UTF8
-    unsigned long val = strtoul(str+1, &end, GCCXML_BASE);
+#if wxUSE_UNICODE_WCHAR
+    unsigned long val = wcstoul(start, &end, GCCXML_BASE);
 #else
 #else
-    unsigned long val = wcstoul(str+1, &end, GCCXML_BASE);
+    unsigned long val = strtoul(start, &end, GCCXML_BASE);
 #endif
 
     // return true only if scan was stopped by the terminating NUL and
     // if the string was not empty to start with and no under/overflow
     // occurred:
 #endif
 
     // return true only if scan was stopped by the terminating NUL and
     // if the string was not empty to start with and no under/overflow
     // occurred:
-    if ( *end != '\0' || end == str+1 || errno == ERANGE || errno == EINVAL )
+    if ( *end != '\0' || end == start || errno == ERANGE || errno == EINVAL )
         return false;
 
     *id = val;
         return false;
 
     *id = val;
@@ -489,29 +760,30 @@ bool getID(unsigned long *id, const wxStringCharType* str)
 }
 
 // utility specialized to parse efficiently the gccXML list of IDs which occur
 }
 
 // utility specialized to parse efficiently the gccXML list of IDs which occur
-// 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 separated by " _" token
+bool getMemberIDs(wxClassMemberIdHashMap* map, wxClass* p, const wxString& str)
 {
 {
-#if wxUSE_UNICODE_UTF8
-    size_t len = strlen(str);
+    const wxStringCharType * const start = str.wx_str();
+#if wxUSE_UNICODE_WCHAR
+    size_t len = wcslen(start);
 #else
 #else
-    size_t len = wcslen(str);
+    size_t len = strlen(start);
 #endif
 
 #endif
 
-    if (len == 0 || str[0] != '_')
+    if (len == 0 || start[0] != '_')
         return false;
 
         return false;
 
-    const wxStringCharType *curpos = str,
-                           *end = str + len;
+    const wxStringCharType *curpos = start,
+                           *end = start + len;
     wxStringCharType *nexttoken;
 
     while (curpos < end)
     {
         // curpos always points to the underscore of the next token to parse:
     wxStringCharType *nexttoken;
 
     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;
@@ -538,16 +810,41 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
     wxXmlNode *child;
     int nodes = 0;
 
     wxXmlNode *child;
     int nodes = 0;
 
-    LogMessage("Parsing %s...", filename);
+    wxLogMessage("Parsing %s...", filename);
 
     if (!doc.Load(filename)) {
 
     if (!doc.Load(filename)) {
-        LogError("can't load %s", filename);
+        wxLogError("can't load %s", filename);
         return false;
     }
 
     // start processing the XML file
     if (doc.GetRoot()->GetName() != "GCC_XML") {
         return false;
     }
 
     // start processing the XML file
     if (doc.GetRoot()->GetName() != "GCC_XML") {
-        LogError("invalid root node for %s", filename);
+        wxLogError("invalid root node for %s", filename);
+        return false;
+    }
+
+    wxString version = doc.GetRoot()->GetAttribute("cvs_revision");
+    bool old = false;
+
+#define MIN_REVISION  120
+
+    if (!version.StartsWith("1."))
+        old = true;
+    if (!old)
+    {
+        unsigned long rev = 0;
+        if (!version.Mid(2).ToULong(&rev))
+            old = true;
+        else
+            if (rev < MIN_REVISION)
+                old = true;
+    }
+
+    if (old)
+    {
+        wxLogError("The version of GCC-XML used for the creation of %s is too old; "
+                 "the cvs_revision attribute of the root node reports '%s', "
+                 "minimal required is 1.%d.", filename, version, MIN_REVISION);
         return false;
     }
 
         return false;
     }
 
@@ -555,6 +852,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);
@@ -570,7 +868,7 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
 
             // NOTE: <File> nodes can have an id == "f0"...
 
 
             // NOTE: <File> nodes can have an id == "f0"...
 
-            LogError("Invalid id for node %s: %s", n, child->GetAttribute("id"));
+            wxLogError("Invalid id for node %s: %s", n, child->GetAttribute("id"));
             return false;
         }
 
             return false;
         }
 
@@ -578,7 +876,7 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
         {
             wxString cname = child->GetAttribute("name");
             if (cname.IsEmpty()) {
         {
             wxString cname = child->GetAttribute("name");
             if (cname.IsEmpty()) {
-                LogError("Invalid empty name for '%s' node", n);
+                wxLogError("Invalid empty name for '%s' node", n);
                 return false;
             }
 
                 return false;
             }
 
@@ -588,11 +886,26 @@ 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())
                 {
                     if (child->GetAttribute("incomplete") != "1") {
                 const wxString& ids = child->GetAttribute("members");
                 if (ids.IsEmpty())
                 {
                     if (child->GetAttribute("incomplete") != "1") {
-                        LogError("Invalid member IDs for '%s' class node: %s",
+                        wxLogError("Invalid member IDs for '%s' class node: %s",
                                 cname, child->GetAttribute("id"));
                         return false;
                     }
                                 cname, child->GetAttribute("id"));
                         return false;
                     }
@@ -602,8 +915,8 @@ 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)) {
-                        LogError("Invalid member IDs for '%s' class node: %s",
+                    if (!getMemberIDs(&members, newClass, ids)) {
+                        wxLogError("Invalid member IDs for '%s' class node: %s",
                                 cname, child->GetAttribute("id"));
                         return false;
                     }
                                 cname, child->GetAttribute("id"));
                         return false;
                     }
@@ -613,12 +926,29 @@ 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"))) {
+                wxLogError("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")
         {
             unsigned long type = 0;
             if (!getID(&type, child->GetAttribute("type")) || type == 0) {
         else if (n == "PointerType" || n == "ReferenceType" ||
                  n == "CvQualifiedType" || n == "ArrayType")
         {
             unsigned long type = 0;
             if (!getID(&type, child->GetAttribute("type")) || type == 0) {
-                LogError("Invalid type for node %s: %s", n, child->GetAttribute("type"));
+                wxLogError("Invalid type for node %s: %s", n, child->GetAttribute("type"));
                 return false;
             }
 
                 return false;
             }
 
@@ -652,16 +982,19 @@ 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")
         {
             if (!child->GetAttribute("id").StartsWith("f")) {
         }
         else if (n == "File")
         {
             if (!child->GetAttribute("id").StartsWith("f")) {
-                LogError("Unexpected file ID: %s", child->GetAttribute("id"));
+                wxLogError("Unexpected file ID: %s", child->GetAttribute("id"));
                 return false;
             }
 
                 return false;
             }
 
@@ -686,8 +1019,10 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
                 // they're never used as return/argument types by wxWidgets methods
 
                 if (g_verbose)
                 // they're never used as return/argument types by wxWidgets methods
 
                 if (g_verbose)
-                    LogWarning("Type node '%s' with ID '%s' does not have name attribute",
+                {
+                    wxLogWarning("Type node '%s' with ID '%s' does not have name attribute",
                                n, child->GetAttribute("id"));
                                n, child->GetAttribute("id"));
+                }
 
                 types[id] = "TOFIX";
             }
 
                 types[id] = "TOFIX";
             }
@@ -700,13 +1035,15 @@ 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)
     {
         if (g_verbose)
     // thus we need to resolve their name iteratively:
     while (toResolveTypes.size()>0)
     {
         if (g_verbose)
-            LogMessage("%d types were collected; %d types need yet to be resolved...",
+        {
+            wxLogMessage("%d types were collected; %d types need yet to be resolved...",
                        types.size(), toResolveTypes.size());
                        types.size(), toResolveTypes.size());
+        }
 
         for (wxToResolveTypeHashMap::iterator i = toResolveTypes.begin();
              i != toResolveTypes.end();)
 
         for (wxToResolveTypeHashMap::iterator i = toResolveTypes.begin();
              i != toResolveTypes.end();)
@@ -733,7 +1070,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);
@@ -756,7 +1096,7 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
                 }
                 else
                 {
                 }
                 else
                 {
-                    LogError("Cannot solve '%s' reference type!", referenced);
+                    wxLogError("Cannot solve '%d' reference type!", referenced);
                     return false;
                 }
             }
                     return false;
                 }
             }
@@ -764,11 +1104,12 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
     }
 
     // resolve header names
     }
 
     // resolve header names
-    for (unsigned int i=0; i<m_classes.GetCount(); i++)
+    unsigned i;
+    for (i=0; i<m_classes.GetCount(); i++)
     {
         unsigned long fileID = 0;
         if (!getID(&fileID, m_classes[i].GetHeader()) || fileID == 0) {
     {
         unsigned long fileID = 0;
         if (!getID(&fileID, m_classes[i].GetHeader()) || fileID == 0) {
-            LogError("invalid header id: %s", m_classes[i].GetHeader());
+            wxLogError("invalid header id: %s", m_classes[i].GetHeader());
             return false;
         }
 
             return false;
         }
 
@@ -777,25 +1118,49 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
         if (idx == files.end())
         {
             // this is an error!
         if (idx == files.end())
         {
             // this is an error!
-            LogError("couldn't find file ID '%s'", m_classes[i].GetHeader());
+            wxLogError("couldn't find file ID '%s'", m_classes[i].GetHeader());
         }
         else
             m_classes[i].SetHeader(idx->second);
     }
 
         }
         else
             m_classes[i].SetHeader(idx->second);
     }
 
+    // resolve parent names
+    for (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))) {
+                wxLogError("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!
+                wxLogError("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;
             if (!getID(&id, child->GetAttribute("id"))) {
             (n == "Method" || n == "Constructor" || n == "Destructor" || n == "OperatorMethod"))
         {
             unsigned long id = 0;
             if (!getID(&id, child->GetAttribute("id"))) {
-                LogError("invalid ID for node '%s' with ID '%s'", n, child->GetAttribute("id"));
+                wxLogError("invalid ID for node '%s' with ID '%s'", n, child->GetAttribute("id"));
                 return false;
             }
 
                 return false;
             }
 
@@ -807,18 +1172,20 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
                 // this <Method> node is a method of the i-th class!
                 wxMethod newfunc;
                 if (!ParseMethod(child, types, newfunc)) {
                 // this <Method> node is a method of the i-th class!
                 wxMethod newfunc;
                 if (!ParseMethod(child, types, newfunc)) {
-                    LogError("The method '%s' could not be added to class '%s'",
+                    wxLogError("The method '%s' could not be added to class '%s'",
                              child->GetAttribute("demangled"), p->GetName());
                     return false;
                 }
 
                              child->GetAttribute("demangled"), p->GetName());
                     return false;
                 }
 
+                // do some additional check that we can do only here:
+
                 if (newfunc.IsCtor() && !p->IsValidCtorForThisClass(newfunc)) {
                 if (newfunc.IsCtor() && !p->IsValidCtorForThisClass(newfunc)) {
-                    LogError("The method '%s' does not seem to be a ctor for '%s'",
+                    wxLogError("The method '%s' does not seem to be a ctor for '%s'",
                              newfunc.GetName(), p->GetName());
                     return false;
                 }
                 if (newfunc.IsDtor() && !p->IsValidDtorForThisClass(newfunc)) {
                              newfunc.GetName(), p->GetName());
                     return false;
                 }
                 if (newfunc.IsDtor() && !p->IsValidDtorForThisClass(newfunc)) {
-                    LogError("The method '%s' does not seem to be a dtor for '%s'",
+                    wxLogError("The method '%s' does not seem to be a dtor for '%s'",
                              newfunc.GetName(), p->GetName());
                     return false;
                 }
                              newfunc.GetName(), p->GetName());
                     return false;
                 }
@@ -833,8 +1200,8 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
         if ((++nodes%PROGRESS_RATE)==0) ShowProgress();
     }
 
         if ((++nodes%PROGRESS_RATE)==0) ShowProgress();
     }
 
-    if (!CheckParseResults())
-        return false;
+    if (!CheckConsistency())
+        return false;       // the check failed
 
     return true;
 }
 
     return true;
 }
@@ -856,7 +1223,7 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p,
     if (!getID(&retid, p->GetAttribute("returns")) || retid == 0)
     {
         if (p->GetName() != "Destructor" && p->GetName() != "Constructor") {
     if (!getID(&retid, p->GetAttribute("returns")) || retid == 0)
     {
         if (p->GetName() != "Destructor" && p->GetName() != "Constructor") {
-            LogError("Empty return ID for method '%s', with ID '%s'",
+            wxLogError("Empty return ID for method '%s', with ID '%s'",
                      name, p->GetAttribute("id"));
             return false;
         }
                      name, p->GetAttribute("id"));
             return false;
         }
@@ -865,13 +1232,13 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p,
     {
         wxTypeIdHashMap::const_iterator retidx = types.find(retid);
         if (retidx == types.end()) {
     {
         wxTypeIdHashMap::const_iterator retidx = types.find(retid);
         if (retidx == types.end()) {
-            LogError("Could not find return type ID '%s'", retid);
+            wxLogError("Could not find return type ID '%s'", retid);
             return false;
         }
 
         ret = wxType(retidx->second);
         if (!ret.IsOk()) {
             return false;
         }
 
         ret = wxType(retidx->second);
         if (!ret.IsOk()) {
-            LogError("Invalid return type '%s' for method '%s', with ID '%s'",
+            wxLogError("Invalid return type '%s' for method '%s', with ID '%s'",
                      retidx->second, name, p->GetAttribute("id"));
             return false;
         }
                      retidx->second, name, p->GetAttribute("id"));
             return false;
         }
@@ -886,18 +1253,20 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p,
         {
             unsigned long id = 0;
             if (!getID(&id, arg->GetAttribute("type")) || id == 0) {
         {
             unsigned long id = 0;
             if (!getID(&id, arg->GetAttribute("type")) || id == 0) {
-                LogError("Invalid argument type ID '%s' for method '%s' with ID %s",
+                wxLogError("Invalid argument type ID '%s' for method '%s' with ID %s",
                          arg->GetAttribute("type"), name, p->GetAttribute("id"));
                 return false;
             }
 
             wxTypeIdHashMap::const_iterator idx = types.find(id);
             if (idx == types.end()) {
                          arg->GetAttribute("type"), name, p->GetAttribute("id"));
                 return false;
             }
 
             wxTypeIdHashMap::const_iterator idx = types.find(id);
             if (idx == types.end()) {
-                LogError("Could not find argument type ID '%s'", id);
+                wxLogError("Could not find argument type ID '%s'", id);
                 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();
@@ -911,15 +1280,23 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p,
 
     // NOTE: gccxml is smart enough to mark as virtual those functions
     //       which are declared virtual in base classes but don't have
 
     // NOTE: gccxml is smart enough to mark as virtual those functions
     //       which are declared virtual in base classes but don't have
-    //       the "virtual" keyword explicitely indicated in the derived
+    //       the "virtual" keyword explicitly indicated in the derived
     //       classes... so we don't need any further logic for virtuals
 
     m.SetVirtual(p->GetAttribute("virtual") == "1");
     m.SetPureVirtual(p->GetAttribute("pure_virtual") == "1");
     m.SetDeprecated(p->GetAttribute("attributes") == "deprecated");
 
     //       classes... so we don't need any further logic for virtuals
 
     m.SetVirtual(p->GetAttribute("virtual") == "1");
     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()) {
     if (!m.IsOk()) {
-        LogError("The prototype '%s' is not valid!", m.GetAsString());
+        wxLogError("The prototype '%s' is not valid!", m.GetAsString());
         return false;
     }
 
         return false;
     }
 
@@ -957,7 +1334,7 @@ static wxString GetTextFromChildren(const wxXmlNode *n)
         else if (ref->GetType() == wxXML_TEXT_NODE)
             text += ref->GetContent();
         else
         else if (ref->GetType() == wxXML_TEXT_NODE)
             text += ref->GetContent();
         else
-            LogWarning("Unexpected node type while getting text from '%s' node", n->GetName());
+            wxLogWarning("Unexpected node type while getting text from '%s' node", n->GetName());
 
         ref = ref->GetNext();
     }
 
         ref = ref->GetNext();
     }
@@ -1031,7 +1408,7 @@ int GetAvailabilityFor(const wxXmlNode *node)
     for (unsigned int i=0; i < ports.GetCount(); i++)
     {
         if (!ports[i].StartsWith("wx")) {
     for (unsigned int i=0; i < ports.GetCount(); i++)
     {
         if (!ports[i].StartsWith("wx")) {
-            LogError("unexpected port ID '%s'", ports[i]);
+            wxLogError("unexpected port ID '%s'", ports[i]);
             return false;
         }
 
             return false;
         }
 
@@ -1051,19 +1428,26 @@ bool wxXmlDoxygenInterface::Parse(const wxString& filename)
     wxXmlDocument index;
     wxXmlNode *compound;
 
     wxXmlDocument index;
     wxXmlNode *compound;
 
-    LogMessage("Parsing %s...", filename);
+    wxLogMessage("Parsing %s...", filename);
 
     if (!index.Load(filename)) {
 
     if (!index.Load(filename)) {
-        LogError("can't load %s", filename);
+        wxLogError("can't load %s", filename);
         return false;
     }
 
     // start processing the index:
     if (index.GetRoot()->GetName() != "doxygenindex") {
         return false;
     }
 
     // start processing the index:
     if (index.GetRoot()->GetName() != "doxygenindex") {
-        LogError("invalid root node for %s", filename);
+        wxLogError("invalid root node for %s", filename);
         return false;
     }
 
         return false;
     }
 
+    /*
+        NB: we may need in future to do a version-check here if the
+            format of the XML generated by doxygen changes.
+            For now (doxygen version 1.5.5), this check is not required
+            since AFAIK the XML format never changed since it was introduced.
+    */
+
     m_classes.Alloc(ESTIMATED_NUM_CLASSES);
 
     // process files referenced by this index file
     m_classes.Alloc(ESTIMATED_NUM_CLASSES);
 
     // process files referenced by this index file
@@ -1084,29 +1468,32 @@ bool wxXmlDoxygenInterface::Parse(const wxString& filename)
     }
     //wxPrint("\n");
 
     }
     //wxPrint("\n");
 
-    if (!CheckParseResults())
-        return false;
+    if (!CheckConsistency())
+        return false;       // the check failed
 
     return true;
 }
 
 bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename)
 {
 
     return true;
 }
 
 bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename)
 {
+    wxClassMemberIdHashMap parents;
     wxXmlDocument doc;
     wxXmlNode *child;
     int nodes = 0;
 
     if (g_verbose)
     wxXmlDocument doc;
     wxXmlNode *child;
     int nodes = 0;
 
     if (g_verbose)
-        LogMessage("Parsing %s...", filename);
+    {
+        wxLogMessage("Parsing %s...", filename);
+    }
 
     if (!doc.Load(filename)) {
 
     if (!doc.Load(filename)) {
-        LogError("can't load %s", filename);
+        wxLogError("can't load %s", filename);
         return false;
     }
 
     // start processing this compound definition XML
     if (doc.GetRoot()->GetName() != "doxygen") {
         return false;
     }
 
     // start processing this compound definition XML
     if (doc.GetRoot()->GetName() != "doxygen") {
-        LogError("invalid root node for %s", filename);
+        wxLogError("invalid root node for %s", filename);
         return false;
     }
 
         return false;
     }
 
@@ -1124,31 +1511,47 @@ bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename)
             wxXmlNode *subchild = child->GetChildren();
             while (subchild)
             {
             wxXmlNode *subchild = child->GetChildren();
             while (subchild)
             {
-                if (subchild->GetName() == "sectiondef" &&
-                    subchild->GetAttribute("kind") == "public-func")
+                // NOTE: when documenting functions using the //@{ and //@}
+                //       tags to create function groups, doxygen puts the
+                //       contained methods into a "user-defined" section
+                //       so we _must_ use the "prot" attribute to distinguish
+                //       public/protected methods from private ones and cannot
+                //       rely on the kind="public" attribute of <sectiondef>
+                if (subchild->GetName() == "sectiondef")
                 {
                 {
-
                     wxXmlNode *membernode = subchild->GetChildren();
                     while (membernode)
                     {
                     wxXmlNode *membernode = subchild->GetChildren();
                     while (membernode)
                     {
+                        const wxString& accessSpec = membernode->GetAttribute("prot");
+
+                        // parse only public&protected functions:
                         if (membernode->GetName() == "memberdef" &&
                         if (membernode->GetName() == "memberdef" &&
-                            membernode->GetAttribute("kind") == "function")
+                            membernode->GetAttribute("kind") == "function" &&
+                            (accessSpec == "public" || accessSpec == "protected"))
                         {
                         {
-
                             wxMethod m;
                             if (!ParseMethod(membernode, m, header)) {
                             wxMethod m;
                             if (!ParseMethod(membernode, m, header)) {
-                                LogError("The method '%s' could not be added to class '%s'",
-                                         m.GetName(), klass.GetName());
+                                wxLogError("The method '%s' could not be added to class '%s'",
+                                           m.GetName(), klass.GetName());
                                 return false;
                             }
 
                                 return false;
                             }
 
+                            if (accessSpec == "public")
+                                m.SetAccessSpecifier(wxMAS_PUBLIC);
+                            else if (accessSpec == "protected")
+                                m.SetAccessSpecifier(wxMAS_PROTECTED);
+                            else if (accessSpec == "private")
+                                m.SetAccessSpecifier(wxMAS_PRIVATE);
+
                             if (absoluteFile.IsEmpty())
                                 absoluteFile = header;
                             else if (header != absoluteFile)
                             {
                             if (absoluteFile.IsEmpty())
                                 absoluteFile = header;
                             else if (header != absoluteFile)
                             {
-                                LogError("The method '%s' is documented in a different "
-                                            "file from others (which belong to '%s') ?",
-                                            header, absoluteFile);
+                                wxLogError("Found inconsistency in the XML file '%s': "
+                                           "the method '%s' is documented in the "
+                                           "file '%s' but the other methods of the same "
+                                           "class are documented in the file '%s'",
+                                            filename, m.GetName(), header, absoluteFile);
                                 return false;
                             }
 
                                 return false;
                             }
 
@@ -1179,16 +1582,25 @@ 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();
             }
 
             // add a new class
             if (klass.IsOk())
 
                 subchild = subchild->GetNext();
             }
 
             // add a new class
             if (klass.IsOk())
+            {
                 m_classes.Add(klass);
                 m_classes.Add(klass);
+            }
             else if (g_verbose)
             else if (g_verbose)
-                LogWarning("discarding class '%s' with %d methods...",
-                        klass.GetName(), klass.GetMethodCount());
+            {
+                wxLogWarning("discarding class '%s' with %d methods...",
+                           klass.GetName(), klass.GetMethodCount());
+            }
         }
 
         child = child->GetNext();
         }
 
         child = child->GetNext();
@@ -1233,7 +1645,7 @@ bool wxXmlDoxygenInterface::ParseMethod(const wxXmlNode* p, wxMethod& m, wxStrin
             }
 
             if (typestr.IsEmpty()) {
             }
 
             if (typestr.IsEmpty()) {
-                LogError("cannot find type node for a param in method '%s'", m.GetName());
+                wxLogError("cannot find type node for a param in method '%s'", m.GetName());
                 return false;
             }
 
                 return false;
             }
 
@@ -1274,14 +1686,14 @@ bool wxXmlDoxygenInterface::ParseMethod(const wxXmlNode* p, wxMethod& m, wxStrin
 
     // NOTE: Doxygen is smart enough to mark as virtual those functions
     //       which are declared virtual in base classes but don't have
 
     // NOTE: Doxygen is smart enough to mark as virtual those functions
     //       which are declared virtual in base classes but don't have
-    //       the "virtual" keyword explicitely indicated in the derived
+    //       the "virtual" keyword explicitly indicated in the derived
     //       classes... so we don't need any further logic for virtuals
 
     m.SetVirtual(p->GetAttribute("virt")=="virtual");
     m.SetPureVirtual(p->GetAttribute("virt")=="pure-virtual");
 
     if (!m.IsOk()) {
     //       classes... so we don't need any further logic for virtuals
 
     m.SetVirtual(p->GetAttribute("virt")=="virtual");
     m.SetPureVirtual(p->GetAttribute("virt")=="pure-virtual");
 
     if (!m.IsOk()) {
-        LogError("The prototype '%s' is not valid!", m.GetAsString());
+        wxLogError("The prototype '%s' is not valid!", m.GetAsString());
         return false;
     }
 
         return false;
     }
 
wxWidgets (Impactor)