Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added wxArgumentType; added parsing of argument names, so that the modify mode retains them when writing correct prototypes

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@52770 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Francesco Montorsi
2008-03-24 22:08:45 +00:00
parent a7be99c803
commit f270e1ddda
3 changed files with 123 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
utils/ifacecheck/src/ifacecheck.cpp
View File

@@ -336,8 +336,22 @@ void IfaceCheckApp::FixMethod(const wxString& header, const wxMethod* iface, con
file.InsertLine(INDENTATION_STR + "*/", start++);
}
wxMethod tmp(*api);
// discard API argument names and replace them with those parsed from doxygen XML:
const wxArgumentTypeArray& doxygenargs = iface->GetArgumentTypes();
const wxArgumentTypeArray& realargs = api->GetArgumentTypes();
if (realargs.GetCount() == doxygenargs.GetCount())
{
for (unsigned int j=0; j<doxygenargs.GetCount(); j++)
if (doxygenargs[j]==realargs[j])
realargs[j].SetArgumentName(doxygenargs[j].GetArgumentName());
tmp.SetArgumentTypes(realargs);
}
// insert the new one
file.InsertLine(INDENTATION_STR + api->GetAsString() + ";", start);
file.InsertLine(INDENTATION_STR + tmp.GetAsString() + ";", start);
// now save the modification
if (!file.Write()) {

102
utils/ifacecheck/src/xmlparser.cpp
View File

@@ -28,6 +28,7 @@
#include <wx/arrimpl.cpp>
WX_DEFINE_OBJARRAY(wxTypeArray)
WX_DEFINE_OBJARRAY(wxArgumentTypeArray)
WX_DEFINE_OBJARRAY(wxMethodArray)
WX_DEFINE_OBJARRAY(wxClassArray)
@@ -47,7 +48,7 @@ extern bool g_verbose;
wxType wxEmptyType;
void wxType::SetFromString(const wxString& t)
void wxType::SetTypeFromString(const wxString& t)
{
/*
TODO: optimize the following code writing a single function
@@ -109,6 +110,44 @@ bool wxType::operator==(const wxType& m) 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
// ----------------------------------------------------------------------------
@@ -145,23 +184,6 @@ bool wxMethod::IsOk() const
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() ||
@@ -177,13 +199,13 @@ bool wxMethod::operator==(const wxMethod& m) const
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;
@@ -196,8 +218,15 @@ wxString wxMethod::GetAsString() const
for (unsigned int i=0; i<m_args.GetCount(); i++)
{
ret += m_args[i].GetAsString();
if (!m_argDefaults[i].IsEmpty())
ret += " = " + m_argDefaults[i];
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 += ", ";
}
@@ -228,7 +257,8 @@ void wxMethod::Dump(wxTextOutputStream& stream) const
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";
@@ -812,8 +842,7 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p,
}
// resolve argument types
wxTypeArray argtypes;
wxArrayString argdefs;
wxArgumentTypeArray argtypes;
wxXmlNode *arg = p->GetChildren();
while (arg)
{
@@ -832,13 +861,7 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p,
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();
@@ -846,7 +869,7 @@ 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");
m.SetVirtual(p->GetAttribute("virtual") == "1");
@@ -1076,8 +1099,7 @@ static bool HasTextNodeContaining(const wxXmlNode *parent, const wxString& name)
bool wxXmlDoxygenInterface::ParseMethod(const wxXmlNode* p, wxMethod& m, wxString& header)
{
wxTypeArray args;
wxArrayString defs;
wxArgumentTypeArray args;
long line;
wxXmlNode *child = p->GetChildren();
@@ -1089,7 +1111,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)
{
@@ -1097,8 +1119,9 @@ bool wxXmlDoxygenInterface::ParseMethod(const wxXmlNode* p, wxMethod& m, wxStrin
// 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);
@@ -1111,8 +1134,7 @@ bool wxXmlDoxygenInterface::ParseMethod(const wxXmlNode* p, wxMethod& m, wxStrin
return false;
}
args.Add(wxType(typestr + arrstr));
defs.Add(defstr);
args.Add(wxArgumentType(typestr + arrstr, defstr, namestr));
}
else if (child->GetName() == "location")
{
@@ -1132,7 +1154,7 @@ bool wxXmlDoxygenInterface::ParseMethod(const wxXmlNode* p, wxMethod& m, wxStrin
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");

60
utils/ifacecheck/src/xmlparser.h
View File

@@ -32,14 +32,12 @@ class wxType
public:
wxType() {}
wxType(const wxString& type)
{ SetFromString(type); }
{ SetTypeFromString(type); }
void SetFromString(const wxString& t);
void SetTypeFromString(const wxString& t);
wxString GetAsString() const
{ return m_strType; }
wxString GetClean() const;
bool IsConst() const
{ return m_strType.Contains("const"); }
bool IsStatic() const
@@ -57,12 +55,49 @@ public:
protected:
wxString m_strType;
// utility for doing comparisons
wxString GetClean() const;
};
extern wxType wxEmptyType;
WX_DECLARE_OBJARRAY(wxType, wxTypeArray);
// ----------------------------------------------------------------------------
// Represents a type used as argument for some wxMethod
// ----------------------------------------------------------------------------
class wxArgumentType : public wxType
{
public:
wxArgumentType() {}
wxArgumentType(const wxString& type, const wxString& defVal,
const wxString& argName = wxEmptyString)
{ SetTypeFromString(type); SetDefaultValue(defVal); m_strArgName = argName; }
void SetArgumentName(const wxString& name)
{ m_strArgName=name.Strip(wxString::both); }
wxString GetArgumentName() const
{ return m_strArgName; }
void SetDefaultValue(const wxString& defval);
wxString GetDefaultValue() const
{ return m_strDefaultValue; }
bool operator==(const wxArgumentType& m) const;
bool operator!=(const wxArgumentType& m) const
{ return !(*this == m); }
protected:
wxString m_strDefaultValue;
wxString m_strArgName; // this one only makes sense when this wxType is
// used as argument type (and not as return type)
// and can be empty.
};
extern wxArgumentType wxEmptyArgumentType;
WX_DECLARE_OBJARRAY(wxArgumentType, wxArgumentTypeArray);
// ----------------------------------------------------------------------------
// Represents a single prototype of a class' member.
@@ -74,17 +109,16 @@ public:
{ m_bConst=m_bVirtual=m_bPureVirtual=m_bStatic=m_bDeprecated=false; m_nLine=-1; }
wxMethod(const wxType& rettype, const wxString& name,
const wxTypeArray& arguments, const wxArrayString& defaults,
const wxArgumentTypeArray& arguments,
bool isConst, bool isStatic, bool isVirtual)
: m_retType(rettype), m_strName(name.Strip(wxString::both)),
m_bConst(isConst), m_bStatic(isStatic), m_bVirtual(isVirtual)
{ SetArgumentTypes(arguments,defaults); m_nLine=-1; }
{ SetArgumentTypes(arguments); m_nLine=-1; }
public: // getters
//void SetFromString(const wxString& proto);
wxString GetAsString() const;
wxString GetAsString(bool bWithArgumentNames = true) const;
// parser of the prototype:
// all these functions return strings with spaces stripped
@@ -92,10 +126,8 @@ public: // getters
{ return m_retType; }
wxString GetName() const
{ return m_strName; }
wxTypeArray GetArgumentTypes() const
wxArgumentTypeArray GetArgumentTypes() const
{ return m_args; }
wxArrayString GetArgumentDefaults() const
{ return m_argDefaults; }
int GetLocation() const
{ return m_nLine; }
@@ -124,7 +156,8 @@ public: // setters
{ m_retType=t; }
void SetName(const wxString& name)
{ m_strName=name; }
void SetArgumentTypes(const wxTypeArray& arr, const wxArrayString& defaults);
void SetArgumentTypes(const wxArgumentTypeArray& arr)
{ m_args=arr; }
void SetConst(bool c = true)
{ m_bConst=c; }
void SetStatic(bool c = true)
@@ -149,8 +182,7 @@ public: // misc
protected:
wxType m_retType;
wxString m_strName;
wxTypeArray m_args;
wxArrayString m_argDefaults;
wxArgumentTypeArray m_args;
bool m_bConst;
bool m_bStatic;
bool m_bVirtual;