X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/96202d070a4f0c7e2f346e0bba7da8580d45d02f..357d2b88cb15fa0ad97b1676fdbc88c2abc85451:/utils/ifacecheck/src/xmlparser.cpp diff --git a/utils/ifacecheck/src/xmlparser.cpp b/utils/ifacecheck/src/xmlparser.cpp index 2209075bd6..e0d5803c4c 100644 --- a/utils/ifacecheck/src/xmlparser.cpp +++ b/utils/ifacecheck/src/xmlparser.cpp @@ -40,6 +40,9 @@ WX_DEFINE_OBJARRAY(wxClassArray) // defined in ifacecheck.cpp extern bool g_verbose; +// global variable: +bool g_bLogEnabled = true; + // ---------------------------------------------------------------------------- @@ -83,6 +86,18 @@ void wxType::SetTypeFromString(const wxString& t) 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 @@ -105,6 +120,9 @@ bool wxType::operator==(const wxType& m) const IsReference() == m.IsReference()) return true; + if (g_verbose) + LogMessage("Type '%s' does not match type '%s'", m_strType, m.m_strType); + return false; } @@ -115,23 +133,55 @@ bool wxType::operator==(const wxType& m) const void wxArgumentType::SetDefaultValue(const wxString& defval, const wxString& defvalForCmp) { - m_strDefaultValue=defval.Strip(wxString::both); - m_strDefaultValueForCmp=defvalForCmp.Strip(wxString::both); + m_strDefaultValue = defval.Strip(wxString::both); + m_strDefaultValueForCmp = defvalForCmp.IsEmpty() ? m_strDefaultValue : defvalForCmp.Strip(wxString::both); + + // 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"; // 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 (m_strDefaultValueForCmp == "0u") + m_strDefaultValueForCmp = "0"; + + m_strDefaultValue.Replace("0x000000001", "1"); + m_strDefaultValueForCmp.Replace("0x000000001", "1"); + + // fix for unicode strings: + m_strDefaultValue.Replace("\\000\\000\\000", ""); + m_strDefaultValueForCmp.Replace("\\000\\000\\000", ""); + + 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); + } + /* if (IsPointer()) - m_strDefaultValue.Replace("0", "NULL"); + m_strDefaultValueForCmp.Replace("0", "NULL"); else - m_strDefaultValue.Replace("NULL", "0"); + m_strDefaultValueForCmp.Replace("NULL", "0"); */ + // ADHOC-FIX: + // doxygen likes to put wxDateTime:: in front of all wxDateTime enums; + // fix this to avoid false positives + m_strDefaultValueForCmp.Replace("wxDateTime::", ""); + m_strDefaultValueForCmp.Replace("wxStockGDI::", ""); // same story for some other classes + m_strDefaultValueForCmp.Replace("wxHelpEvent::", ""); // same story for some other classes + + m_strDefaultValueForCmp.Replace("wxGet_wxConvLocal()", "wxConvLocal"); - if (m_strDefaultValue.Contains("wxGetTranslation")) - m_strDefaultValue = "_(TOFIX)"; // TODO: wxGetTranslation gives problems to gccxml + m_strDefaultValueForCmp.Replace("* GetColour(COLOUR_BLACK)", "*wxBLACK"); + + // ADHOC-FIX: + if (m_strDefaultValueForCmp.Contains("wxGetTranslation")) + m_strDefaultValueForCmp = "_(TOFIX)"; // TODO: wxGetTranslation gives problems to gccxml } bool wxArgumentType::operator==(const wxArgumentType& m) const @@ -139,22 +189,44 @@ 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; + // 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; + + // fix for default values which were replaced by gcc-xml with their numeric values + // (at this point we know that m_strTypeClean == m.m_strTypeClean): + if (m_strTypeClean == "long" || m_strTypeClean == "int") + { + if ((m_strDefaultValueForCmp.IsNumber() && m.m_strDefaultValueForCmp.StartsWith("wx")) || + (m.m_strDefaultValueForCmp.IsNumber() && m_strDefaultValueForCmp.StartsWith("wx"))) + { + if (g_verbose) + LogMessage("Supposing '%s' default value to be the same of '%s'...", + m_strDefaultValueForCmp, m.m_strDefaultValueForCmp); + + return true; + } + } - if (def1 != def2) + if (m_strDefaultValueForCmp != m.m_strDefaultValueForCmp) { // 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 (m_strDefaultValueForCmp.ToLong(&def1val, 0 /* auto-detect */) && + m.m_strDefaultValueForCmp.ToLong(&def2val, 0 /* auto-detect */)) { if (def1val == def2val) return true; // the default values match } + if (g_verbose) + LogMessage("Argument type '%s = %s' has different default value from '%s = %s'", + m_strType, m_strDefaultValueForCmp, m.m_strType, m.m_strDefaultValueForCmp); return false; } @@ -217,20 +289,20 @@ bool wxMethod::IsOk() const return true; } -bool wxMethod::operator==(const wxMethod& m) const +bool wxMethod::MatchesExceptForAttributes(const wxMethod& m) const { if (GetReturnType() != m.GetReturnType() || - GetName() != m.GetName() || - IsConst() != m.IsConst() || - IsStatic() != m.IsStatic() || - IsVirtual() != m.IsVirtual() || - IsPureVirtual() != m.IsPureVirtual() || - IsDeprecated() != m.IsDeprecated()) + GetName() != m.GetName()) return false; - if (m_args.GetCount()!=m.m_args.GetCount()) + if (m_args.GetCount()!=m.m_args.GetCount()) { + if (g_verbose) + LogMessage("Method '%s' has %d arguments while '%s' has %d arguments", + m_strName, m_args.GetCount(), m_strName, m.m_args.GetCount()); return false; + } + // compare argument types for (unsigned int i=0; im_methods.RemoveAt(j); + j--; } return true; @@ -376,7 +484,39 @@ const wxMethod* wxClass::FindMethod(const wxMethod& m) const return NULL; } -wxMethodPtrArray wxClass::FindMethodNamed(const wxString& name) const +const wxMethod* wxClass::RecursiveUpwardFindMethod(const wxMethod& m, + const wxXmlInterface* allclasses) const +{ + // first, search into *this + const wxMethod* ret = FindMethod(m); + if (ret) + return ret; + + // then, search into its parents + for (unsigned int i=0; iFindClass(m_parents[i]); + if (!parent) { + LogError("Could not find parent '%s' of class '%s'...", + m_parents[i], GetName()); + return false; + } + + const wxMethod *parentMethod = parent->RecursiveUpwardFindMethod(m, allclasses); + if (parentMethod) + return parentMethod; + } + } + + // could not find anything even in parent classes... + return NULL; +} + +wxMethodPtrArray wxClass::FindMethodsNamed(const wxString& name) const { wxMethodPtrArray ret; @@ -388,6 +528,37 @@ wxMethodPtrArray wxClass::FindMethodNamed(const wxString& name) const } +wxMethodPtrArray wxClass::RecursiveUpwardFindMethodsNamed(const wxString& name, + const wxXmlInterface* allclasses) const +{ + // first, search into *this + wxMethodPtrArray ret = FindMethodsNamed(name); + if (ret.GetCount()>0) + return ret; // stop here, don't look upward in the parents + + // then, search into parents of this class + for (unsigned int i=0; iFindClass(m_parents[i]); + if (!parent) { + LogError("Could not find parent '%s' of class '%s'...", + m_parents[i], GetName()); + return false; + } + + wxMethodPtrArray temp = parent->RecursiveUpwardFindMethodsNamed(name, allclasses); + WX_APPEND_ARRAY(ret, temp); + } + } + + return ret; +} + + + // ---------------------------------------------------------------------------- // wxXmlInterface // ---------------------------------------------------------------------------- @@ -444,11 +615,16 @@ wxClassPtrArray wxXmlInterface::FindClassesDefinedIn(const wxString& headerfile) // wxXmlGccInterface helper declarations // ---------------------------------------------------------------------------- +// or-able flags for a toResolveTypeItem->attrib: #define ATTRIB_CONST 1 #define ATTRIB_REFERENCE 2 #define ATTRIB_POINTER 4 #define ATTRIB_ARRAY 8 +// it may sound strange but gccxml, in order to produce shorter ID names +// uses (after the underscore) characters in range 0-9 and a-z in the ID names; +// in order to be able to translate such strings into numbers using strtoul() +// we use as base 10 (possible digits) + 25 (possible characters) = 35 #define GCCXML_BASE 35 class toResolveTypeItem @@ -458,7 +634,8 @@ public: toResolveTypeItem(unsigned int refID, unsigned int attribint) : ref(refID), attribs(attribint) {} - unsigned long ref, attribs; + unsigned long ref, // the referenced type's ID + attribs; // the attributes of this reference }; #if 1 @@ -472,6 +649,7 @@ WX_DECLARE_HASH_MAP( unsigned long, toResolveTypeItem, WX_DECLARE_HASH_MAP( unsigned long, wxClass*, wxIntegerHash, wxIntegerEqual, wxClassMemberIdHashMap ); + #else #include typedef std::map wxToResolveTypeHashMap; @@ -520,7 +698,7 @@ 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 +#if wxUSE_UNICODE_WCHAR unsigned long id = wcstoul(curpos+1, &nexttoken, GCCXML_BASE); #else unsigned long id = strtoul(curpos+1, &nexttoken, GCCXML_BASE); @@ -592,6 +770,7 @@ bool wxXmlGccInterface::Parse(const wxString& filename) wxClassMemberIdHashMap members; wxTypeIdHashMap types; wxTypeIdHashMap files; + wxTypeIdHashMap typedefs; // prealloc quite a lot of memory! m_classes.Alloc(ESTIMATED_NUM_CLASSES); @@ -625,6 +804,21 @@ bool wxXmlGccInterface::Parse(const wxString& filename) // NB: "file" attribute contains an ID value that we'll resolve later m_classes.Add(wxClass(cname, child->GetAttribute("file"))); + // the just-inserted class: + wxClass *newClass = &m_classes.Last(); + + // now get a list of the base classes: + wxXmlNode *baseNode = child->GetChildren(); + while (baseNode) + { + // for now we store as "parents" only the parent IDs... + // later we will resolve them into full class names + if (baseNode->GetName() == "Base") + newClass->AddParent(baseNode->GetAttribute("type")); + + baseNode = baseNode->GetNext(); + } + const wxString& ids = child->GetAttribute("members"); if (ids.IsEmpty()) { @@ -639,7 +833,7 @@ bool wxXmlGccInterface::Parse(const wxString& filename) else { // decode the non-empty list of IDs: - if (!getMemberIDs(&members, &m_classes.Last(), ids)) { + if (!getMemberIDs(&members, newClass, ids)) { LogError("Invalid member IDs for '%s' class node: %s", cname, child->GetAttribute("id")); return false; @@ -650,6 +844,23 @@ bool wxXmlGccInterface::Parse(const wxString& filename) // register this class also as possible return/argument type: 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") { @@ -689,11 +900,14 @@ bool wxXmlGccInterface::Parse(const wxString& filename) } if (argstr.Len() > 0) - argstr = argstr.Left(argstr.Len()-2); + 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); - types[id] = child->GetAttribute("returns") + "(" + argstr + ")"; + //types[id] = child->GetAttribute("returns") + "(" + argstr + ")"; + + types[id] = "TOFIX"; // typically this type will be "fixed" thanks + // to a typedef later... } else if (n == "File") { @@ -737,7 +951,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) { @@ -770,7 +984,10 @@ bool wxXmlGccInterface::Parse(const wxString& filename) 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); @@ -793,7 +1010,7 @@ bool wxXmlGccInterface::Parse(const wxString& filename) } else { - LogError("Cannot solve '%s' reference type!", referenced); + LogError("Cannot solve '%d' reference type!", referenced); return false; } } @@ -820,14 +1037,38 @@ bool wxXmlGccInterface::Parse(const wxString& filename) m_classes[i].SetHeader(idx->second); } + // resolve parent names + for (unsigned int i=0; isecond); + } + } + // build the list of the wx methods child = doc.GetRoot()->GetChildren(); while (child) { - wxString n = child->GetName(); + wxString n = child->GetName(), acc = child->GetAttribute("access"); - // only register public methods - if (child->GetAttribute("access") == "public" && + // only register public&protected methods + if ((acc == "public" || acc == "protected") && (n == "Method" || n == "Constructor" || n == "Destructor" || n == "OperatorMethod")) { unsigned long id = 0; @@ -849,6 +1090,8 @@ bool wxXmlGccInterface::Parse(const wxString& filename) return false; } + // 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()); @@ -934,7 +1177,9 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p, return false; } - argtypes.Add(wxArgumentType(idx->second, arg->GetAttribute("default"))); + argtypes.Add(wxArgumentType(idx->second, + arg->GetAttribute("default"), + arg->GetAttribute("name"))); } arg = arg->GetNext(); @@ -955,6 +1200,14 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p, 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()); return false; @@ -1136,6 +1389,7 @@ bool wxXmlDoxygenInterface::Parse(const wxString& filename) bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename) { + wxClassMemberIdHashMap parents; wxXmlDocument doc; wxXmlNode *child; int nodes = 0; @@ -1168,8 +1422,11 @@ 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") == "public-func") + (kind == "public-func" || kind == "protected-func")) { wxXmlNode *membernode = subchild->GetChildren(); @@ -1186,6 +1443,13 @@ bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename) 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) @@ -1223,6 +1487,11 @@ bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename) // identify custom XML tags klass.SetAvailability(GetAvailabilityFor(subchild)); } + else if (subchild->GetName() == "basecompoundref") + { + // add the name of this parent to the list of klass' parents + klass.AddParent(subchild->GetNodeContent()); + } subchild = subchild->GetNext(); }