Compilation fix.

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

diff --git a/utils/ifacecheck/src/xmlparser.cpp b/utils/ifacecheck/src/xmlparser.cpp
index b768a519ecb7034e67a2aea019af608ca0f6ab7f..c36cc450d6ee6ce147208351121c24553f10cce3 100644 (file)
--- a/utils/ifacecheck/src/xmlparser.cpp
+++ b/utils/ifacecheck/src/xmlparser.cpp
@@ -24,6 +24,9 @@
 #include "wx/arrimpl.cpp"
 #include "wx/dynarray.h"
 #include "wx/filename.h"
 #include "wx/arrimpl.cpp"
 #include "wx/dynarray.h"
 #include "wx/filename.h"

+
+#include <errno.h>
+

 #include "xmlparser.h"
 
 #define PROGRESS_RATE             1000     // each PROGRESS_RATE nodes processed print a dot
 #include "xmlparser.h"
 
 #define PROGRESS_RATE             1000     // each PROGRESS_RATE nodes processed print a dot


@@ -142,84 +145,6 @@ void wxMethod::SetArgumentTypes(const wxTypeArray& arr, const wxArrayString& def
     }
 }
 
     }
 }
 

-
-/*
-void wxMethod::SetFromString(const wxString& proto)
-{
-    m_strProto=proto.Strip(wxString::both);
-
-    // make sure there is a space separing each token
-    m_strProto.Replace("&", "& ");
-    m_strProto.Replace("*", "* ");
-    m_strProto.Replace(",", ", ");
-
-    wxASSERT(m_strProto.Contains("::"));
-    wxASSERT(m_strProto.Contains("(") && m_strProto.Contains(")"));
-}
-
-wxType wxMethod::GetReturnType() const
-{
-    wxString leftpart = m_strProto.Left(m_strProto.Find("::")).Strip(wxString::both);
-    if (!leftpart.Contains(" "))
-        // this is a dtor or a ctor then...
-        return wxEmptyType;
-
-    // see SetFromString: all tokens are separed by a space!
-    wxType ret(leftpart.BeforeFirst(' ').Strip(wxString::both));
-    wxASSERT(ret.IsOk());
-
-    return ret;
-}
-
-wxString wxMethod::GetName() const
-{
-    int nstart = m_strProto.Find("::")+2,
-        nend = m_strProto.Find("(");
-    wxASSERT(nstart!=wxNOT_FOUND && nend!=wxNOT_FOUND);
-
-    return m_strProto.Mid(nstart, nend-nstart).Strip(wxString::both);
-}
-
-bool wxMethod::IsConst() const
-{
-    return m_strProto.EndsWith("const");
-}
-
-bool wxMethod::IsStatic() const
-{
-    return m_strProto.StartsWith("static");
-}
-
-wxTypeArray wxMethod::GetArgumentTypes() const
-{
-    int nstart = m_strProto.Find('(', false * start from beginning *)+1,
-        nend = m_strProto.Find(')', true * start from end *);
-    wxASSERT(nstart!=wxNOT_FOUND && nend!=wxNOT_FOUND);
-
-    wxString argstr = m_strProto.Mid(nstart, nend-nstart).Strip(wxString::both);
-    wxArrayString args = wxSplit(argstr, ',');
-
-    wxTypeArray ret;
-    for (unsigned int i=0; i<args.GetCount(); i++)
-    {
-        wxString arg = args[i].Strip(wxString::both);
-
-        // arg may contain both the type and the argument name;
-        // we need to get rid of the last one...
-        wxArrayString temp = wxSplit(arg, ' ');
-
-        if (temp.GetCount()>1 &&
-            !temp.Last().Contains("&") &&
-            !temp.Last().Contains("*") &&
-            g_)
-            arg.Replace(temp.Last(), "");   // looks like an argument name - remove it
-
-        ret.Add(wxType(arg));
-    }
-
-    return ret;
-}
-*/

 bool wxMethod::operator==(const wxMethod& m) const
 {
     if (GetReturnType() != m.GetReturnType() ||
 bool wxMethod::operator==(const wxMethod& m) const
 {
     if (GetReturnType() != m.GetReturnType() ||


@@ -412,7 +337,7 @@ bool wxXmlInterface::CheckParseResults() const
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

-// wxXmlGccInterface
+// wxXmlGccInterface helper declarations

 // ----------------------------------------------------------------------------
 
 #define ATTRIB_CONST        1
 // ----------------------------------------------------------------------------
 
 #define ATTRIB_CONST        1


@@ -420,228 +345,213 @@ bool wxXmlInterface::CheckParseResults() const
 #define ATTRIB_POINTER      4
 #define ATTRIB_ARRAY        8
 
 #define ATTRIB_POINTER      4
 #define ATTRIB_ARRAY        8
 

+#define GCCXML_BASE         35
+

 class toResolveTypeItem
 {
 public:
     toResolveTypeItem() { attribs=0; }
 class toResolveTypeItem
 {
 public:
     toResolveTypeItem() { attribs=0; }

-    toResolveTypeItem(const wxString& namestr, int attribint)
-        : ref(namestr), attribs(attribint) {}
+    toResolveTypeItem(unsigned int refID, unsigned int attribint)
+        : ref(refID), attribs(attribint) {}

 
 

-    wxString ref;
-    int attribs;
+    unsigned long ref, attribs;

 };
 
 };
 

-//WX_DECLARE_STRING_HASH_MAP( toResolveTypeItem, wxToResolveTypeHashMap );
+#if 1
+
+// for wxToResolveTypeHashMap, keys == gccXML IDs  and  values == toResolveTypeItem
+WX_DECLARE_HASH_MAP( unsigned long, toResolveTypeItem,
+                     wxIntegerHash, wxIntegerEqual,
+                     wxToResolveTypeHashMap );
+
+// for wxClassMemberIdHashMap, keys == gccXML IDs  and  values == wxClass which owns that member ID
+WX_DECLARE_HASH_MAP( unsigned long, wxClass*,
+                     wxIntegerHash, wxIntegerEqual,
+                     wxClassMemberIdHashMap );
+#else

 #include <map>
 #include <map>

-typedef std::map<wxString, toResolveTypeItem> wxToResolveTypeHashMap;
+typedef std::map<unsigned long, toResolveTypeItem> wxToResolveTypeHashMap;
+#endif

 
 

-bool wxXmlGccInterface::Parse(const wxString& filename)
-{
-    wxXmlDocument doc;
-    wxXmlNode *child;
-    int nodes = 0;

 
 

-    LogMessage("Parsing %s...", filename);
+// 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)
+{
+    wxStringCharType *end;
+#if wxUSE_UNICODE_UTF8
+    unsigned long val = strtoul(str+1, &end, GCCXML_BASE);
+#else
+    unsigned long val = wcstoul(str+1, &end, GCCXML_BASE);
+#endif

 
 

-    if (!doc.Load(filename)) {
-        LogError("can't load %s", filename);
+    // 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 )

         return false;
         return false;

-    }

 
 

-    // start processing the XML file
-    if (doc.GetRoot()->GetName() != "GCC_XML") {
-        LogError("invalid root node for %s", filename);
-        return false;
-    }
+    *id = val;
+    return true;
+}

 
 

-    wxToResolveTypeHashMap toResolveTypes;
-    wxArrayString arrMemberIds;
-    wxStringHashMap types;
-    wxStringHashMap files;
+// 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)
+{
+#if wxUSE_UNICODE_UTF8
+    size_t len = strlen(str);
+#else
+    size_t len = wcslen(str);
+#endif

 
 

-    // prealloc quite a lot of memory!
-    m_classes.Alloc(ESTIMATED_NUM_CLASSES);
-    arrMemberIds.Alloc(ESTIMATED_NUM_TYPES);
+    if (len == 0 || str[0] != '_')
+        return false;

 
 

-#if 0
-    // do a quick parsing of the <File> nodes; we take advantage of the fact that
-    // gccxml puts all of them in a contiguos block at the end of the file it produces.
-    child = doc.GetRoot()->GetChildren();
-    while (child && child->GetName() != "File")
-        child = child->GetNext();       // skip everything until first <File> node
+    const wxStringCharType *curpos = str,
+                           *end = str + len;
+    wxStringCharType *nexttoken;

 
 

-    // here starts the <File> node block
-    while (child)
+    while (curpos < end)

     {
     {

-        wxString id = child->GetAttribute("id", "");
-        if (!id.StartsWith("f")) {
-            LogError("Unexpected file ID: %s", id);
+        // 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
+        unsigned long id = wcstoul(curpos+1, &nexttoken, GCCXML_BASE);
+#endif
+        if ( *nexttoken != ' ' || errno == ERANGE || errno == EINVAL )

             return false;
             return false;

-        }

 
 

-        fileIds.Add(id);
-        fileNames.Add(child->GetAttribute("name", ""));
+        // advance current position
+        curpos = nexttoken + 1;

 
 

-        child = child->GetNext();
-    }
-#endif
-
-#if 0
-    wxString allWxClassesIds, allWxMethodsIds, allWxReferencesIds;
-    allWxClassesIds.Alloc(240000);
-    allWxMethodsIds.Alloc(240000);
-    allWxReferencesIds.Alloc(240000);
-    child = doc.GetRoot()->GetChildren();
-    while (child)
-    {
-        if (child->GetName() == "Class")
-            if (child->GetAttribute("name", wxEmptyString).StartsWith("wx"))
-                allWxClassesIds += " " + child->GetAttribute("members", wxEmptyString);
-        child = child->GetNext();
+        // add this ID to the hashmap
+        wxClassMemberIdHashMap::value_type v(id, p);
+        map->insert(v);

     }
 
     }
 

-    child = doc.GetRoot()->GetChildren();
-    while (child)
-    {
-        wxString n = child->GetName();
-        if ((n == "Method" || n == "Constructor" || n == "Destructor" || n == "OperatorMethod") &&
-            child->GetAttribute("access", wxEmptyString) == "public")
-        {
-            if (allWxClassesIds.Contains(child->GetAttribute("id", wxEmptyString)))
-            {
-                allWxMethodsIds += " " + child->GetAttribute("returns", wxEmptyString);
+    return true;
+}

 
 

-                wxXmlNode *arg = child->GetChildren();
-                while (arg)
-                {
-                    if (arg->GetName() == "Argument")
-                        allWxMethodsIds += " " + arg->GetAttribute("type", wxEmptyString);

 
 

-                    arg = arg->GetNext();
-                }
-            }
-        }
+// ----------------------------------------------------------------------------
+// wxXmlGccInterface
+// ----------------------------------------------------------------------------

 
 

-        child = child->GetNext();
-    }
+bool wxXmlGccInterface::Parse(const wxString& filename)
+{
+    wxXmlDocument doc;
+    wxXmlNode *child;
+    int nodes = 0;

 
 

-    child = doc.GetRoot()->GetChildren();
-    while (child)
-    {
-        if (allWxMethodsIds.Contains(child->GetAttribute("id", wxEmptyString)))
-        {
-            const wxString& type = child->GetAttribute("type", wxEmptyString);
-            allWxReferencesIds += " " + type;
-        }
+    LogMessage("Parsing %s...", filename);

 
 

-        child = child->GetNext();
+    if (!doc.Load(filename)) {
+        LogError("can't load %s", filename);
+        return false;

     }
 
     }
 

-    child = doc.GetRoot()->GetChildren();
-    while (child)
-    {
-        if (allWxReferencesIds.Contains(child->GetAttribute("id", wxEmptyString)))
-        {
-            const wxString& type = child->GetAttribute("type", wxEmptyString);
-            allWxReferencesIds += " " + type;
-        }
-
-        child = child->GetNext();
+    // start processing the XML file
+    if (doc.GetRoot()->GetName() != "GCC_XML") {
+        LogError("invalid root node for %s", filename);
+        return false;

     }
 
     }
 

-    LogMessage("adfafdasfdas %d-%d-%d", allWxClassesIds.Len(),
-               allWxMethodsIds.Len(), allWxReferencesIds.Len());
-#endif
+    wxToResolveTypeHashMap toResolveTypes;
+    //wxArrayString arrMemberIds;
+    wxClassMemberIdHashMap members;
+    wxTypeIdHashMap types;
+    wxTypeIdHashMap files;

 
 

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

 
     // build a list of wx classes and in general of all existent types
     child = doc.GetRoot()->GetChildren();
     while (child)
     {
         const wxString& n = child->GetName();
 
     // build a list of wx classes and in general of all existent types
     child = doc.GetRoot()->GetChildren();
     while (child)
     {
         const wxString& n = child->GetName();

-        const wxString& id = child->GetAttribute("id", wxEmptyString);

 
 

-#if 0
-        if (!allWxClassesIds.Contains(id) && !allWxMethodsIds.Contains(id) && !allWxReferencesIds.Contains(id))
-            ; // ignore this node
-        else
-#endif
-#if 0
-        wxString fid = child->GetAttribute("file", "");
-        int fileidx = wxNOT_FOUND;
-
-        if (!fid.IsEmpty()) {
-            fileidx = fileIds.Index(fid);
-            if (fileidx == wxNOT_FOUND) {
-                LogError("couldn't find the file ID '%s'", fid);
-                return false;
-            }
-        }
+        unsigned long id = 0;
+        if (!getID(&id, child->GetAttribute("id")) || (id == 0 && n != "File")) {

 
 

-        if (fileidx!=wxNOT_FOUND && !fileNames[fileidx].Contains("wx"))
-        {
-            // skip this node: not wx related!
-        } else
-#endif
+            // NOTE: <File> nodes can have an id == "f0"...

 
 

-        /*if (child->GetAttribute("artificial", "") == "1")
-        {
-            // discard this immediately - we're not interested
+            LogError("Invalid id for node %s: %s", n, child->GetAttribute("id"));
+            return false;

         }
         }

-        else*/
+

         if (n == "Class")
         {
         if (n == "Class")
         {

-            wxString cname = child->GetAttribute("name", wxEmptyString);
+            wxString cname = child->GetAttribute("name");

             if (cname.IsEmpty()) {
                 LogError("Invalid empty name for '%s' node", n);
                 return false;
             }
 
             // only register wx classes (do remember also the IDs of their members)
             if (cname.IsEmpty()) {
                 LogError("Invalid empty name for '%s' node", n);
                 return false;
             }
 
             // only register wx classes (do remember also the IDs of their members)

-            if (cname.StartsWith("wx")) {
-                arrMemberIds.Add(child->GetAttribute("members", wxEmptyString));
-
+            if (cname.StartsWith("wx"))
+            {

                 // NB: "file" attribute contains an ID value that we'll resolve later
                 // NB: "file" attribute contains an ID value that we'll resolve later

-                m_classes.Add(wxClass(cname, child->GetAttribute("file", wxEmptyString)));
+                m_classes.Add(wxClass(cname, child->GetAttribute("file")));
+
+                const wxString& ids = child->GetAttribute("members");
+                if (ids.IsEmpty())
+                {
+                    if (child->GetAttribute("incomplete") != "1") {
+                        LogError("Invalid member IDs for '%s' class node (ID %s)",
+                                cname, child->GetAttribute("id"));
+                        return false;
+                    }
+                    //else: don't warn the user; it looks like "incomplete" classes
+                    //      never have any member...
+                }
+                else
+                {
+                    // decode the non-empty list of IDs:
+                    if (!getMemberIDs(&members, &m_classes.Last(), ids)) {
+                        LogError("Invalid member IDs for '%s' class node (ID %s)",
+                                cname, child->GetAttribute("id"));
+                        return false;
+                    }
+                }

             }
 
             // register this class also as possible return/argument type:
             }
 
             // register this class also as possible return/argument type:

-            //typeIds.Add(child->GetAttribute("id", wxEmptyString));
-            //typeNames.Add(cname);

             types[id] = cname;
         }
         else if (n == "PointerType" || n == "ReferenceType" ||
                  n == "CvQualifiedType" || n == "ArrayType")
         {
             types[id] = cname;
         }
         else if (n == "PointerType" || n == "ReferenceType" ||
                  n == "CvQualifiedType" || n == "ArrayType")
         {

-            const wxString& type = child->GetAttribute("type", wxEmptyString);
-            if (id.IsEmpty() || type.IsEmpty()) {
-                LogError("Invalid empty type/id for '%s' node", n);
+            unsigned long type = 0;
+            if (!getID(&type, child->GetAttribute("type")) || type == 0) {
+                LogError("Invalid type for node %s: %s", n, child->GetAttribute("type"));

                 return false;
             }
 
                 return false;
             }
 

-            int attr = 0;
+            unsigned long attr = 0;

             if (n == "PointerType")
                 attr = ATTRIB_POINTER;
             else if (n == "ReferenceType")
                 attr = ATTRIB_REFERENCE;
             if (n == "PointerType")
                 attr = ATTRIB_POINTER;
             else if (n == "ReferenceType")
                 attr = ATTRIB_REFERENCE;

-            else if (n == "CvQualifiedType" && child->GetAttribute("const", "") == "1")
+            else if (n == "CvQualifiedType" && child->GetAttribute("const") == "1")

                 attr = ATTRIB_CONST;
             else if (n == "ArrayType")
                 attr = ATTRIB_ARRAY;
 
             // these nodes make reference to other types... we'll resolve them later
                 attr = ATTRIB_CONST;
             else if (n == "ArrayType")
                 attr = ATTRIB_ARRAY;
 
             // these nodes make reference to other types... we'll resolve them later

-            //toResolveTypeIds.Add(id);
-            //toResolveRefType.Add(type);
-            //toResolveAttrib.Add(attr);

             toResolveTypes[id] = toResolveTypeItem(type, attr);
         }
         else if (n == "FunctionType" || n == "MethodType")
         {
             /* TODO: incomplete */
 
             toResolveTypes[id] = toResolveTypeItem(type, attr);
         }
         else if (n == "FunctionType" || n == "MethodType")
         {
             /* TODO: incomplete */
 

-            const wxString& ret = child->GetAttribute("returns", wxEmptyString);
-            if (id.IsEmpty() || ret.IsEmpty()) {
-                LogError("Invalid empty ret/id for '%s' node", n);
+            unsigned long ret = 0;
+            if (!getID(&ret, child->GetAttribute("returns")) || ret == 0) {
+                LogError("Invalid empty returns value for '%s' node", n);

                 return false;
             }
 
                 return false;
             }
 


@@ -650,22 +560,18 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
         }
         else if (n == "File")
         {
         }
         else if (n == "File")
         {

-            if (!id.StartsWith("f")) {
+            if (!child->GetAttribute("id").StartsWith("f")) {

                 LogError("Unexpected file ID: %s", id);
                 return false;
             }
 
             // just ignore this node... all file IDs/names were already parsed
                 LogError("Unexpected file ID: %s", id);
                 return false;
             }
 
             // just ignore this node... all file IDs/names were already parsed

-            files[id] = child->GetAttribute("name", "");
+            files[id] = child->GetAttribute("name");

         }
         else
         {
             // we register everything else as a possible return/argument type:
         }
         else
         {
             // we register everything else as a possible return/argument type:

-            const wxString& name = child->GetAttribute("name", wxEmptyString);
-            /*if (id.IsEmpty() || name.IsEmpty()) {
-                LogError("Invalid empty name/id for '%s' node", n);
-                return false;
-            }*/
+            const wxString& name = child->GetAttribute("name");

 
             if (!name.IsEmpty())
             {
 
             if (!name.IsEmpty())
             {


@@ -682,8 +588,6 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
                 if (g_verbose)
                     LogWarning("Type '%s' with ID '%s' does not have name attribute", n, id);
 
                 if (g_verbose)
                     LogWarning("Type '%s' with ID '%s' does not have name attribute", n, id);
 

-                //typeIds.Add(id);
-                //typeNames.Add("TOFIX");

                 types[id] = "TOFIX";
             }
         }
                 types[id] = "TOFIX";
             }
         }


@@ -706,10 +610,10 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
         for (wxToResolveTypeHashMap::iterator i = toResolveTypes.begin();
              i != toResolveTypes.end();)
         {
         for (wxToResolveTypeHashMap::iterator i = toResolveTypes.begin();
              i != toResolveTypes.end();)
         {

-            const wxString& id = i->first;
-            const wxString& referenced = i->second.ref;
+            unsigned long id = i->first;
+            unsigned long referenced = i->second.ref;

 
 

-            wxStringHashMap::iterator primary = types.find(referenced);
+            wxTypeIdHashMap::iterator primary = types.find(referenced);

             if (primary != types.end())
             {
                 // this to-resolve-type references a "primary" type
             if (primary != types.end())
             {
                 // this to-resolve-type references a "primary" type


@@ -766,58 +670,19 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
                 }
             }
         }
                 }
             }
         }

-/*
-        // now get the return types of all wx methods parsed above
-        child = doc.GetRoot()->GetChildren();
-        int idx;
-        while (child) {
-
-            wxString n = child->GetName();
-
-            if (n == "PointerType" || n == "ReferenceType" || n == "CvQualifiedType") {
-                wxString id = child->GetAttribute("id", wxEmptyString);
-                wxString type = child->GetAttribute("type", wxEmptyString);
-
-                // are we interested to this id?
-                while ((idx = retTypeIds.Index(id)) != wxNOT_FOUND)
-                {
-                    // substitute this ID with the ID referenced by this node
-                    retTypeIds[idx] = type;
-                    // leave "incompleteMethods" array untouched
-                }
-            } else {
-                wxString id = child->GetAttribute("id", wxEmptyString);
-                wxString name = child->GetAttribute("name", wxEmptyString);
-                if (!name.IsEmpty())
-                {
-                    // are we interested to this id?
-                    while ((idx = retTypeIds.Index(id)) != wxNOT_FOUND)
-                    {
-                        wxMethod *p = (wxMethod*)incompleteMethods[idx];
-                        p->SetFromString(name + " " + p->GetAsString());
-
-                        //LogMessage("rettype node is named %s and is '%s'", n,
-                        //           child->GetAttribute("name", ""));
-
-                        // prototype is now complete; remove it from the list of protos
-                        // waiting for completion
-                        retTypeIds.RemoveAt(idx);
-                        incompleteMethods.RemoveAt(idx);
-                    }
-                }
-            }
-
-            child = child->GetNext();
-
-            // give feedback to the user about the progress...
-            if ((++nodes%PROGRESS_RATE)==0) ShowProgress();
-        }*/

     }
 
     // resolve header names
     for (unsigned int i=0; i<m_classes.GetCount(); i++)
     {
     }
 
     // resolve header names
     for (unsigned int i=0; i<m_classes.GetCount(); i++)
     {

-        wxStringHashMap::const_iterator idx = files.find(m_classes[i].GetHeader());
+        unsigned long fileID = 0;
+        if (!getID(&fileID, m_classes[i].GetHeader()) || fileID == 0) {
+            LogError("invalid header id: %s", m_classes[i].GetHeader());
+            return false;
+        }
+
+        // search this file
+        wxTypeIdHashMap::const_iterator idx = files.find(fileID);

         if (idx == files.end())
         {
             // this is an error!
         if (idx == files.end())
         {
             // this is an error!


@@ -833,38 +698,38 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
     {
         wxString n = child->GetName();
 
     {
         wxString n = child->GetName();
 

-        if (n == "Method" || n == "Constructor" || n == "Destructor" || n == "OperatorMethod")
+        // only register public methods
+        if (child->GetAttribute("access") == "public" &&
+            (n == "Method" || n == "Constructor" || n == "Destructor" || n == "OperatorMethod"))

         {
         {

-            wxString id = child->GetAttribute("id", wxEmptyString);
+            unsigned long id = 0;
+            if (!getID(&id, child->GetAttribute("id"))) {
+                LogError("invalid ID for node '%s' with ID '%s'", n, child->GetAttribute("id"));
+                return false;
+            }

 
 

-            // only register public methods
-            if (child->GetAttribute("access", wxEmptyString) == "public")
+            wxClassMemberIdHashMap::const_iterator it = members.find(id);
+            if (it != members.end())

             {
             {

-                wxASSERT(arrMemberIds.GetCount()==m_classes.GetCount());
+                wxClass *p = it->second;

 
 

-                for (unsigned int i=0; i<m_classes.GetCount(); i++)
-                {
-                    if (arrMemberIds[i].Contains(id))
-                    {
-                        // this <Method> node is a method of the i-th class!
-                        wxMethod newfunc;
-                        if (!ParseMethod(child, types, newfunc))
-                            return false;
-
-                        if (newfunc.IsCtor() && !m_classes[i].IsValidCtorForThisClass(newfunc)) {
-                            LogError("The method '%s' does not seem to be a ctor for '%s'",
-                                     newfunc.GetName(), m_classes[i].GetName());
-                            return false;
-                        }
-                        if (newfunc.IsDtor() && !m_classes[i].IsValidDtorForThisClass(newfunc)) {
-                            LogError("The method '%s' does not seem to be a dtor for '%s'",
-                                     newfunc.GetName(), m_classes[i].GetName());
-                            return false;
-                        }
+                // this <Method> node is a method of the i-th class!
+                wxMethod newfunc;
+                if (!ParseMethod(child, types, newfunc))
+                    return false;

 
 

-                        m_classes[i].AddMethod(newfunc);
-                    }
+                if (newfunc.IsCtor() && !p->IsValidCtorForThisClass(newfunc)) {
+                    LogError("The method '%s' does not seem to be a ctor for '%s'",
+                                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'",
+                                newfunc.GetName(), p->GetName());
+                    return false;
+                }
+
+                p->AddMethod(newfunc);

             }
         }
 
             }
         }
 


@@ -882,11 +747,11 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
 }
 
 bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p,
 }
 
 bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p,

-                                    const wxStringHashMap& types,
+                                    const wxTypeIdHashMap& types,

                                     wxMethod& m)
 {
     // get the real name
                                     wxMethod& m)
 {
     // get the real name

-    wxString name = p->GetAttribute("name", wxEmptyString).Strip(wxString::both);
+    wxString name = p->GetAttribute("name").Strip(wxString::both);

     if (p->GetName() == "Destructor")
         name = "~" + name;
     else if (p->GetName() == "OperatorMethod")
     if (p->GetName() == "Destructor")
         name = "~" + name;
     else if (p->GetName() == "OperatorMethod")


@@ -894,18 +759,18 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p,
 
     // resolve return type
     wxType ret;
 
     // resolve return type
     wxType ret;

-    wxString retid = p->GetAttribute("returns", wxEmptyString);
-    if (retid.IsEmpty())
+    unsigned long retid = 0;
+    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'",
     {
         if (p->GetName() != "Destructor" && p->GetName() != "Constructor") {
             LogError("Empty return ID for method '%s', with ID '%s'",

-                     name, p->GetAttribute("id", ""));
+                     name, p->GetAttribute("id"));

             return false;
         }
     }
     else
     {
             return false;
         }
     }
     else
     {

-        wxStringHashMap::const_iterator retidx = types.find(retid);
+        wxTypeIdHashMap::const_iterator retidx = types.find(retid);

         if (retidx == types.end()) {
             LogError("Could not find return type ID '%s'", retid);
             return false;
         if (retidx == types.end()) {
             LogError("Could not find return type ID '%s'", retid);
             return false;


@@ -914,7 +779,7 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p,
         ret = wxType(retidx->second);
         if (!ret.IsOk()) {
             LogError("Invalid return type '%s' for method '%s', with ID '%s'",
         ret = wxType(retidx->second);
         if (!ret.IsOk()) {
             LogError("Invalid return type '%s' for method '%s', with ID '%s'",

-                     retidx->second, name, p->GetAttribute("id", ""));
+                     retidx->second, name, p->GetAttribute("id"));

             return false;
         }
     }
             return false;
         }
     }


@@ -927,8 +792,14 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p,
     {
         if (arg->GetName() == "Argument")
         {
     {
         if (arg->GetName() == "Argument")
         {

-            wxString id = arg->GetAttribute("type", wxEmptyString);
-            wxStringHashMap::const_iterator idx = types.find(id);
+            unsigned long id = 0;
+            if (!getID(&id, arg->GetAttribute("type")) || id == 0) {
+                LogError("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()) {
                 LogError("Could not find argument type ID '%s'", id);
                 return false;
             if (idx == types.end()) {
                 LogError("Could not find argument type ID '%s'", id);
                 return false;


@@ -936,7 +807,7 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p,
 
             argtypes.Add(wxType(idx->second));
 
 
             argtypes.Add(wxType(idx->second));
 

-            wxString def = arg->GetAttribute("default", "");
+            wxString def = arg->GetAttribute("default");

             if (def.Contains("wxGetTranslation"))
                 argdefs.Add(wxEmptyString);     // TODO: wxGetTranslation gives problems to gccxml
             else
             if (def.Contains("wxGetTranslation"))
                 argdefs.Add(wxEmptyString);     // TODO: wxGetTranslation gives problems to gccxml
             else


@@ -949,9 +820,9 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p,
     m.SetReturnType(ret);
     m.SetName(name);
     m.SetArgumentTypes(argtypes, argdefs);
     m.SetReturnType(ret);
     m.SetName(name);
     m.SetArgumentTypes(argtypes, argdefs);

-    m.SetConst(p->GetAttribute("const", "") == "1");
-    m.SetStatic(p->GetAttribute("static", "") == "1");
-    m.SetVirtual(p->GetAttribute("virtual", "") == "1");
+    m.SetConst(p->GetAttribute("const") == "1");
+    m.SetStatic(p->GetAttribute("static") == "1");
+    m.SetVirtual(p->GetAttribute("virtual") == "1");

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


@@ -991,9 +862,9 @@ bool wxXmlDoxygenInterface::Parse(const wxString& filename)
     while (compound)
     {
         if (compound->GetName() == "compound" &&
     while (compound)
     {
         if (compound->GetName() == "compound" &&

-            compound->GetAttribute("kind", "") == "class")
+            compound->GetAttribute("kind") == "class")

         {
         {

-            wxString refid = compound->GetAttribute("refid", "");
+            wxString refid = compound->GetAttribute("refid");

 
             wxFileName fn(filename);
             if (!ParseCompoundDefinition(fn.GetPath(wxPATH_GET_SEPARATOR) + refid + ".xml"))
 
             wxFileName fn(filename);
             if (!ParseCompoundDefinition(fn.GetPath(wxPATH_GET_SEPARATOR) + refid + ".xml"))


@@ -1035,7 +906,7 @@ bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename)
     while (child)
     {
         if (child->GetName() == "compounddef" &&
     while (child)
     {
         if (child->GetName() == "compounddef" &&

-            child->GetAttribute("kind", wxEmptyString) == "class")
+            child->GetAttribute("kind") == "class")

         {
             // parse this class
             wxClass klass;
         {
             // parse this class
             wxClass klass;


@@ -1045,14 +916,14 @@ bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename)
             while (subchild)
             {
                 if (subchild->GetName() == "sectiondef" &&
             while (subchild)
             {
                 if (subchild->GetName() == "sectiondef" &&

-                    subchild->GetAttribute("kind", wxEmptyString) == "public-func")
+                    subchild->GetAttribute("kind") == "public-func")

                 {
 
                     wxXmlNode *membernode = subchild->GetChildren();
                     while (membernode)
                     {
                         if (membernode->GetName() == "memberdef" &&
                 {
 
                     wxXmlNode *membernode = subchild->GetChildren();
                     while (membernode)
                     {
                         if (membernode->GetName() == "memberdef" &&

-                            membernode->GetAttribute("kind", wxEmptyString) == "function")
+                            membernode->GetAttribute("kind") == "function")

                         {
 
                             wxMethod m;
                         {
 
                             wxMethod m;


@@ -1187,18 +1058,18 @@ bool wxXmlDoxygenInterface::ParseMethod(const wxXmlNode* p, wxMethod& m, wxStrin
         }
         else if (child->GetName() == "location")
         {
         }
         else if (child->GetName() == "location")
         {

-            if (child->GetAttribute("line", "").ToLong(&line))
+            if (child->GetAttribute("line").ToLong(&line))

                 m.SetLocation((int)line);
                 m.SetLocation((int)line);

-            header = child->GetAttribute("file", "");
+            header = child->GetAttribute("file");

         }
 
         child = child->GetNext();
     }
 
     m.SetArgumentTypes(args, defs);
         }
 
         child = child->GetNext();
     }
 
     m.SetArgumentTypes(args, defs);

-    m.SetConst(p->GetAttribute("const", "")=="yes");
-    m.SetStatic(p->GetAttribute("static", "")=="yes");
-    m.SetVirtual(p->GetAttribute("virt", "")=="virtual");
+    m.SetConst(p->GetAttribute("const")=="yes");
+    m.SetStatic(p->GetAttribute("static")=="yes");
+    m.SetVirtual(p->GetAttribute("virt")=="virtual");

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