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

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@52770 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

utils/ifacecheck/src/ifacecheck.cpp

@@ -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()) {

utils/ifacecheck/src/xmlparser.cpp

@@ -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;
+    wxArgumentTypeArray argtypes;
-    wxArrayString argdefs;
     wxXmlNode *arg = p->GetChildren();
     while (arg)
     {
@@ -832,13 +861,7 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p,
                 return false;
             }
 
-            argtypes.Add(wxType(idx->second));
+            argtypes.Add(wxArgumentType(idx->second, arg->GetAttribute("default")));
-
-            wxString def = arg->GetAttribute("default");
-            if (def.Contains("wxGetTranslation"))
-                argdefs.Add(wxEmptyString);     // TODO: wxGetTranslation gives problems to gccxml
-            else
-                argdefs.Add(def);
         }
 
         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;
+    wxArgumentTypeArray args;
-    wxArrayString defs;
     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));
+            args.Add(wxArgumentType(typestr + arrstr, defstr, namestr));
-            defs.Add(defstr);
         }
         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");

utils/ifacecheck/src/xmlparser.h

@@ -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(bool bWithArgumentNames = true) const;
-    wxString GetAsString() 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;
+    wxArgumentTypeArray m_args;
-    wxArrayString m_argDefaults;
     bool m_bConst;
     bool m_bStatic;
     bool m_bVirtual;