// for all others, include the necessary headers
#ifndef WX_PRECOMP
+ #include "wx/crt.h"
#endif
#include "wx/xml/xml.h"
// defined in ifacecheck.cpp
extern bool g_verbose;
+// global variable:
+bool g_bLogEnabled = true;
+
// ----------------------------------------------------------------------------
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");
+ m_strType.Replace("short unsigned int", "unsigned short");
// make sure the * and & operator always use the same spacing rules
// (to make sure GetAsString() output is always consistent)
m_strType.Replace(" ,", ",");
+ // ADHOC-FIX
+ m_strType.Replace("_wxArraywxArrayStringBase", "wxString");
+ m_strType.Replace("ExitCode", "void*"); // used in wxThread stuff
+
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
// "reverse_iterator_impl<wxString::const_iterator>" 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)
+void wxArgumentType::SetDefaultValue(const wxString& defval, const wxString& defvalForCmp)
{
- m_strDefaultValue=defval.Strip(wxString::both);
+ m_strDefaultValue = defval.Strip(wxString::both);
+ m_strDefaultValueForCmp = defvalForCmp.IsEmpty() ?
+ m_strDefaultValue : defvalForCmp.Strip(wxString::both);
- // in order to make valid&simple comparison on argument defaults,
- // we reduce some of the multiple forms in which the same things may appear
- // to a single form:
- m_strDefaultValue.Replace("0u", "0");
- if (IsPointer())
- m_strDefaultValue.Replace("0", "NULL");
- else
- m_strDefaultValue.Replace("NULL", "0");
+ // 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 = NULL;
+ 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 == "0l") *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);
+ }
- if (m_strDefaultValue.Contains("wxGetTranslation"))
- m_strDefaultValue = "_(TOFIX)"; // TODO: wxGetTranslation gives problems to gccxml
+ // 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;
- if (m_strDefaultValue != m.m_strDefaultValue)
+ // 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
// 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;
}
// a function can't be both const and static or virtual and static!
if ((m_bConst && m_bStatic) || ((m_bVirtual || m_bPureVirtual) && m_bStatic)) {
- LogError("'%s' method can't be both const/static or virtual/static", m_strName);
+ wxLogError("'%s' method can't be both const/static or virtual/static", m_strName);
return false;
}
- wxASSERT((m_bVirtual && m_bPureVirtual) || !m_bVirtual);
+ wxASSERT(!m_bPureVirtual || (m_bPureVirtual && m_bVirtual));
for (unsigned int i=0; i<m_args.GetCount(); i++)
if (!m_args[i].IsOk()) {
- LogError("'%s' method has invalid %d-th argument type: %s",
+ wxLogError("'%s' method has invalid %d-th argument type: %s",
m_strName, i+1, m_args[i].GetAsString());
return false;
}
for (unsigned int i=1; i<m_args.GetCount(); i++)
{
if (previousArgHasDefault && !m_args[i].HasDefaultValue()) {
- LogError("'%s' method has %d-th argument which has no default value "
+ wxLogError("'%s' method has %d-th argument which has no default value "
"(while the previous one had one!)",
m_strName, i+1);
return false;
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())
+ {
+ if (g_verbose)
+ {
+ wxLogMessage("The method '%s' does not match method '%s'; different names/rettype", GetName(), m.GetName());
+ }
return false;
+ }
- if (m_args.GetCount()!=m.m_args.GetCount())
+ if (m_args.GetCount()!=m.m_args.GetCount()) {
+ if (g_verbose)
+ {
+ wxLogMessage("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; i<m_args.GetCount(); i++)
if (m_args[i] != m.m_args[i])
return false;
return true;
}
-wxString wxMethod::GetAsString(bool bWithArgumentNames) const
+bool wxMethod::ActsAsDefaultCtor() const
+{
+ if (!IsCtor())
+ return false;
+
+ for (unsigned int i=0; i<m_args.GetCount(); i++)
+ if (!m_args[i].HasDefaultValue())
+ return false;
+
+ return true;
+}
+
+bool wxMethod::operator==(const wxMethod& m) const
+{
+ // check attributes
+ if (IsConst() != m.IsConst() ||
+ IsStatic() != m.IsStatic() ||
+ IsVirtual() != m.IsVirtual() ||
+ IsPureVirtual() != m.IsPureVirtual() ||
+ IsDeprecated() != m.IsDeprecated() ||
+ GetAccessSpecifier() != m.GetAccessSpecifier())
+ {
+ if (g_verbose)
+ {
+ wxLogMessage("The method '%s' does not match method '%s'; different attributes", GetName(), m.GetName());
+ }
+
+ return false;
+ }
+
+ // check everything else
+ return MatchesExceptForAttributes(m);
+}
+
+wxString wxMethod::GetAsString(bool bWithArgumentNames, bool bCleanDefaultValues,
+ bool bDeprecated, bool bAccessSpec) const
{
wxString ret;
+ // NOTE: for return and argument types, never use wxType::GetAsCleanString
+ // since in that way we'd miss important decorators like &,*,const etc
+
if (m_retType!=wxEmptyType)
ret += m_retType.GetAsString() + " ";
//else; this is a ctor or dtor
if (bWithArgumentNames && !name.IsEmpty())
ret += " " + name;
- const wxString& def = m_args[i].GetDefaultValue();
+ const wxString& def = bCleanDefaultValues ?
+ m_args[i].GetDefaultCleanValue() : m_args[i].GetDefaultValue();
if (!def.IsEmpty())
ret += " = " + def;
if (m_bVirtual || m_bPureVirtual)
ret = "virtual " + ret;
if (m_bPureVirtual)
- ret = ret + " = 0";
+ ret += " = 0";
+ if (m_bDeprecated && bDeprecated)
+ ret += " [deprecated]";
- // in doxygen headers we don't need wxDEPRECATED:
- //if (m_bDeprecated)
- // ret = "wxDEPRECATED( " + ret + " )";
+ 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;
}
for (unsigned int j=0; j<m_methods.GetCount(); j++)
if (i!=j && m_methods[i] == m_methods[j])
{
- LogError("class %s has two methods with the same prototype: '%s'",
+ wxLogError("class %s has two methods with the same prototype: '%s'",
m_strName, m_methods[i].GetAsString());
return false;
+
+ // fix the problem?
+ //((wxClass*)this)->m_methods.RemoveAt(j);
+ //j--;
}
return true;
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; i<m_parents.GetCount(); i++)
+ {
+ // ignore non-wx-classes parents
+ // AD-HOC FIX: discard wxScrolledT_Helper parent as it always gives errors
+ if (m_parents[i].StartsWith("wx") && m_parents[i] != "wxScrolledT_Helper")
+ {
+ const wxClass *parent = allclasses->FindClass(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;
}
+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; i<m_parents.GetCount(); i++)
+ {
+ // AD-HOC FIX: discard wxScrolledT_Helper parent as it always gives errors
+ if (m_parents[i].StartsWith("wx") && m_parents[i] != "wxScrolledT_Helper")
+ {
+ const wxClass *parent = allclasses->FindClass(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
// ----------------------------------------------------------------------------
// dump the classes in alphabetical order
wxSortedClassArray sorted(CompareWxClassObjects);
sorted.Alloc(m_classes.GetCount());
- for (unsigned int i=0; i<m_classes.GetCount(); i++)
+
+ unsigned i;
+ for (i=0; i<m_classes.GetCount(); i++)
sorted.Add(&m_classes[i]);
// now they have been sorted
- for (unsigned int i=0; i<sorted.GetCount(); i++)
+ for (i=0; i<sorted.GetCount(); i++)
sorted[i]->Dump(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; i<m_classes.GetCount(); i++)
+ {
if (!m_classes[i].CheckConsistency())
return false;
-#endif
+
+ for (unsigned int j=0; j<m_classes.GetCount(); j++)
+ if (i!=j && m_classes[i].GetName() == m_classes[j].GetName())
+ {
+ wxLogError("two classes have the same name: %s",
+ m_classes[i].GetName());
+ return false;
+ }
+ }
+//#endif
return true;
}
+wxClassPtrArray wxXmlInterface::FindClassesDefinedIn(const wxString& headerfile) const
+{
+ wxClassPtrArray ret;
+
+ for (unsigned int i=0; i<m_classes.GetCount(); i++)
+ if (m_classes[i].GetHeader() == headerfile)
+ ret.Add(&m_classes[i]);
+
+ return ret;
+}
+
+
// ----------------------------------------------------------------------------
// 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
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
WX_DECLARE_HASH_MAP( unsigned long, wxClass*,
wxIntegerHash, wxIntegerEqual,
wxClassMemberIdHashMap );
+
#else
#include <map>
typedef std::map<unsigned long, toResolveTypeItem> 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;
}
// utility specialized to parse efficiently the gccXML list of IDs which occur
-// in nodes like <Class> ones... i.e. numeric values separed by " _" token
-bool getMemberIDs(wxClassMemberIdHashMap* map, wxClass* p, const wxStringCharType* str)
+// in nodes like <Class> ones... i.e. numeric values separated by " _" token
+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;
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;
}
wxClassMemberIdHashMap members;
wxTypeIdHashMap types;
wxTypeIdHashMap files;
+ wxTypeIdHashMap typedefs;
// prealloc quite a lot of memory!
m_classes.Alloc(ESTIMATED_NUM_CLASSES);
// NOTE: <File> 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;
}
{
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;
}
// 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;
}
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;
}
// 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;
}
}
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;
}
// 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";
}
}
// 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();
i != toResolveTypes.end();)
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);
}
else
{
- LogError("Cannot solve '%s' reference type!", referenced);
+ wxLogError("Cannot solve '%d' reference type!", referenced);
return false;
}
}
}
// resolve header names
- for (unsigned int i=0; i<m_classes.GetCount(); i++)
+ unsigned i;
+ for (i=0; i<m_classes.GetCount(); i++)
{
unsigned long fileID = 0;
if (!getID(&fileID, m_classes[i].GetHeader()) || fileID == 0) {
- LogError("invalid header id: %s", m_classes[i].GetHeader());
+ wxLogError("invalid header id: %s", m_classes[i].GetHeader());
return false;
}
if (idx == files.end())
{
// this is an error!
- LogError("couldn't find file ID '%s'", m_classes[i].GetHeader());
+ wxLogError("couldn't find file ID '%s'", m_classes[i].GetHeader());
}
else
m_classes[i].SetHeader(idx->second);
}
+ // resolve parent names
+ for (i=0; i<m_classes.GetCount(); i++)
+ {
+ for (unsigned int k=0; k<m_classes[i].GetParentCount(); k++)
+ {
+ unsigned long id;
+
+ if (!getID(&id, m_classes[i].GetParent(k))) {
+ wxLogError("invalid parent class ID for '%s'", m_classes[i].GetName());
+ return false;
+ }
+
+ wxTypeIdHashMap::const_iterator idx = types.find(id);
+ if (idx == types.end())
+ {
+ // this is an error!
+ wxLogError("couldn't find parent class ID '%d'", id);
+ }
+ else
+ // replace k-th parent with its true name:
+ m_classes[i].SetParent(k, idx->second);
+ }
+ }
+
// 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;
}
// this <Method> 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'",
+ 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;
}
if ((++nodes%PROGRESS_RATE)==0) ShowProgress();
}
- if (!CheckParseResults())
- return false;
+ if (!CheckConsistency())
+ return false; // the check failed
return true;
}
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;
}
{
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;
}
{
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(wxArgumentType(idx->second, arg->GetAttribute("default")));
+ argtypes.Add(wxArgumentType(idx->second,
+ arg->GetAttribute("default"),
+ arg->GetAttribute("name")));
}
arg = arg->GetNext();
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 explicitly 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;
}
}
+
+// ----------------------------------------------------------------------------
+// wxXmlDoxygenInterface global helpers
+// ----------------------------------------------------------------------------
+
+static wxString GetTextFromChildren(const wxXmlNode *n)
+{
+ wxString text;
+
+ // consider the tree
+ //
+ // <a><b>this</b> is a <b>string</b></a>
+ //
+ // <a>
+ // |- <b>
+ // | |- this
+ // |- is a
+ // |- <b>
+ // |- 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 <onlyfor> 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
// ----------------------------------------------------------------------------
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
}
//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;
}
wxXmlNode *subchild = child->GetChildren();
while (subchild)
{
- if (subchild->GetName() == "sectiondef" &&
- subchild->GetAttribute("kind") == "public-func")
+ // NOTE: when documenting functions using the //@{ and //@}
+ // tags to create function groups, doxygen puts the
+ // contained methods into a "user-defined" section
+ // so we _must_ use the "prot" attribute to distinguish
+ // public/protected methods from private ones and cannot
+ // rely on the kind="public" attribute of <sectiondef>
+ if (subchild->GetName() == "sectiondef")
{
-
wxXmlNode *membernode = subchild->GetChildren();
while (membernode)
{
+ const wxString& accessSpec = membernode->GetAttribute("prot");
+
+ // parse only public&protected functions:
if (membernode->GetName() == "memberdef" &&
- membernode->GetAttribute("kind") == "function")
+ membernode->GetAttribute("kind") == "function" &&
+ (accessSpec == "public" || accessSpec == "protected"))
{
-
wxMethod m;
if (!ParseMethod(membernode, m, header)) {
- LogError("The method '%s' could not be added to class '%s'",
- m.GetName(), klass.GetName());
+ wxLogError("The method '%s' could not be added to class '%s'",
+ m.GetName(), klass.GetName());
return false;
}
+ if (accessSpec == "public")
+ m.SetAccessSpecifier(wxMAS_PUBLIC);
+ else if (accessSpec == "protected")
+ m.SetAccessSpecifier(wxMAS_PROTECTED);
+ else if (accessSpec == "private")
+ m.SetAccessSpecifier(wxMAS_PRIVATE);
+
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);
+ wxLogError("Found inconsistency in the XML file '%s': "
+ "the method '%s' is documented in the "
+ "file '%s' but the other methods of the same "
+ "class are documented in the file '%s'",
+ filename, m.GetName(), header, absoluteFile);
return false;
}
klass.SetHeader(subchild->GetNodeContent());
}*/
+ else if (subchild->GetName() == "detaileddescription")
+ {
+ // identify <onlyfor> 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();
}
// add a new class
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();
return true;
}
-static wxString GetTextFromChildren(const wxXmlNode *n)
-{
- wxString text;
-
- // consider the tree
- //
- // <a><b>this</b> is a <b>string</b></a>
- //
- // <a>
- // |- <b>
- // | |- this
- // |- is a
- // |- <b>
- // |- 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)
{
wxArgumentTypeArray args;
else if (n->GetName() == "declname")
namestr = GetTextFromChildren(n);
else if (n->GetName() == "defval")
- defstr = GetTextFromChildren(n);
+ defstr = GetTextFromChildren(n).Strip(wxString::both);
else if (n->GetName() == "array")
arrstr = GetTextFromChildren(n);
}
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(wxArgumentType(typestr + arrstr, defstr, namestr));
+ 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")
{
// Doxygen outputs somewhere nested inside <detaileddescription>
// a <xreftitle>Deprecated</xreftitle> tag.
m.SetDeprecated(HasTextNodeContaining(child, "Deprecated"));
+
+ // identify <onlyfor> custom XML tags
+ m.SetAvailability(GetAvailabilityFor(child));
}
child = child->GetNext();
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 explicitly 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;
}
projects / wxWidgets.git / blobdiff