]> git.saurik.com Git - wxWidgets.git/blobdiff - utils/ifacecheck/src/xmlparser.cpp
Compilation fix.
[wxWidgets.git] / utils / ifacecheck / src / xmlparser.cpp
index f74f53e230d2960e0482ce84a72a53beba6a2b23..c36cc450d6ee6ce147208351121c24553f10cce3 100644 (file)
@@ -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
@@ -334,7 +337,7 @@ bool wxXmlInterface::CheckParseResults() const
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
-// wxXmlGccInterface
+// wxXmlGccInterface helper declarations
 // ----------------------------------------------------------------------------
 
 #define ATTRIB_CONST        1
 // ----------------------------------------------------------------------------
 
 #define ATTRIB_CONST        1
@@ -342,23 +345,100 @@ 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;
 };
 
 #if 1
 };
 
 #if 1
-WX_DECLARE_STRING_HASH_MAP( toResolveTypeItem, wxToResolveTypeHashMap );
+
+// 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>
 #else
 #include <map>
-typedef std::map<wxString, toResolveTypeItem> wxToResolveTypeHashMap;
+typedef std::map<unsigned long, toResolveTypeItem> wxToResolveTypeHashMap;
+#endif
+
+
+// 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
+
+    // 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;
+
+    *id = val;
+    return true;
+}
+
+// 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
+
+    if (len == 0 || str[0] != '_')
+        return false;
+
+    const wxStringCharType *curpos = str,
+                           *end = str + len;
+    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
+        unsigned long id = wcstoul(curpos+1, &nexttoken, GCCXML_BASE);
 #endif
 #endif
+        if ( *nexttoken != ' ' || errno == ERANGE || errno == EINVAL )
+            return false;
+
+        // advance current position
+        curpos = nexttoken + 1;
+
+        // add this ID to the hashmap
+        wxClassMemberIdHashMap::value_type v(id, p);
+        map->insert(v);
+    }
+
+    return true;
+}
+
+
+// ----------------------------------------------------------------------------
+// wxXmlGccInterface
+// ----------------------------------------------------------------------------
 
 bool wxXmlGccInterface::Parse(const wxString& filename)
 {
 
 bool wxXmlGccInterface::Parse(const wxString& filename)
 {
@@ -380,35 +460,64 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
     }
 
     wxToResolveTypeHashMap toResolveTypes;
     }
 
     wxToResolveTypeHashMap toResolveTypes;
-    wxArrayString arrMemberIds;
-    wxStringHashMap types;
-    wxStringHashMap files;
+    //wxArrayString arrMemberIds;
+    wxClassMemberIdHashMap members;
+    wxTypeIdHashMap types;
+    wxTypeIdHashMap files;
 
     // prealloc quite a lot of memory!
     m_classes.Alloc(ESTIMATED_NUM_CLASSES);
 
     // prealloc quite a lot of memory!
     m_classes.Alloc(ESTIMATED_NUM_CLASSES);
-    arrMemberIds.Alloc(ESTIMATED_NUM_TYPES);
+    //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);
+
+        unsigned long id = 0;
+        if (!getID(&id, child->GetAttribute("id")) || (id == 0 && n != "File")) {
+
+            // NOTE: <File> nodes can have an id == "f0"...
+
+            LogError("Invalid id for node %s: %s", n, child->GetAttribute("id"));
+            return false;
+        }
 
         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:
@@ -417,18 +526,18 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
         else if (n == "PointerType" || n == "ReferenceType" ||
                  n == "CvQualifiedType" || n == "ArrayType")
         {
         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;
                 attr = ATTRIB_CONST;
             else if (n == "ArrayType")
                 attr = ATTRIB_ARRAY;
@@ -440,9 +549,9 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
         {
             /* TODO: incomplete */
 
         {
             /* 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;
             }
 
@@ -451,18 +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);
+            const wxString& name = child->GetAttribute("name");
 
             if (!name.IsEmpty())
             {
 
             if (!name.IsEmpty())
             {
@@ -501,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
@@ -566,7 +675,14 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
     // 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!
@@ -582,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);
             }
         }
 
             }
         }
 
@@ -631,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")
@@ -643,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;
@@ -663,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;
         }
     }
@@ -676,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;
@@ -685,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
@@ -698,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());
@@ -740,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"))
@@ -784,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;
@@ -794,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;
@@ -936,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());