make GetPaperRect() and GetResolution() const functions

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

diff --git a/utils/ifacecheck/src/xmlparser.cpp b/utils/ifacecheck/src/xmlparser.cpp
index e0d5803c4c5b64d9c29d913a2001d90186424abf..b5c752d48fe070255d87a8defef4f53b4f79941d 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"


@@ -58,11 +59,15 @@ 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");

 
     // 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)


@@ -76,10 +81,17 @@ void wxType::SetTypeFromString(const wxString& t)
 
     m_strType.Replace(" ,", ",");
 
 
     m_strType.Replace(" ,", ",");
 

+    // ADHOC-FIX
+    m_strType.Replace("_wxArraywxArrayStringBase", "wxString");
+

     m_strType = m_strType.Strip(wxString::both);
 
     m_strType = m_strType.Strip(wxString::both);
 

-    // now set the clean version
-    m_strTypeClean = m_strType;
+
+
+    // 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("const", "");
     m_strTypeClean.Replace("static", "");
     m_strTypeClean.Replace("*", "");


@@ -92,12 +104,13 @@ void wxType::SetTypeFromString(const wxString& t)
     if (m_strTypeClean.EndsWith("Base"))
         m_strTypeClean = m_strTypeClean.Left(m_strTypeClean.Len()-4);
 
     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:
     // 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::", "");
+    m_strTypeClean.Replace("wxWindowID", "int");

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


@@ -121,7 +134,13 @@ bool wxType::operator==(const wxType& m) const
         return true;
 
     if (g_verbose)
         return true;
 
     if (g_verbose)

-        LogMessage("Type '%s' does not match type '%s'", m_strType, m.m_strType);
+    {
+        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;
 }


@@ -134,25 +153,39 @@ bool wxType::operator==(const wxType& m) const
 void wxArgumentType::SetDefaultValue(const wxString& defval, const wxString& defvalForCmp)
 {
     m_strDefaultValue = defval.Strip(wxString::both);
 void wxArgumentType::SetDefaultValue(const wxString& defval, const wxString& defvalForCmp)
 {
     m_strDefaultValue = defval.Strip(wxString::both);

-    m_strDefaultValueForCmp = defvalForCmp.IsEmpty() ? m_strDefaultValue : defvalForCmp.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

 
 

-    // 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";
+    wxString *p;
+    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 = "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:
-    if (m_strDefaultValueForCmp == "0u")
-        m_strDefaultValueForCmp = "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__");
+
+        // ADHOC-FIX: for wxConv* default values
+        p->Replace("wxConvAuto(wxFONTENCODING_DEFAULT)", "wxConvAuto()");
+        p->Replace("wxGet_wxConvUTF8()", "wxConvUTF8");
+        p->Replace("wxGet_wxConvLocal()", "wxConvLocal");
+    }

 
 

-    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", "");
+    // clean ONLY the default argument string specific for comparison
+    // --------------------------------------------------------------

 
     if (m_strDefaultValueForCmp.StartsWith("wxT(") &&
         m_strDefaultValueForCmp.EndsWith(")"))
 
     if (m_strDefaultValueForCmp.StartsWith("wxT(") &&
         m_strDefaultValueForCmp.EndsWith(")"))


@@ -162,21 +195,12 @@ void wxArgumentType::SetDefaultValue(const wxString& defval, const wxString& def
         m_strDefaultValueForCmp = m_strDefaultValueForCmp.Mid(4,len-5);
     }
 
         m_strDefaultValueForCmp = m_strDefaultValueForCmp.Mid(4,len-5);
     }
 

