X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/5934cda171bc0535abd044da92f3728524a11faf..6b03a638a437316e47f02a896d3ad664d59c6ddb:/utils/ifacecheck/src/xmlparser.cpp?ds=sidebyside diff --git a/utils/ifacecheck/src/xmlparser.cpp b/utils/ifacecheck/src/xmlparser.cpp index b768a519ec..3942535b1f 100644 --- a/utils/ifacecheck/src/xmlparser.cpp +++ b/utils/ifacecheck/src/xmlparser.cpp @@ -21,24 +21,28 @@ #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 "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; +// global variable: +bool g_bLogEnabled = true; + // ---------------------------------------------------------------------------- @@ -47,12 +51,53 @@ 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); + + // to avoid false errors types like wxStandardPaths and wxStandardPathsBase + // need to be considered as the same type + if (m_strTypeClean.EndsWith("Base")) + m_strTypeClean = m_strTypeClean.Left(m_strTypeClean.Len()-4); + + // 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::", ""); } bool wxType::IsOk() const @@ -61,188 +106,229 @@ 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() && IsReference() == m.IsReference()) return true; + if (g_verbose) + LogMessage("Type '%s' does not match type '%s'", m_strType, m.m_strType); + return false; } + // ---------------------------------------------------------------------------- -// wxMethod +// wxArgumentType // ---------------------------------------------------------------------------- -bool wxMethod::IsOk() const +void wxArgumentType::SetDefaultValue(const wxString& defval, const wxString& defvalForCmp) { - // 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()); - return false; - } + m_strDefaultValue = defval.Strip(wxString::both); + m_strDefaultValueForCmp = defvalForCmp.IsEmpty() ? m_strDefaultValue : defvalForCmp.Strip(wxString::both); - if (m_strName.IsEmpty()) - return false; + // 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"; - // a function can't be both const and static or virtual and static! - if ((m_bConst && m_bStatic) || (m_bVirtual && m_bStatic)) { - LogError("'%s' method can't be both const/static or virtual/static", m_strName); - return false; + // 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"; + + // fix for unicode strings: + m_strDefaultValueForCmp.Replace("\\000\\000\\000", ""); + + if (m_strDefaultValueForCmp.StartsWith("wxT(") && + m_strDefaultValueForCmp.EndsWith(")")) + { + // get rid of the wxT() part + unsigned int len = m_strDefaultValueForCmp.Len(); + m_strDefaultValueForCmp = m_strDefaultValueForCmp.Mid(4,len-5); } - for (unsigned int i=0; i) - // so we don't do any test on them. + m_strDefaultValueForCmp.Replace("wxGet_wxConvLocal()", "wxConvLocal"); - return true; + m_strDefaultValueForCmp.Replace("* GetColour(COLOUR_BLACK)", "*wxBLACK"); + + // ADHOC-FIX: + if (m_strDefaultValueForCmp.Contains("wxGetTranslation")) + m_strDefaultValueForCmp = "_(TOFIX)"; // TODO: wxGetTranslation gives problems to gccxml } -void wxMethod::SetArgumentTypes(const wxTypeArray& arr, const wxArrayString& defaults) +bool wxArgumentType::operator==(const wxArgumentType& m) const { - wxASSERT(arr.GetCount()==defaults.GetCount()); + if ((const wxType&)(*this) != (const wxType&)m) + return false; - m_args=arr; - m_argDefaults=defaults; + // ADHOC-FIX: + // default values for style attributes of wxWindow-derived classes in gccxml appear as raw + // numbers; avoid false positives in this case! + if (m_strArgName == m.m_strArgName && m_strArgName == "style" && + (m_strDefaultValueForCmp.IsNumber() || m.m_strDefaultValueForCmp.IsNumber())) + return true; - // 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; i) + // so we don't do any test on their contents + if (m_args.GetCount()>0) { - 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 + bool previousArgHasDefault = m_args[0].HasDefaultValue(); + for (unsigned int i=1; i0) - ret.RemoveLast(); + ret = ret.Left(ret.Len()-2); ret += ")"; @@ -266,8 +360,28 @@ 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 += " = 0"; + if (m_bDeprecated && bDeprecated) + ret += " [deprecated]"; + + if (bAccessSpec) + { + switch (m_access) + { + case wxMAS_PUBLIC: + ret += " [public]"; + break; + case wxMAS_PROTECTED: + ret += " [protected]"; + break; + case wxMAS_PRIVATE: + ret += " [private]"; + break; + } + } return ret; } @@ -278,7 +392,8 @@ void wxMethod::Dump(wxTextOutputStream& stream) const stream << "[" + m_strName + "]"; for (unsigned int i=0; im_methods.RemoveAt(j); + j--; } return true; @@ -359,7 +480,7 @@ const wxMethod* wxClass::FindMethod(const wxMethod& m) const return NULL; } -wxMethodPtrArray wxClass::FindMethodNamed(const wxString& name) const +wxMethodPtrArray wxClass::FindMethodsNamed(const wxString& name) const { wxMethodPtrArray ret; @@ -402,38 +523,132 @@ void wxXmlInterface::Dump(const wxString& filename) bool wxXmlInterface::CheckParseResults() const { // this check can be quite slow, so do it only for debug releases: -#ifdef __WXDEBUG__ +//#ifdef __WXDEBUG__ for (unsigned int i=0; iattrib: #define ATTRIB_CONST 1 #define ATTRIB_REFERENCE 2 #define ATTRIB_POINTER 4 #define ATTRIB_ARRAY 8 +#define GCCXML_BASE 35 + 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, // the referenced type's ID + attribs; // the attributes of this reference }; -//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 -typedef std::map wxToResolveTypeHashMap; +typedef std::map 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_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 + // 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 ones... i.e. numeric values separed by " _" token +bool getMemberIDs(wxClassMemberIdHashMap* map, wxClass* p, const wxStringCharType* str) +{ +#if wxUSE_UNICODE_WCHAR + size_t len = wcslen(str); +#else + size_t len = strlen(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_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; + + // 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) { @@ -454,218 +669,173 @@ bool wxXmlGccInterface::Parse(const wxString& filename) return false; } - wxToResolveTypeHashMap toResolveTypes; - wxArrayString arrMemberIds; - wxStringHashMap types; - wxStringHashMap files; + wxString version = doc.GetRoot()->GetAttribute("cvs_revision"); + bool old = false; - // prealloc quite a lot of memory! - m_classes.Alloc(ESTIMATED_NUM_CLASSES); - arrMemberIds.Alloc(ESTIMATED_NUM_TYPES); +#define MIN_REVISION 120 -#if 0 - // do a quick parsing of the 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 node - - // here starts the node block - while (child) + if (!version.StartsWith("1.")) + old = true; + if (!old) { - wxString id = child->GetAttribute("id", ""); - if (!id.StartsWith("f")) { - LogError("Unexpected file ID: %s", id); - return false; - } - - fileIds.Add(id); - fileNames.Add(child->GetAttribute("name", "")); - - 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(); - } - - 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); - - wxXmlNode *arg = child->GetChildren(); - while (arg) - { - if (arg->GetName() == "Argument") - allWxMethodsIds += " " + arg->GetAttribute("type", wxEmptyString); - - arg = arg->GetNext(); - } - } - } - - child = child->GetNext(); - } - - child = doc.GetRoot()->GetChildren(); - while (child) - { - if (allWxMethodsIds.Contains(child->GetAttribute("id", wxEmptyString))) - { - const wxString& type = child->GetAttribute("type", wxEmptyString); - allWxReferencesIds += " " + type; - } - - child = child->GetNext(); + unsigned long rev = 0; + if (!version.Mid(2).ToULong(&rev)) + old = true; + else + if (rev < MIN_REVISION) + old = true; } - child = doc.GetRoot()->GetChildren(); - while (child) + if (old) { - if (allWxReferencesIds.Contains(child->GetAttribute("id", wxEmptyString))) - { - const wxString& type = child->GetAttribute("type", wxEmptyString); - allWxReferencesIds += " " + type; - } - - child = child->GetNext(); + 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; } - LogMessage("adfafdasfdas %d-%d-%d", allWxClassesIds.Len(), - allWxMethodsIds.Len(), allWxReferencesIds.Len()); -#endif + wxToResolveTypeHashMap toResolveTypes; + wxClassMemberIdHashMap members; + wxTypeIdHashMap types; + wxTypeIdHashMap files; + wxTypeIdHashMap typedefs; + // prealloc quite a lot of memory! + m_classes.Alloc(ESTIMATED_NUM_CLASSES); // 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: 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") { - 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.StartsWith("wx")) { - arrMemberIds.Add(child->GetAttribute("members", wxEmptyString)); - + if (cname.StartsWith("wx")) + { // 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: %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: %s", + cname, child->GetAttribute("id")); + return false; + } + } } // register this class also as possible return/argument type: - //typeIds.Add(child->GetAttribute("id", wxEmptyString)); - //typeNames.Add(cname); types[id] = cname; } + else if (n == "Typedef") + { + unsigned long typeId = 0; + if (!getID(&typeId, child->GetAttribute("type"))) { + LogError("Invalid type for node %s: %s", n, child->GetAttribute("type")); + return false; + } + + // this typedef node tell us that every type referenced with the + // "typeId" ID should be called with another name: + wxString name = child->GetAttribute("name"); + + // save this typedef in a separate hashmap... + typedefs[typeId] = name; + + types[id] = name; + } else if (n == "PointerType" || n == "ReferenceType" || n == "CvQualifiedType" || n == "ArrayType") { - 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; } - int attr = 0; + unsigned long attr = 0; 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 - //toResolveTypeIds.Add(id); - //toResolveRefType.Add(type); - //toResolveAttrib.Add(attr); 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); - 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); // remove final comma + // 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 + ")"; + + types[id] = "TOFIX"; // typically this type will be "fixed" thanks + // to a typedef later... } else if (n == "File") { - if (!id.StartsWith("f")) { - LogError("Unexpected file ID: %s", id); + if (!child->GetAttribute("id").StartsWith("f")) { + LogError("Unexpected file ID: %s", child->GetAttribute("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: - 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()) { @@ -680,10 +850,9 @@ 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")); - //typeIds.Add(id); - //typeNames.Add("TOFIX"); types[id] = "TOFIX"; } } @@ -695,7 +864,7 @@ bool wxXmlGccInterface::Parse(const wxString& filename) } // some nodes with IDs referenced by methods as return/argument types, do reference - // in turn o ther nodes (see PointerType, ReferenceType and CvQualifierType above); + // in turn other nodes (see PointerType, ReferenceType and CvQualifierType above); // thus we need to resolve their name iteratively: while (toResolveTypes.size()>0) { @@ -706,28 +875,32 @@ bool wxXmlGccInterface::Parse(const wxString& filename) 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 - 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; + if (newtype.Contains("TOFIX") && typedefs[id] != "") + types[id] = typedefs[id]; // better use a typedef for this type! + else + types[id] = newtype; // this one has been resolved; erase it through its iterator! toResolveTypes.erase(i); @@ -750,74 +923,24 @@ bool wxXmlGccInterface::Parse(const wxString& filename) } else { -#if 1 - LogError("Cannot solve '%s' reference type!", referenced); + LogError("Cannot solve '%d' 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 } } } -/* - // 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; iGetChildren(); while (child) { - wxString n = child->GetName(); + wxString n = child->GetName(), acc = child->GetAttribute("access"); - if (n == "Method" || n == "Constructor" || n == "Destructor" || n == "OperatorMethod") + // only register public&protected methods + if ((acc == "public" || acc == "protected") && + (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 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 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'", + child->GetAttribute("demangled"), p->GetName()); + return false; + } - m_classes[i].AddMethod(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'", + 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); } } @@ -874,7 +1002,6 @@ bool wxXmlGccInterface::Parse(const wxString& filename) if ((++nodes%PROGRESS_RATE)==0) ShowProgress(); } - //wxPrint("\n"); if (!CheckParseResults()) return false; @@ -882,11 +1009,11 @@ bool wxXmlGccInterface::Parse(const wxString& filename) } bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p, - const wxStringHashMap& types, + const wxTypeIdHashMap& types, 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") @@ -894,18 +1021,18 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p, // 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'", - name, p->GetAttribute("id", "")); + name, p->GetAttribute("id")); 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; @@ -914,33 +1041,34 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p, 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; } } // resolve argument types - wxTypeArray argtypes; - wxArrayString argdefs; + wxArgumentTypeArray argtypes; wxXmlNode *arg = p->GetChildren(); while (arg) { 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; } - 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->GetAttribute("name"))); } arg = arg->GetNext(); @@ -948,10 +1076,26 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p, 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.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"); + + // decode access specifier + if (p->GetAttribute("access") == "public") + m.SetAccessSpecifier(wxMAS_PUBLIC); + else if (p->GetAttribute("access") == "protected") + m.SetAccessSpecifier(wxMAS_PROTECTED); + else if (p->GetAttribute("access") == "private") + m.SetAccessSpecifier(wxMAS_PRIVATE); if (!m.IsOk()) { LogError("The prototype '%s' is not valid!", m.GetAsString()); @@ -962,6 +1106,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 // ---------------------------------------------------------------------------- @@ -984,6 +1243,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 @@ -991,9 +1257,9 @@ bool wxXmlDoxygenInterface::Parse(const wxString& filename) 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")) @@ -1035,7 +1301,7 @@ bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename) while (child) { if (child->GetName() == "compounddef" && - child->GetAttribute("kind", wxEmptyString) == "class") + child->GetAttribute("kind") == "class") { // parse this class wxClass klass; @@ -1044,32 +1310,45 @@ bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename) wxXmlNode *subchild = child->GetChildren(); while (subchild) { + wxString kind = subchild->GetAttribute("kind"); + + // parse only public&protected functions: if (subchild->GetName() == "sectiondef" && - subchild->GetAttribute("kind", wxEmptyString) == "public-func") + (kind == "public-func" || kind == "protected-func")) { wxXmlNode *membernode = subchild->GetChildren(); while (membernode) { if (membernode->GetName() == "memberdef" && - membernode->GetAttribute("kind", wxEmptyString) == "function") + membernode->GetAttribute("kind") == "function") { 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 (kind == "public-func") + m.SetAccessSpecifier(wxMAS_PUBLIC); + else if (kind == "protected-func") + m.SetAccessSpecifier(wxMAS_PROTECTED); + else if (kind == "private-func") + m.SetAccessSpecifier(wxMAS_PRIVATE); + + if (absoluteFile.IsEmpty()) + absoluteFile = header; + else if (header != absoluteFile) { - if (absoluteFile.IsEmpty()) - absoluteFile = header; - else if (header != absoluteFile) - { - LogError("The method '%s' is documented in a different " - "file from others (which belong to '%s') ?", - header, absoluteFile); - 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(); @@ -1091,6 +1370,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(); } @@ -1112,43 +1396,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(); @@ -1160,7 +1410,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) { @@ -1168,9 +1418,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); @@ -1182,23 +1433,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") { - if (child->GetAttribute("line", "").ToLong(&line)) + line = -1; + if (child->GetAttribute("line").ToLong(&line)) m.SetLocation((int)line); - header = child->GetAttribute("file", ""); + 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.SetConst(p->GetAttribute("const", "")=="yes"); - m.SetStatic(p->GetAttribute("static", "")=="yes"); - m.SetVirtual(p->GetAttribute("virt", "")=="virtual"); + 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());