X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/1f81aa3692666f05363b9265fa0f6c2a14bd9df1..6d52ca536a0ecb6e69474d30461f6128497505a0:/utils/ifacecheck/src/xmlparser.cpp diff --git a/utils/ifacecheck/src/xmlparser.cpp b/utils/ifacecheck/src/xmlparser.cpp index 78a12e8196..b5c752d48f 100644 --- a/utils/ifacecheck/src/xmlparser.cpp +++ b/utils/ifacecheck/src/xmlparser.cpp @@ -17,6 +17,7 @@ // for all others, include the necessary headers #ifndef WX_PRECOMP + #include "wx/crt.h" #endif #include "wx/xml/xml.h" @@ -28,6 +29,7 @@ #include WX_DEFINE_OBJARRAY(wxTypeArray) +WX_DEFINE_OBJARRAY(wxArgumentTypeArray) WX_DEFINE_OBJARRAY(wxMethodArray) WX_DEFINE_OBJARRAY(wxClassArray) @@ -39,6 +41,9 @@ WX_DEFINE_OBJARRAY(wxClassArray) // defined in ifacecheck.cpp extern bool g_verbose; +// global variable: +bool g_bLogEnabled = true; + // ---------------------------------------------------------------------------- @@ -47,12 +52,65 @@ 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 + */ + + // clean the type string + // --------------------- + + 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" + m_strType.Replace("long unsigned int", "unsigned 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(" ,", ","); + + // ADHOC-FIX + m_strType.Replace("_wxArraywxArrayStringBase", "wxString"); + + m_strType = m_strType.Strip(wxString::both); + + + + // clean the type string (this time for the comparison) + // ---------------------------------------------------- + + m_strTypeClean = m_strType; // begin with the already-cleaned string + 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); + + // remove the namespace from the types; there's no problem of conflicts + // (except for templates) and this avoids tons of false warnings + if (m_strTypeClean.Contains("::") && !m_strTypeClean.Contains("<")) + m_strTypeClean = m_strTypeClean.Mid(m_strTypeClean.Find("::")+2); + + // ADHOC-FIX: + m_strTypeClean.Replace("wxWindowID", "int"); } bool wxType::IsOk() const @@ -61,34 +119,156 @@ 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) + { + wxLogMessage("Type '%s' does not match type '%s'", m_strType, m.m_strType); + wxLogMessage(" => TypeClean %s / %s; IsConst %d / %d; IsStatic %d / %d; IsPointer %d / %d; IsReference %d / %d", + m_strTypeClean, m.m_strTypeClean, IsConst(), m.IsConst(), + IsStatic(), m.IsStatic(), IsPointer(), m.IsPointer(), + IsReference(), m.IsReference()); + } + return false; } + +// ---------------------------------------------------------------------------- +// wxArgumentType +// ---------------------------------------------------------------------------- + +void wxArgumentType::SetDefaultValue(const wxString& defval, const wxString& defvalForCmp) +{ + m_strDefaultValue = defval.Strip(wxString::both); + m_strDefaultValueForCmp = defvalForCmp.IsEmpty() ? + m_strDefaultValue : defvalForCmp.Strip(wxString::both); + + + // clean the default argument strings + // ---------------------------------- + + // Note: we adjust the aesthetic form of the m_strDefaultValue string for the "modify mode" + // of ifacecheck: we may need to write it out in an interface header + + wxString *p; + for (int i=0; i<2; i++) // to avoid copying&pasting the code! + { + if (i == 0) p = &m_strDefaultValue; + if (i == 1) p = &m_strDefaultValueForCmp; + + if (*p == "0u") *p = "0"; + + p->Replace("0x000000001", "1"); + p->Replace("\\000\\000\\000", ""); // fix for unicode strings: + p->Replace("\\011", "\\t"); + p->Replace("e+0", ""); + p->Replace("2147483647", "__INT_MAX__"); + + // ADHOC-FIX: for wxConv* default values + p->Replace("wxConvAuto(wxFONTENCODING_DEFAULT)", "wxConvAuto()"); + p->Replace("wxGet_wxConvUTF8()", "wxConvUTF8"); + p->Replace("wxGet_wxConvLocal()", "wxConvLocal"); + } + + + // clean ONLY the default argument string specific for comparison + // -------------------------------------------------------------- + + 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); + } + + // 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("* 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 +{ + if ((const wxType&)(*this) != (const wxType&)m) + return false; + + // check if the default values match + // --------------------------------- + + + // 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) + wxLogMessage("Supposing '%s' default value to be the same of '%s'...", + m_strDefaultValueForCmp, m.m_strDefaultValueForCmp); + + return true; + } + } + else if (m_strTypeClean == "float" || m_strTypeClean == "double") + // gccXML translates the default floating values in a hardly usable + // format; e.g. 25.2 => 2.51999999999999992894572642398998141288757324219e+1 + // we avoid check on these... + return true; + + 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 (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) + wxLogMessage("Argument type '%s = %s' has different default value from '%s = %s'", + m_strType, m_strDefaultValueForCmp, m.m_strType, m.m_strDefaultValueForCmp); + return false; + } + + // we deliberately avoid checks on the argument name + + return true; +} + + // ---------------------------------------------------------------------------- // wxMethod // ---------------------------------------------------------------------------- @@ -98,7 +278,7 @@ bool wxMethod::IsOk() const // 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()); + wxLogError("'%s' method has invalid return type: %s", m_retType.GetAsString()); return false; } @@ -106,66 +286,107 @@ 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)) { - LogError("'%s' method can't be both const/static or virtual/static", m_strName); + if ((m_bConst && m_bStatic) || ((m_bVirtual || m_bPureVirtual) && m_bStatic)) { + wxLogError("'%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. + // so we don't do any test on their contents + if (m_args.GetCount()>0) + { + bool previousArgHasDefault = m_args[0].HasDefaultValue(); + for (unsigned int i=1; im_methods.RemoveAt(j); + //j--; } return true; @@ -288,7 +540,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) { + wxLogError("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; @@ -300,6 +584,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) { + wxLogError("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 // ---------------------------------------------------------------------------- @@ -320,35 +635,64 @@ void wxXmlInterface::Dump(const wxString& filename) // dump the classes in alphabetical order wxSortedClassArray sorted(CompareWxClassObjects); sorted.Alloc(m_classes.GetCount()); - for (unsigned int i=0; iDump(apiout); } -bool wxXmlInterface::CheckParseResults() const +bool wxXmlInterface::CheckConsistency() 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 +// 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 @@ -358,7 +702,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 @@ -372,6 +717,7 @@ WX_DECLARE_HASH_MAP( unsigned long, toResolveTypeItem, WX_DECLARE_HASH_MAP( unsigned long, wxClass*, wxIntegerHash, wxIntegerEqual, wxClassMemberIdHashMap ); + #else #include typedef std::map wxToResolveTypeHashMap; @@ -381,19 +727,20 @@ typedef std::map wxToResolveTypeHashMap; // 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) +bool getID(unsigned long *id, const wxString& str) { + const wxStringCharType * const start = str.wx_str()+1; wxStringCharType *end; -#if wxUSE_UNICODE_UTF8 - unsigned long val = strtoul(str+1, &end, GCCXML_BASE); +#if wxUSE_UNICODE_WCHAR + unsigned long val = wcstoul(start, &end, GCCXML_BASE); #else - unsigned long val = wcstoul(str+1, &end, GCCXML_BASE); + unsigned long val = strtoul(start, &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 ) + if ( *end != '\0' || end == start || errno == ERANGE || errno == EINVAL ) return false; *id = val; @@ -402,28 +749,29 @@ bool getID(unsigned long *id, const wxStringCharType* str) // 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) +bool getMemberIDs(wxClassMemberIdHashMap* map, wxClass* p, const wxString& str) { -#if wxUSE_UNICODE_UTF8 - size_t len = strlen(str); + const wxStringCharType * const start = str.wx_str(); +#if wxUSE_UNICODE_WCHAR + size_t len = wcslen(start); #else - size_t len = wcslen(str); + size_t len = strlen(start); #endif - if (len == 0 || str[0] != '_') + if (len == 0 || start[0] != '_') return false; - const wxStringCharType *curpos = str, - *end = str + len; + const wxStringCharType *curpos = start, + *end = start + 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 +#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; @@ -450,16 +798,41 @@ bool wxXmlGccInterface::Parse(const wxString& filename) wxXmlNode *child; int nodes = 0; - LogMessage("Parsing %s...", filename); + wxLogMessage("Parsing %s...", filename); if (!doc.Load(filename)) { - LogError("can't load %s", filename); + wxLogError("can't load %s", filename); return false; } // start processing the XML file if (doc.GetRoot()->GetName() != "GCC_XML") { - LogError("invalid root node for %s", filename); + wxLogError("invalid root node for %s", 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) + { + wxLogError("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; } @@ -467,6 +840,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); @@ -482,7 +856,7 @@ bool wxXmlGccInterface::Parse(const wxString& filename) // NOTE: nodes can have an id == "f0"... - LogError("Invalid id for node %s: %s", n, child->GetAttribute("id")); + wxLogError("Invalid id for node %s: %s", n, child->GetAttribute("id")); return false; } @@ -490,7 +864,7 @@ bool wxXmlGccInterface::Parse(const wxString& filename) { wxString cname = child->GetAttribute("name"); if (cname.IsEmpty()) { - LogError("Invalid empty name for '%s' node", n); + wxLogError("Invalid empty name for '%s' node", n); return false; } @@ -500,11 +874,26 @@ 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()) { if (child->GetAttribute("incomplete") != "1") { - LogError("Invalid member IDs for '%s' class node (ID %s)", + wxLogError("Invalid member IDs for '%s' class node: %s", cname, child->GetAttribute("id")); return false; } @@ -514,8 +903,8 @@ bool wxXmlGccInterface::Parse(const wxString& filename) 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)", + if (!getMemberIDs(&members, newClass, ids)) { + wxLogError("Invalid member IDs for '%s' class node: %s", cname, child->GetAttribute("id")); return false; } @@ -525,12 +914,29 @@ 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"))) { + wxLogError("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") { unsigned long type = 0; if (!getID(&type, child->GetAttribute("type")) || type == 0) { - LogError("Invalid type for node %s: %s", n, child->GetAttribute("type")); + wxLogError("Invalid type for node %s: %s", n, child->GetAttribute("type")); return false; } @@ -564,16 +970,19 @@ 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") { if (!child->GetAttribute("id").StartsWith("f")) { - LogError("Unexpected file ID: %s", id); + wxLogError("Unexpected file ID: %s", child->GetAttribute("id")); return false; } @@ -598,7 +1007,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); + wxLogWarning("Type node '%s' with ID '%s' does not have name attribute", + n, child->GetAttribute("id")); types[id] = "TOFIX"; } @@ -611,12 +1021,12 @@ 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) { if (g_verbose) - LogMessage("%d types were collected; %d types need yet to be resolved...", + wxLogMessage("%d types were collected; %d types need yet to be resolved...", types.size(), toResolveTypes.size()); for (wxToResolveTypeHashMap::iterator i = toResolveTypes.begin(); @@ -644,7 +1054,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); @@ -667,7 +1080,7 @@ bool wxXmlGccInterface::Parse(const wxString& filename) } else { - LogError("Cannot solve '%s' reference type!", referenced); + wxLogError("Cannot solve '%d' reference type!", referenced); return false; } } @@ -675,11 +1088,12 @@ bool wxXmlGccInterface::Parse(const wxString& filename) } // resolve header names - for (unsigned int i=0; isecond); } + // resolve parent names + for (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; if (!getID(&id, child->GetAttribute("id"))) { - LogError("invalid ID for node '%s' with ID '%s'", n, child->GetAttribute("id")); + wxLogError("invalid ID for node '%s' with ID '%s'", n, child->GetAttribute("id")); return false; } @@ -717,17 +1155,22 @@ 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)) { + wxLogError("The method '%s' could not be added to class '%s'", + child->GetAttribute("demangled"), p->GetName()); 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()); + wxLogError("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()); + wxLogError("The method '%s' does not seem to be a dtor for '%s'", + newfunc.GetName(), p->GetName()); return false; } @@ -741,9 +1184,8 @@ bool wxXmlGccInterface::Parse(const wxString& filename) if ((++nodes%PROGRESS_RATE)==0) ShowProgress(); } - //wxPrint("\n"); - if (!CheckParseResults()) - return false; + if (!CheckConsistency()) + return false; // the check failed return true; } @@ -765,7 +1207,7 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p, 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'", + wxLogError("Empty return ID for method '%s', with ID '%s'", name, p->GetAttribute("id")); return false; } @@ -774,21 +1216,20 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p, { wxTypeIdHashMap::const_iterator retidx = types.find(retid); if (retidx == types.end()) { - LogError("Could not find return type ID '%s'", retid); + wxLogError("Could not find return type ID '%s'", retid); return false; } ret = wxType(retidx->second); if (!ret.IsOk()) { - LogError("Invalid return type '%s' for method '%s', with ID '%s'", + wxLogError("Invalid return type '%s' for method '%s', with ID '%s'", retidx->second, name, p->GetAttribute("id")); return false; } } // resolve argument types - wxTypeArray argtypes; - wxArrayString argdefs; + wxArgumentTypeArray argtypes; wxXmlNode *arg = p->GetChildren(); while (arg) { @@ -796,24 +1237,20 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p, { unsigned long id = 0; if (!getID(&id, arg->GetAttribute("type")) || id == 0) { - LogError("Invalid argument type ID '%s' for method '%s' with ID %s", + wxLogError("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); + wxLogError("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(); @@ -821,14 +1258,29 @@ 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"); + // 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()); + wxLogError("The prototype '%s' is not valid!", m.GetAsString()); return false; } @@ -836,6 +1288,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 + wxLogWarning("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")) { + wxLogError("unexpected port ID '%s'", ports[i]); + return false; + } + + nAvail |= wxPlatformInfo::GetPortId(ports[i].Mid(2)); + } + + return nAvail; +} + + // ---------------------------------------------------------------------------- // wxXmlDoxygenInterface // ---------------------------------------------------------------------------- @@ -845,19 +1412,26 @@ bool wxXmlDoxygenInterface::Parse(const wxString& filename) wxXmlDocument index; wxXmlNode *compound; - LogMessage("Parsing %s...", filename); + wxLogMessage("Parsing %s...", filename); if (!index.Load(filename)) { - LogError("can't load %s", filename); + wxLogError("can't load %s", filename); return false; } // start processing the index: if (index.GetRoot()->GetName() != "doxygenindex") { - LogError("invalid root node for %s", filename); + wxLogError("invalid root node for %s", 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 @@ -878,29 +1452,30 @@ bool wxXmlDoxygenInterface::Parse(const wxString& filename) } //wxPrint("\n"); - if (!CheckParseResults()) - return false; + if (!CheckConsistency()) + return false; // the check failed return true; } bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename) { + wxClassMemberIdHashMap parents; wxXmlDocument doc; wxXmlNode *child; int nodes = 0; if (g_verbose) - LogMessage("Parsing %s...", filename); + wxLogMessage("Parsing %s...", filename); if (!doc.Load(filename)) { - LogError("can't load %s", filename); + wxLogError("can't load %s", filename); return false; } // start processing this compound definition XML if (doc.GetRoot()->GetName() != "doxygen") { - LogError("invalid root node for %s", filename); + wxLogError("invalid root node for %s", filename); return false; } @@ -918,8 +1493,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(); @@ -930,20 +1508,30 @@ bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename) { wxMethod m; - if (ParseMethod(membernode, m, header)) + if (!ParseMethod(membernode, m, header)) { + wxLogError("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); + wxLogError("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(); @@ -965,6 +1553,16 @@ bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename) klass.SetHeader(subchild->GetNodeContent()); }*/ + else if (subchild->GetName() == "detaileddescription") + { + // 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(); } @@ -973,8 +1571,8 @@ bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename) if (klass.IsOk()) m_classes.Add(klass); else if (g_verbose) - LogWarning("discarding class '%s' with %d methods...", - klass.GetName(), klass.GetMethodCount()); + wxLogWarning("discarding class '%s' with %d methods...", + klass.GetName(), klass.GetMethodCount()); } child = child->GetNext(); @@ -986,72 +1584,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; -} - -static bool HasTextNodeContaining(const wxXmlNode *parent, const wxString& name) -{ - 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; -} - bool wxXmlDoxygenInterface::ParseMethod(const wxXmlNode* p, wxMethod& m, wxString& header) { - wxTypeArray args; - wxArrayString defs; + wxArgumentTypeArray args; long line; wxXmlNode *child = p->GetChildren(); @@ -1063,7 +1598,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) { @@ -1071,9 +1606,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); @@ -1081,12 +1617,19 @@ bool wxXmlDoxygenInterface::ParseMethod(const wxXmlNode* p, wxMethod& m, wxStrin } if (typestr.IsEmpty()) { - LogError("cannot find type node for a param in method '%s'", m.GetName()); + wxLogError("cannot find type node for a param in method '%s'", m.GetName()); 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") { @@ -1101,18 +1644,28 @@ bool wxXmlDoxygenInterface::ParseMethod(const wxXmlNode* p, wxMethod& m, wxStrin // 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()); + wxLogError("The prototype '%s' is not valid!", m.GetAsString()); return false; }