-/*
-    if (IsPointer())
-        m_strDefaultValueForCmp.Replace("0", "NULL");
-    else
-        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
     // 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");
-

     m_strDefaultValueForCmp.Replace("* GetColour(COLOUR_BLACK)", "*wxBLACK");
 
     // ADHOC-FIX:
     m_strDefaultValueForCmp.Replace("* GetColour(COLOUR_BLACK)", "*wxBLACK");
 
     // ADHOC-FIX:


@@ -189,6 +213,10 @@ 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;
 

+    // check if the default values match
+    // ---------------------------------
+
+

     // ADHOC-FIX:
     // default values for style attributes of wxWindow-derived classes in gccxml appear as raw
     // numbers; avoid false positives in this case!
     // ADHOC-FIX:
     // default values for style attributes of wxWindow-derived classes in gccxml appear as raw
     // numbers; avoid false positives in this case!


@@ -204,12 +232,17 @@ bool wxArgumentType::operator==(const wxArgumentType& m) const
             (m.m_strDefaultValueForCmp.IsNumber() && m_strDefaultValueForCmp.StartsWith("wx")))
         {
             if (g_verbose)
             (m.m_strDefaultValueForCmp.IsNumber() && m_strDefaultValueForCmp.StartsWith("wx")))
         {
             if (g_verbose)

-                LogMessage("Supposing '%s'  default value to be the same of '%s'...",
+                wxLogMessage("Supposing '%s'  default value to be the same of '%s'...",

                            m_strDefaultValueForCmp, m.m_strDefaultValueForCmp);
 
             return true;
         }
     }
                            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)
     {
 
     if (m_strDefaultValueForCmp != m.m_strDefaultValueForCmp)
     {


@@ -225,7 +258,7 @@ bool wxArgumentType::operator==(const wxArgumentType& m) const
         }
 
         if (g_verbose)
         }
 
         if (g_verbose)

-            LogMessage("Argument type '%s = %s' has different default value from '%s = %s'",
+            wxLogMessage("Argument type '%s = %s' has different default value from '%s = %s'",

                        m_strType, m_strDefaultValueForCmp, m.m_strType, m.m_strDefaultValueForCmp);
         return false;
     }
                        m_strType, m_strDefaultValueForCmp, m.m_strType, m.m_strDefaultValueForCmp);
         return false;
     }


@@ -245,7 +278,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;
     }
 


@@ -254,7 +287,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;
     }
 


@@ -262,7 +295,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;
         }


@@ -276,7 +309,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;


@@ -293,11 +326,15 @@ bool wxMethod::MatchesExceptForAttributes(const wxMethod& m) const
 {
     if (GetReturnType() != m.GetReturnType() ||
         GetName() != m.GetName())
 {
     if (GetReturnType() != m.GetReturnType() ||
         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 (g_verbose)
 
     if (m_args.GetCount()!=m.m_args.GetCount()) {
         if (g_verbose)

-            LogMessage("Method '%s' has %d arguments while '%s' has %d arguments",
+            wxLogMessage("Method '%s' has %d arguments while '%s' has %d arguments",

                        m_strName, m_args.GetCount(), m_strName, m.m_args.GetCount());
         return false;
     }
                        m_strName, m_args.GetCount(), m_strName, m.m_args.GetCount());
         return false;
     }


@@ -310,6 +347,18 @@ bool wxMethod::MatchesExceptForAttributes(const wxMethod& m) const
     return true;
 }
 
     return true;
 }
 

+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
 bool wxMethod::operator==(const wxMethod& m) const
 {
     // check attributes


@@ -319,7 +368,12 @@ bool wxMethod::operator==(const wxMethod& m) const
         IsPureVirtual() != m.IsPureVirtual() ||
         IsDeprecated() != m.IsDeprecated() ||
         GetAccessSpecifier() != m.GetAccessSpecifier())
         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;
         return false;

+    }

 
     // check everything else
     return MatchesExceptForAttributes(m);
 
     // check everything else
     return MatchesExceptForAttributes(m);


@@ -466,11 +520,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;

-                ((wxClass*)this)->m_methods.RemoveAt(j);
-                j--;
+
+                // fix the problem?
+                //((wxClass*)this)->m_methods.RemoveAt(j);
+                //j--;

             }
 
     return true;
             }
 
     return true;


@@ -501,7 +557,7 @@ const wxMethod* wxClass::RecursiveUpwardFindMethod(const wxMethod& m,
         {
             const wxClass *parent = allclasses->FindClass(m_parents[i]);
             if (!parent) {
         {
             const wxClass *parent = allclasses->FindClass(m_parents[i]);
             if (!parent) {

-                LogError("Could not find parent '%s' of class '%s'...",
+                wxLogError("Could not find parent '%s' of class '%s'...",

                          m_parents[i], GetName());
                 return false;
             }
                          m_parents[i], GetName());
                 return false;
             }


@@ -544,7 +600,7 @@ wxMethodPtrArray wxClass::RecursiveUpwardFindMethodsNamed(const wxString& name,
         {
             const wxClass *parent = allclasses->FindClass(m_parents[i]);
             if (!parent) {
         {
             const wxClass *parent = allclasses->FindClass(m_parents[i]);
             if (!parent) {

-                LogError("Could not find parent '%s' of class '%s'...",
+                wxLogError("Could not find parent '%s' of class '%s'...",

                          m_parents[i], GetName());
                 return false;
             }
                          m_parents[i], GetName());
                 return false;
             }


@@ -579,21 +635,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;


@@ -659,19 +727,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;
 #if wxUSE_UNICODE_WCHAR
     wxStringCharType *end;
 #if wxUSE_UNICODE_WCHAR

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

 #else
 #else

-    unsigned long val = strtoul(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;


@@ -680,19 +749,20 @@ bool getID(unsigned long *id, const wxStringCharType* str)
 
 // utility specialized to parse efficiently the gccXML list of IDs which occur
 // in nodes like <Class> ones... i.e. numeric values separed by " _" token
 
 // 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)
+bool getMemberIDs(wxClassMemberIdHashMap* map, wxClass* p, const wxString& str)

 {
 {

+    const wxStringCharType * const start = str.wx_str();

 #if wxUSE_UNICODE_WCHAR
 #if wxUSE_UNICODE_WCHAR

-    size_t len = wcslen(str);
+    size_t len = wcslen(start);

 #else
 #else

-    size_t len = strlen(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)
     wxStringCharType *nexttoken;
 
     while (curpos < end)


@@ -728,16 +798,16 @@ 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;
     }
 
         return false;
     }
 


@@ -760,7 +830,7 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
 
     if (old)
     {
 
     if (old)
     {

-        LogError("The version of GCC-XML used for the creation of %s is too 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;
                  "the cvs_revision attribute of the root node reports '%s', "
                  "minimal required is 1.%d.", filename, version, MIN_REVISION);
         return false;


@@ -786,7 +856,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;
         }
 


@@ -794,7 +864,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;
             }
 


@@ -823,7 +893,7 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
                 if (ids.IsEmpty())
                 {
                     if (child->GetAttribute("incomplete") != "1") {
                 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;
                     }


@@ -834,7 +904,7 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
                 {
                     // decode the non-empty list of IDs:
                     if (!getMemberIDs(&members, newClass, ids)) {
                 {
                     // decode the non-empty list of IDs:
                     if (!getMemberIDs(&members, newClass, ids)) {

-                        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;
                     }


@@ -848,7 +918,7 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
         {
             unsigned long typeId = 0;
             if (!getID(&typeId, child->GetAttribute("type"))) {
         {
             unsigned long typeId = 0;
             if (!getID(&typeId, child->GetAttribute("type"))) {

-                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;
             }
 


@@ -866,7 +936,7 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
         {
             unsigned long type = 0;
             if (!getID(&type, child->GetAttribute("type")) || type == 0) {
         {
             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;
             }
 


@@ -912,7 +982,7 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
         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;
             }
 


@@ -937,7 +1007,7 @@ 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"));
 
                 types[id] = "TOFIX";
                                n, child->GetAttribute("id"));
 
                 types[id] = "TOFIX";


@@ -956,7 +1026,7 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
     while (toResolveTypes.size()>0)
     {
         if (g_verbose)
     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());
 
         for (wxToResolveTypeHashMap::iterator i = toResolveTypes.begin();
                        types.size(), toResolveTypes.size());
 
         for (wxToResolveTypeHashMap::iterator i = toResolveTypes.begin();


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

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

                     return false;
                 }
             }
                     return false;
                 }
             }


@@ -1018,11 +1088,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;
         }
 


@@ -1031,21 +1102,21 @@ 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);
     }
 
     // resolve parent names
         }
         else
             m_classes[i].SetHeader(idx->second);
     }
 
     // resolve parent names

-    for (unsigned int i=0; i<m_classes.GetCount(); i++)
+    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))) {
     {
         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());
+                wxLogError("invalid parent class ID for '%s'", m_classes[i].GetName());

                 return false;
             }
 
                 return false;
             }
 


@@ -1053,7 +1124,7 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
             if (idx == types.end())
             {
                 // this is an error!
             if (idx == types.end())
             {
                 // this is an error!

-                LogError("couldn't find parent class ID '%d'", id);
+                wxLogError("couldn't find parent class ID '%d'", id);

             }
             else
                 // replace k-th parent with its true name:
             }
             else
                 // replace k-th parent with its true name:


@@ -1073,7 +1144,7 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
         {
             unsigned long id = 0;
             if (!getID(&id, child->GetAttribute("id"))) {
         {
             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;
             }
 


@@ -1085,7 +1156,7 @@ 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;
                 }


@@ -1093,12 +1164,12 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
                 // do some additional check that we can do only here:
 
                 if (newfunc.IsCtor() && !p->IsValidCtorForThisClass(newfunc)) {
                 // 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'",
+                    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;
                 }


@@ -1113,8 +1184,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;
 }


@@ -1136,7 +1207,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;
         }


@@ -1145,13 +1216,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;
         }


@@ -1166,14 +1237,14 @@ 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;
             }
 


@@ -1209,7 +1280,7 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p,
         m.SetAccessSpecifier(wxMAS_PRIVATE);
 
     if (!m.IsOk()) {
         m.SetAccessSpecifier(wxMAS_PRIVATE);
 
     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;
     }
 


@@ -1247,7 +1318,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();
     }


@@ -1321,7 +1392,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;
         }
 


@@ -1341,16 +1412,16 @@ 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;
     }
 


@@ -1381,8 +1452,8 @@ bool wxXmlDoxygenInterface::Parse(const wxString& filename)
     }
     //wxPrint("\n");
 
     }
     //wxPrint("\n");
 

-    if (!CheckParseResults())
-        return false;
+    if (!CheckConsistency())
+        return false;       // the check failed

 
     return true;
 }
 
     return true;
 }


@@ -1395,16 +1466,16 @@ bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename)
     int nodes = 0;
 
     if (g_verbose)
     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;
     }
 


@@ -1438,7 +1509,7 @@ bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename)
 
                             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'",
+                                wxLogError("The method '%s' could not be added to class '%s'",

                                          m.GetName(), klass.GetName());
                                 return false;
                             }
                                          m.GetName(), klass.GetName());
                                 return false;
                             }


@@ -1454,7 +1525,7 @@ bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename)
                                 absoluteFile = header;
                             else if (header != absoluteFile)
                             {
                                 absoluteFile = header;
                             else if (header != absoluteFile)
                             {

-                                LogError("The method '%s' is documented in a different "
+                                wxLogError("The method '%s' is documented in a different "

                                             "file from others (which belong to '%s') ?",
                                             header, absoluteFile);
                                 return false;
                                             "file from others (which belong to '%s') ?",
                                             header, absoluteFile);
                                 return false;


@@ -1500,8 +1571,8 @@ bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename)
             if (klass.IsOk())
                 m_classes.Add(klass);
             else if (g_verbose)
             if (klass.IsOk())
                 m_classes.Add(klass);
             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();


@@ -1546,7 +1617,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;
             }
 


@@ -1594,7 +1665,7 @@ bool wxXmlDoxygenInterface::ParseMethod(const wxXmlNode* p, wxMethod& m, wxStrin
     m.SetPureVirtual(p->GetAttribute("virt")=="pure-virtual");
 
     if (!m.IsOk()) {
     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;
     }