X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/74bda2038c4bf33ebb99dbdfaca2801329c301e2..f3fda1aa01b9036e9050813a2af62c2544984087:/utils/ifacecheck/src/xmlparser.cpp diff --git a/utils/ifacecheck/src/xmlparser.cpp b/utils/ifacecheck/src/xmlparser.cpp index c36cc450d6..7b29c794ff 100644 --- a/utils/ifacecheck/src/xmlparser.cpp +++ b/utils/ifacecheck/src/xmlparser.cpp @@ -21,25 +21,23 @@ #include "wx/xml/xml.h" #include "wx/wfstream.h" -#include "wx/arrimpl.cpp" -#include "wx/dynarray.h" +#include "wx/hashmap.h" #include "wx/filename.h" - -#include - #include "xmlparser.h" +#include -#define PROGRESS_RATE 1000 // each PROGRESS_RATE nodes processed print a dot -#define ESTIMATED_NUM_CLASSES 600 // used by both wxXmlInterface-derived classes to prealloc mem -#define ESTIMATED_NUM_TYPES 50000 // used only by wxGccXmlInterface to prealloc mem -#define ESTIMATED_NUM_FILES 800 // used only by wxGccXmlInterface to prealloc mem - +#include WX_DEFINE_OBJARRAY(wxTypeArray) +WX_DEFINE_OBJARRAY(wxArgumentTypeArray) WX_DEFINE_OBJARRAY(wxMethodArray) WX_DEFINE_OBJARRAY(wxClassArray) -// declared in ifacecheck.cpp +#define PROGRESS_RATE 1000 // each PROGRESS_RATE nodes processed print a dot +#define ESTIMATED_NUM_CLASSES 600 // used by both wxXmlInterface-derived classes to prealloc mem + + +// defined in ifacecheck.cpp extern bool g_verbose; @@ -50,12 +48,41 @@ extern bool g_verbose; wxType wxEmptyType; -void wxType::SetFromString(const wxString& t) +void wxType::SetTypeFromString(const wxString& t) { - m_strType = t.Strip(wxString::both); + /* + TODO: optimize the following code writing a single function + which works at char-level and does everything in a single pass + */ + + 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" + + // make sure the * and & operator always use the same spacing rules + // (to make sure GetAsString() output is always consistent) + m_strType.Replace("*", "* "); + m_strType.Replace("&", "& "); + m_strType.Replace(" *", "*"); + m_strType.Replace(" &", "&"); + + while (m_strType.Contains(" ")) + m_strType.Replace(" ", " "); // do it once again + + m_strType.Replace(" ,", ","); + + m_strType = m_strType.Strip(wxString::both); + + // now set the clean version + m_strTypeClean = m_strType; + m_strTypeClean.Replace("const", ""); + m_strTypeClean.Replace("static", ""); + m_strTypeClean.Replace("*", ""); + m_strTypeClean.Replace("&", ""); + m_strTypeClean.Replace("[]", ""); + m_strTypeClean = m_strTypeClean.Strip(wxString::both); } bool wxType::IsOk() const @@ -64,25 +91,14 @@ bool wxType::IsOk() const // "reverse_iterator_impl" type // It can also contain commas, * and & operators etc - return !GetClean().IsEmpty(); -} - -wxString wxType::GetClean() const -{ - wxString ret(m_strType); - ret.Replace("const", ""); - ret.Replace("static", ""); - ret.Replace("*", ""); - ret.Replace("&", ""); - ret.Replace("[]", ""); - return ret.Strip(wxString::both); + return !m_strTypeClean.IsEmpty(); } bool wxType::operator==(const wxType& m) const { // brain-dead comparison: - if (GetClean() == m.GetClean() && + if (m_strTypeClean == m.m_strTypeClean && IsConst() == m.IsConst() && IsStatic() == m.IsStatic() && IsPointer() == m.IsPointer() && @@ -92,6 +108,62 @@ bool wxType::operator==(const wxType& m) const return false; } + +// ---------------------------------------------------------------------------- +// wxArgumentType +// ---------------------------------------------------------------------------- + +void wxArgumentType::SetDefaultValue(const wxString& defval, const wxString& defvalForCmp) +{ + m_strDefaultValue=defval.Strip(wxString::both); + m_strDefaultValueForCmp=defvalForCmp.Strip(wxString::both); + + // in order to make valid&simple comparison on argument defaults, + // we reduce some of the multiple forms in which the same things may appear + // to a single form: + if (m_strDefaultValue == "0u") + m_strDefaultValue = "0"; +/* + if (IsPointer()) + m_strDefaultValue.Replace("0", "NULL"); + else + m_strDefaultValue.Replace("NULL", "0"); +*/ + + if (m_strDefaultValue.Contains("wxGetTranslation")) + m_strDefaultValue = "_(TOFIX)"; // TODO: wxGetTranslation gives problems to gccxml +} + +bool wxArgumentType::operator==(const wxArgumentType& m) const +{ + if ((const wxType&)(*this) != (const wxType&)m) + return false; + + const wxString& def1 = m_strDefaultValueForCmp.IsEmpty() ? m_strDefaultValue : m_strDefaultValueForCmp; + const wxString& def2 = m.m_strDefaultValueForCmp.IsEmpty() ? m.m_strDefaultValue : m.m_strDefaultValueForCmp; + + if (def1 != def2) + { + // maybe the default values are numbers. + // in this case gccXML gives as default values things like '-0x0000001' instead of just '-1'. + // To handle these cases, we try to convert the default value strings to numbers: + long def1val, def2val; + if (def1.ToLong(&def1val, 0 /* auto-detect */) && + def2.ToLong(&def2val, 0 /* auto-detect */)) + { + if (def1val == def2val) + return true; // the default values match + } + + return false; + } + + // we deliberately avoid checks on the argument name + + return true; +} + + // ---------------------------------------------------------------------------- // wxMethod // ---------------------------------------------------------------------------- @@ -109,40 +181,40 @@ bool wxMethod::IsOk() const return false; // a function can't be both const and static or virtual and static! - if ((m_bConst && m_bStatic) || (m_bVirtual && m_bStatic)) { + 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); return false; } + wxASSERT(!m_bPureVirtual || (m_bPureVirtual && m_bVirtual)); + for (unsigned int i=0; i) - // so we don't do any test on them. - - return true; -} - -void wxMethod::SetArgumentTypes(const wxTypeArray& arr, const wxArrayString& defaults) -{ - wxASSERT(arr.GetCount()==defaults.GetCount()); - - m_args=arr; - m_argDefaults=defaults; - - // 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 - for (unsigned int i=0; i0) { - m_argDefaults[i].Replace("NULL", "0"); - m_argDefaults[i].Replace("0u", "0"); + bool previousArgHasDefault = m_args[0].HasDefaultValue(); + for (unsigned int i=1; i0) - ret.RemoveLast(); + ret = ret.Left(ret.Len()-2); ret += ")"; @@ -191,8 +272,14 @@ wxString wxMethod::GetAsString() const ret += " const"; if (m_bStatic) ret = "static " + ret; - if (m_bVirtual) + if (m_bVirtual || m_bPureVirtual) ret = "virtual " + ret; + if (m_bPureVirtual) + ret = ret + " = 0"; + + // in doxygen headers we don't need wxDEPRECATED: + //if (m_bDeprecated) + // ret = "wxDEPRECATED( " + ret + " )"; return ret; } @@ -203,7 +290,8 @@ void wxMethod::Dump(wxTextOutputStream& stream) const stream << "[" + m_strName + "]"; for (unsigned int i=0; i wxToResolveTypeHashMap; bool getID(unsigned long *id, const wxStringCharType* str) { wxStringCharType *end; -#if wxUSE_UNICODE_UTF8 - unsigned long val = strtoul(str+1, &end, GCCXML_BASE); -#else +#if wxUSE_UNICODE_WCHAR unsigned long val = wcstoul(str+1, &end, GCCXML_BASE); +#else + unsigned long val = strtoul(str+1, &end, GCCXML_BASE); #endif // return true only if scan was stopped by the terminating NUL and @@ -400,10 +504,10 @@ bool getID(unsigned long *id, const wxStringCharType* str) // in nodes like ones... i.e. numeric values separed by " _" token bool getMemberIDs(wxClassMemberIdHashMap* map, wxClass* p, const wxStringCharType* str) { -#if wxUSE_UNICODE_UTF8 - size_t len = strlen(str); -#else +#if wxUSE_UNICODE_WCHAR size_t len = wcslen(str); +#else + size_t len = strlen(str); #endif if (len == 0 || str[0] != '_') @@ -416,10 +520,10 @@ bool getMemberIDs(wxClassMemberIdHashMap* map, wxClass* p, const wxStringCharTyp while (curpos < end) { // curpos always points to the underscore of the next token to parse: -#if wxUSE_UNICODE_UTF8 - unsigned long id = strtoul(curpos+1, &nexttoken, GCCXML_BASE); -#else +#if wxUSE_UNICODE_WCHAR unsigned long id = wcstoul(curpos+1, &nexttoken, GCCXML_BASE); +#else + unsigned long id = strtoul(curpos+1, &nexttoken, GCCXML_BASE); #endif if ( *nexttoken != ' ' || errno == ERANGE || errno == EINVAL ) return false; @@ -459,15 +563,38 @@ bool wxXmlGccInterface::Parse(const wxString& filename) return false; } + wxString version = doc.GetRoot()->GetAttribute("cvs_revision"); + bool old = false; + +#define MIN_REVISION 120 + + if (!version.StartsWith("1.")) + old = true; + if (!old) + { + unsigned long rev = 0; + if (!version.Mid(2).ToULong(&rev)) + old = true; + else + if (rev < MIN_REVISION) + old = true; + } + + if (old) + { + LogError("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; + } + 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(); @@ -502,7 +629,7 @@ bool wxXmlGccInterface::Parse(const wxString& filename) if (ids.IsEmpty()) { if (child->GetAttribute("incomplete") != "1") { - LogError("Invalid member IDs for '%s' class node (ID %s)", + LogError("Invalid member IDs for '%s' class node: %s", cname, child->GetAttribute("id")); return false; } @@ -513,7 +640,7 @@ bool wxXmlGccInterface::Parse(const wxString& filename) { // decode the non-empty list of IDs: if (!getMemberIDs(&members, &m_classes.Last(), ids)) { - LogError("Invalid member IDs for '%s' class node (ID %s)", + LogError("Invalid member IDs for '%s' class node: %s", cname, child->GetAttribute("id")); return false; } @@ -547,21 +674,31 @@ bool wxXmlGccInterface::Parse(const wxString& filename) } else if (n == "FunctionType" || n == "MethodType") { - /* TODO: incomplete */ - - unsigned long ret = 0; - if (!getID(&ret, child->GetAttribute("returns")) || ret == 0) { - LogError("Invalid empty returns value for '%s' node", n); - return false; + /* + TODO: parsing FunctionType and MethodType nodes is not as easy + as for other "simple" types. + */ + + wxString argstr; + wxXmlNode *arg = child->GetChildren(); + while (arg) + { + if (arg->GetName() == "Argument") + argstr += arg->GetAttribute("type") + ", "; + arg = arg->GetNext(); } + if (argstr.Len() > 0) + argstr = argstr.Left(argstr.Len()-2); + // these nodes make reference to other types... we'll resolve them later - toResolveTypes[id] = toResolveTypeItem(ret, 0); + //toResolveTypes[id] = toResolveTypeItem(ret, 0); + types[id] = child->GetAttribute("returns") + "(" + argstr + ")"; } else if (n == "File") { if (!child->GetAttribute("id").StartsWith("f")) { - LogError("Unexpected file ID: %s", id); + LogError("Unexpected file ID: %s", child->GetAttribute("id")); return false; } @@ -586,7 +723,8 @@ bool wxXmlGccInterface::Parse(const wxString& filename) // they're never used as return/argument types by wxWidgets methods if (g_verbose) - LogWarning("Type '%s' with ID '%s' does not have name attribute", n, id); + LogWarning("Type node '%s' with ID '%s' does not have name attribute", + n, child->GetAttribute("id")); types[id] = "TOFIX"; } @@ -618,17 +756,18 @@ bool wxXmlGccInterface::Parse(const wxString& filename) { // this to-resolve-type references a "primary" type - wxString newtype; + wxString newtype = primary->second; int attribs = i->second.attribs; + // attribs may contain a combination of ATTRIB_* flags: if (attribs & ATTRIB_CONST) - newtype = "const " + primary->second; + newtype = "const " + newtype; if (attribs & ATTRIB_REFERENCE) - newtype = primary->second + "&"; + newtype = newtype + "&"; if (attribs & ATTRIB_POINTER) - newtype = primary->second + "*"; + newtype = newtype + "*"; if (attribs & ATTRIB_ARRAY) - newtype = primary->second + "[]"; + newtype = newtype + "[]"; // add the resolved type to the list of "primary" types types[id] = newtype; @@ -654,19 +793,8 @@ bool wxXmlGccInterface::Parse(const wxString& filename) } else { -#if 1 LogError("Cannot solve '%s' reference type!", referenced); return false; -#else - typeIds.Add(toResolveTypeIds[i]); - typeNames.Add("TOFIX"); - - // this one has been resolved! - toResolveTypeIds.RemoveAt(i); - toResolveRefType.RemoveAt(i); - toResolveAttrib.RemoveAt(i); - n--; -#endif } } } @@ -715,17 +843,20 @@ bool wxXmlGccInterface::Parse(const wxString& filename) // this node is a method of the i-th class! wxMethod newfunc; - if (!ParseMethod(child, types, newfunc)) + if (!ParseMethod(child, types, newfunc)) { + LogError("The method '%s' could not be added to class '%s'", + child->GetAttribute("demangled"), p->GetName()); return false; + } if (newfunc.IsCtor() && !p->IsValidCtorForThisClass(newfunc)) { LogError("The method '%s' does not seem to be a ctor for '%s'", - newfunc.GetName(), p->GetName()); + 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()); + newfunc.GetName(), p->GetName()); return false; } @@ -739,7 +870,6 @@ bool wxXmlGccInterface::Parse(const wxString& filename) if ((++nodes%PROGRESS_RATE)==0) ShowProgress(); } - //wxPrint("\n"); if (!CheckParseResults()) return false; @@ -785,8 +915,7 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p, } // resolve argument types - wxTypeArray argtypes; - wxArrayString argdefs; + wxArgumentTypeArray argtypes; wxXmlNode *arg = p->GetChildren(); while (arg) { @@ -805,13 +934,7 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p, return false; } - argtypes.Add(wxType(idx->second)); - - wxString def = arg->GetAttribute("default"); - if (def.Contains("wxGetTranslation")) - argdefs.Add(wxEmptyString); // TODO: wxGetTranslation gives problems to gccxml - else - argdefs.Add(def); + argtypes.Add(wxArgumentType(idx->second, arg->GetAttribute("default"))); } arg = arg->GetNext(); @@ -819,10 +942,18 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p, m.SetReturnType(ret); m.SetName(name); - m.SetArgumentTypes(argtypes, argdefs); + m.SetArgumentTypes(argtypes); m.SetConst(p->GetAttribute("const") == "1"); m.SetStatic(p->GetAttribute("static") == "1"); + + // NOTE: gccxml is smart enough to mark as virtual those functions + // which are declared virtual in base classes but don't have + // the "virtual" keyword explicitely indicated in the derived + // classes... so we don't need any further logic for virtuals + m.SetVirtual(p->GetAttribute("virtual") == "1"); + m.SetPureVirtual(p->GetAttribute("pure_virtual") == "1"); + m.SetDeprecated(p->GetAttribute("attributes") == "deprecated"); if (!m.IsOk()) { LogError("The prototype '%s' is not valid!", m.GetAsString()); @@ -833,6 +964,121 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p, } + +// ---------------------------------------------------------------------------- +// wxXmlDoxygenInterface global helpers +// ---------------------------------------------------------------------------- + +static wxString GetTextFromChildren(const wxXmlNode *n) +{ + wxString text; + + // consider the tree + // + // this is a string + // + // + // |- + // | |- this + // |- is a + // |- + // |- string + // + // unlike wxXmlNode::GetNodeContent() which would return " is a " + // this function returns "this is a string" + + wxXmlNode *ref = n->GetChildren(); + while (ref) { + if (ref->GetType() == wxXML_ELEMENT_NODE) + text += ref->GetNodeContent(); + else if (ref->GetType() == wxXML_TEXT_NODE) + text += ref->GetContent(); + else + LogWarning("Unexpected node type while getting text from '%s' node", n->GetName()); + + ref = ref->GetNext(); + } + + return text; +} + +static bool HasTextNodeContaining(const wxXmlNode *parent, const wxString& name) +{ + if (!parent) + return false; + + wxXmlNode *p = parent->GetChildren(); + while (p) + { + switch (p->GetType()) + { + case wxXML_TEXT_NODE: + if (p->GetContent() == name) + return true; + break; + + case wxXML_ELEMENT_NODE: + // recurse into this node... + if (HasTextNodeContaining(p, name)) + return true; + break; + + default: + // skip it + break; + } + + p = p->GetNext(); + } + + return false; +} + +static const wxXmlNode* FindNodeNamed(const wxXmlNode* parent, const wxString& name) +{ + if (!parent) + return NULL; + + const wxXmlNode *p = parent->GetChildren(); + while (p) + { + if (p->GetName() == name) + return p; // found! + + // search recursively in the children of this node + const wxXmlNode *ret = FindNodeNamed(p, name); + if (ret) + return ret; + + p = p->GetNext(); + } + + return NULL; +} + +int GetAvailabilityFor(const wxXmlNode *node) +{ + // identify custom XML tags + const wxXmlNode* onlyfor = FindNodeNamed(node, "onlyfor"); + if (!onlyfor) + return wxPORT_UNKNOWN; + + wxArrayString ports = wxSplit(onlyfor->GetNodeContent(), ','); + int nAvail = wxPORT_UNKNOWN; + for (unsigned int i=0; i < ports.GetCount(); i++) + { + if (!ports[i].StartsWith("wx")) { + LogError("unexpected port ID '%s'", ports[i]); + return false; + } + + nAvail |= wxPlatformInfo::GetPortId(ports[i].Mid(2)); + } + + return nAvail; +} + + // ---------------------------------------------------------------------------- // wxXmlDoxygenInterface // ---------------------------------------------------------------------------- @@ -855,6 +1101,13 @@ bool wxXmlDoxygenInterface::Parse(const wxString& filename) return false; } + /* + NB: we may need in future to do a version-check here if the + format of the XML generated by doxygen changes. + For now (doxygen version 1.5.5), this check is not required + since AFAIK the XML format never changed since it was introduced. + */ + m_classes.Alloc(ESTIMATED_NUM_CLASSES); // process files referenced by this index file @@ -927,20 +1180,23 @@ bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename) { wxMethod m; - if (ParseMethod(membernode, m, header)) + if (!ParseMethod(membernode, m, header)) { + LogError("The method '%s' could not be added to class '%s'", + m.GetName(), klass.GetName()); + return false; + } + + if (absoluteFile.IsEmpty()) + absoluteFile = header; + else if (header != absoluteFile) { - if (absoluteFile.IsEmpty()) - absoluteFile = header; - else if (header != absoluteFile) - { - LogError("The method '%s' is documented in a different " - "file from others (which belong to '%s') ?", - header, absoluteFile); - return false; - } - - klass.AddMethod(m); + LogError("The method '%s' is documented in a different " + "file from others (which belong to '%s') ?", + header, absoluteFile); + return false; } + + klass.AddMethod(m); } membernode = membernode->GetNext(); @@ -962,6 +1218,11 @@ bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename) klass.SetHeader(subchild->GetNodeContent()); }*/ + else if (subchild->GetName() == "detaileddescription") + { + // identify custom XML tags + klass.SetAvailability(GetAvailabilityFor(subchild)); + } subchild = subchild->GetNext(); } @@ -983,43 +1244,9 @@ bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename) return true; } -static wxString GetTextFromChildren(const wxXmlNode *n) -{ - wxString text; - - // consider the tree - // - // this is a string - // - // - // |- - // | |- this - // |- is a - // |- - // |- string - // - // unlike wxXmlNode::GetNodeContent() which would return " is a " - // this function returns "this is a string" - - wxXmlNode *ref = n->GetChildren(); - while (ref) { - if (ref->GetType() == wxXML_ELEMENT_NODE) - text += ref->GetNodeContent(); - else if (ref->GetType() == wxXML_TEXT_NODE) - text += ref->GetContent(); - else - LogWarning("Unexpected node type while getting text from '%s' node", n->GetName()); - - ref = ref->GetNext(); - } - - return text; -} - bool wxXmlDoxygenInterface::ParseMethod(const wxXmlNode* p, wxMethod& m, wxString& header) { - wxTypeArray args; - wxArrayString defs; + wxArgumentTypeArray args; long line; wxXmlNode *child = p->GetChildren(); @@ -1031,7 +1258,7 @@ bool wxXmlDoxygenInterface::ParseMethod(const wxXmlNode* p, wxMethod& m, wxStrin m.SetReturnType(wxType(GetTextFromChildren(child))); else if (child->GetName() == "param") { - wxString typestr, defstr, arrstr; + wxString typestr, namestr, defstr, arrstr; wxXmlNode *n = child->GetChildren(); while (n) { @@ -1039,9 +1266,10 @@ bool wxXmlDoxygenInterface::ParseMethod(const wxXmlNode* p, wxMethod& m, wxStrin // if the node has children, they should be all TEXT and nodes // and we need to take the text they contain, in the order they appear typestr = GetTextFromChildren(n); + else if (n->GetName() == "declname") + namestr = GetTextFromChildren(n); else if (n->GetName() == "defval") - // same for the node - defstr = GetTextFromChildren(n); + defstr = GetTextFromChildren(n).Strip(wxString::both); else if (n->GetName() == "array") arrstr = GetTextFromChildren(n); @@ -1053,23 +1281,48 @@ bool wxXmlDoxygenInterface::ParseMethod(const wxXmlNode* p, wxMethod& m, wxStrin return false; } - args.Add(wxType(typestr + arrstr)); - defs.Add(defstr); + wxArgumentType newarg(typestr + arrstr, defstr, namestr); + + // can we use preprocessor output to transform the default value + // into the same form which gets processed by wxXmlGccInterface? + wxStringHashMap::const_iterator it = m_preproc.find(defstr); + if (it != m_preproc.end()) + newarg.SetDefaultValue(defstr, it->second); + + args.Add(newarg); } else if (child->GetName() == "location") { + line = -1; if (child->GetAttribute("line").ToLong(&line)) m.SetLocation((int)line); header = child->GetAttribute("file"); } + else if (child->GetName() == "detaileddescription") + { + // when a method has a @deprecated tag inside its description, + // Doxygen outputs somewhere nested inside + // a Deprecated tag. + m.SetDeprecated(HasTextNodeContaining(child, "Deprecated")); + + // identify custom XML tags + m.SetAvailability(GetAvailabilityFor(child)); + } child = child->GetNext(); } - m.SetArgumentTypes(args, defs); + m.SetArgumentTypes(args); m.SetConst(p->GetAttribute("const")=="yes"); m.SetStatic(p->GetAttribute("static")=="yes"); + + // NOTE: Doxygen is smart enough to mark as virtual those functions + // which are declared virtual in base classes but don't have + // the "virtual" keyword explicitely indicated in the derived + // classes... so we don't need any further logic for virtuals + m.SetVirtual(p->GetAttribute("virt")=="virtual"); + m.SetPureVirtual(p->GetAttribute("virt")=="pure-virtual"); if (!m.IsOk()) { LogError("The prototype '%s' is not valid!", m.GetAsString());