#include "wx/xml/xml.h"
#include "wx/wfstream.h"
-#include "wx/arrimpl.cpp"
-#include "wx/dynarray.h"
+#include "wx/hashmap.h"
#include "wx/filename.h"
-
-#include <errno.h>
-
#include "xmlparser.h"
+#include <errno.h>
-#define PROGRESS_RATE 1000 // each PROGRESS_RATE nodes processed print a dot
-#define ESTIMATED_NUM_CLASSES 600 // used by both wxXmlInterface-derived classes to prealloc mem
-#define ESTIMATED_NUM_TYPES 50000 // used only by wxGccXmlInterface to prealloc mem
-#define ESTIMATED_NUM_FILES 800 // used only by wxGccXmlInterface to prealloc mem
-
+#include <wx/arrimpl.cpp>
WX_DEFINE_OBJARRAY(wxTypeArray)
+WX_DEFINE_OBJARRAY(wxArgumentTypeArray)
WX_DEFINE_OBJARRAY(wxMethodArray)
WX_DEFINE_OBJARRAY(wxClassArray)
-// declared in ifacecheck.cpp
+#define PROGRESS_RATE 1000 // each PROGRESS_RATE nodes processed print a dot
+#define ESTIMATED_NUM_CLASSES 600 // used by both wxXmlInterface-derived classes to prealloc mem
+
+
+// defined in ifacecheck.cpp
extern bool g_verbose;
wxType wxEmptyType;
-void wxType::SetFromString(const wxString& t)
+void wxType::SetTypeFromString(const wxString& t)
{
- m_strType = t.Strip(wxString::both);
+ /*
+ TODO: optimize the following code writing a single function
+ which works at char-level and does everything in a single pass
+ */
+
+ m_strType = t;
// [] is the same as * for gccxml
m_strType.Replace("[]", "*");
+ m_strType.Replace("long int", "long"); // in wx typically we never write "long int", just "long"
+
+ // make sure the * and & operator always use the same spacing rules
+ // (to make sure GetAsString() output is always consistent)
+ m_strType.Replace("*", "* ");
+ m_strType.Replace("&", "& ");
+ m_strType.Replace(" *", "*");
+ m_strType.Replace(" &", "&");
+
+ while (m_strType.Contains(" "))
+ m_strType.Replace(" ", " "); // do it once again
+
+ m_strType.Replace(" ,", ",");
+
+ m_strType = m_strType.Strip(wxString::both);
}
bool wxType::IsOk() const
return false;
}
+
+// ----------------------------------------------------------------------------
+// wxArgumentType
+// ----------------------------------------------------------------------------
+
+void wxArgumentType::SetDefaultValue(const wxString& defval)
+{
+ m_strDefaultValue=defval;
+
+ // 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");
+
+
+ if (m_strDefaultValue.Contains("wxGetTranslation"))
+ m_strDefaultValue = wxEmptyString; // 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)
+ return false;
+
+ // we deliberately avoid checks on the argument name
+
+ return true;
+}
+
+
// ----------------------------------------------------------------------------
// wxMethod
// ----------------------------------------------------------------------------
return false;
// a function can't be both const and static or virtual and static!
- if ((m_bConst && m_bStatic) || (m_bVirtual && m_bStatic)) {
+ if ((m_bConst && m_bStatic) || ((m_bVirtual || m_bPureVirtual) && m_bStatic)) {
LogError("'%s' method can't be both const/static or virtual/static", m_strName);
return false;
}
+ wxASSERT((m_bVirtual && 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",
return true;
}
-void wxMethod::SetArgumentTypes(const wxTypeArray& arr, const wxArrayString& defaults)
-{
- wxASSERT(arr.GetCount()==defaults.GetCount());
-
- m_args=arr;
- m_argDefaults=defaults;
-
- // in order to make valid&simple comparison on argument defaults,
- // we reduce some of the multiple forms in which the same things may appear
- // to a single form
- for (unsigned int i=0; i<m_argDefaults.GetCount(); i++)
- {
- m_argDefaults[i].Replace("NULL", "0");
- m_argDefaults[i].Replace("0u", "0");
- }
-}
-
bool wxMethod::operator==(const wxMethod& m) const
{
if (GetReturnType() != m.GetReturnType() ||
GetName() != m.GetName() ||
IsConst() != m.IsConst() ||
IsStatic() != m.IsStatic() ||
- IsVirtual() != m.IsVirtual())
+ IsVirtual() != m.IsVirtual() ||
+ IsPureVirtual() != m.IsPureVirtual() ||
+ IsDeprecated() != m.IsDeprecated())
return false;
if (m_args.GetCount()!=m.m_args.GetCount())
return false;
for (unsigned int i=0; i<m_args.GetCount(); i++)
- if (m_args[i] != m.m_args[i] || m_argDefaults[i] != m.m_argDefaults[i])
+ if (m_args[i] != m.m_args[i])
return false;
return true;
}
-wxString wxMethod::GetAsString() const
+wxString wxMethod::GetAsString(bool bWithArgumentNames) const
{
wxString ret;
for (unsigned int i=0; i<m_args.GetCount(); i++)
{
ret += m_args[i].GetAsString();
- if (!m_argDefaults[i].IsEmpty())
- ret += " = " + m_argDefaults[i];
- ret += ",";
+
+ const wxString& name = m_args[i].GetArgumentName();
+ if (bWithArgumentNames && !name.IsEmpty())
+ ret += " " + name;
+
+ const wxString& def = m_args[i].GetDefaultValue();
+ if (!def.IsEmpty())
+ ret += " = " + def;
+
+ ret += ", ";
}
if (m_args.GetCount()>0)
- ret.RemoveLast();
+ ret = ret.Left(ret.Len()-2);
ret += ")";
ret += " const";
if (m_bStatic)
ret = "static " + ret;
- if (m_bVirtual)
+ if (m_bVirtual || m_bPureVirtual)
ret = "virtual " + ret;
+ if (m_bPureVirtual)
+ ret = ret + " = 0";
+
+ // in doxygen headers we don't need wxDEPRECATED:
+ //if (m_bDeprecated)
+ // ret = "wxDEPRECATED( " + ret + " )";
return ret;
}
stream << "[" + m_strName + "]";
for (unsigned int i=0; i<m_args.GetCount(); i++)
- stream << "[" + m_args[i].GetAsString() + "=" + m_argDefaults[i] + "]";
+ stream << "[" + m_args[i].GetAsString() + " " + m_args[i].GetArgumentName() +
+ "=" + m_args[i].GetDefaultValue() + "]";
if (IsConst())
stream << " CONST";
stream << " STATIC";
if (IsVirtual())
stream << " VIRTUAL";
+ if (IsPureVirtual())
+ stream << " PURE-VIRTUAL";
+ if (IsDeprecated())
+ stream << " DEPRECATED";
// no final newline
}
}
wxToResolveTypeHashMap toResolveTypes;
- //wxArrayString arrMemberIds;
wxClassMemberIdHashMap members;
wxTypeIdHashMap types;
wxTypeIdHashMap files;
// prealloc quite a lot of memory!
m_classes.Alloc(ESTIMATED_NUM_CLASSES);
- //arrMemberIds.Alloc(ESTIMATED_NUM_TYPES);
// build a list of wx classes and in general of all existent types
child = doc.GetRoot()->GetChildren();
}
else if (n == "FunctionType" || n == "MethodType")
{
- /* TODO: incomplete */
-
- unsigned long ret = 0;
- if (!getID(&ret, child->GetAttribute("returns")) || ret == 0) {
- LogError("Invalid empty returns value for '%s' node", n);
- return false;
+ /*
+ TODO: parsing FunctionType and MethodType nodes is not as easy
+ as for other "simple" types.
+ */
+
+ wxString argstr;
+ wxXmlNode *arg = child->GetChildren();
+ while (arg)
+ {
+ if (arg->GetName() == "Argument")
+ argstr += arg->GetAttribute("type") + ", ";
+ arg = arg->GetNext();
}
+ if (argstr.Len() > 0)
+ argstr = argstr.Left(argstr.Len()-2);
+
// these nodes make reference to other types... we'll resolve them later
- toResolveTypes[id] = toResolveTypeItem(ret, 0);
+ //toResolveTypes[id] = toResolveTypeItem(ret, 0);
+ types[id] = child->GetAttribute("returns") + "(" + argstr + ")";
}
else if (n == "File")
{
{
// this to-resolve-type references a "primary" type
- wxString newtype;
+ wxString newtype = primary->second;
int attribs = i->second.attribs;
+ // attribs may contain a combination of ATTRIB_* flags:
if (attribs & ATTRIB_CONST)
- newtype = "const " + primary->second;
+ newtype = "const " + newtype;
if (attribs & ATTRIB_REFERENCE)
- newtype = primary->second + "&";
+ newtype = newtype + "&";
if (attribs & ATTRIB_POINTER)
- newtype = primary->second + "*";
+ newtype = newtype + "*";
if (attribs & ATTRIB_ARRAY)
- newtype = primary->second + "[]";
+ newtype = newtype + "[]";
// add the resolved type to the list of "primary" types
types[id] = newtype;
}
else
{
-#if 1
LogError("Cannot solve '%s' reference type!", referenced);
return false;
-#else
- typeIds.Add(toResolveTypeIds[i]);
- typeNames.Add("TOFIX");
-
- // this one has been resolved!
- toResolveTypeIds.RemoveAt(i);
- toResolveRefType.RemoveAt(i);
- toResolveAttrib.RemoveAt(i);
- n--;
-#endif
}
}
}
}
// resolve argument types
- wxTypeArray argtypes;
- wxArrayString argdefs;
+ wxArgumentTypeArray argtypes;
wxXmlNode *arg = p->GetChildren();
while (arg)
{
return false;
}
- argtypes.Add(wxType(idx->second));
-
- wxString def = arg->GetAttribute("default");
- if (def.Contains("wxGetTranslation"))
- argdefs.Add(wxEmptyString); // TODO: wxGetTranslation gives problems to gccxml
- else
- argdefs.Add(def);
+ argtypes.Add(wxArgumentType(idx->second, arg->GetAttribute("default")));
}
arg = arg->GetNext();
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");
m.SetVirtual(p->GetAttribute("virtual") == "1");
+ m.SetPureVirtual(p->GetAttribute("pure_virtual") == "1");
+ m.SetDeprecated(p->GetAttribute("attributes") == "deprecated");
if (!m.IsOk()) {
LogError("The prototype '%s' is not valid!", m.GetAsString());
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();
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)
{
// if the <type> node has children, they should be all TEXT and <ref> 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 <defval> node
defstr = GetTextFromChildren(n);
else if (n->GetName() == "array")
arrstr = GetTextFromChildren(n);
return false;
}
- args.Add(wxType(typestr + arrstr));
- defs.Add(defstr);
+ args.Add(wxArgumentType(typestr + arrstr, defstr, namestr));
}
else if (child->GetName() == "location")
{
+ line = -1;
if (child->GetAttribute("line").ToLong(&line))
m.SetLocation((int)line);
header = child->GetAttribute("file");
}
+ else if (child->GetName() == "detaileddescription")
+ {
+ // when a method has a @deprecated tag inside its description,
+ // Doxygen outputs somewhere nested inside <detaileddescription>
+ // a <xreftitle>Deprecated</xreftitle> tag.
+ m.SetDeprecated(HasTextNodeContaining(child, "Deprecated"));
+ }
child = child->GetNext();
}
- m.SetArgumentTypes(args, defs);
+ m.SetArgumentTypes(args);
m.SetConst(p->GetAttribute("const")=="yes");
m.SetStatic(p->GetAttribute("static")=="yes");
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());
projects / wxWidgets.git / blobdiff