added wxArgumentType; added parsing of argument names, so that the modify mode retain...

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

diff --git a/utils/ifacecheck/src/ifacecheck.cpp b/utils/ifacecheck/src/ifacecheck.cpp
index 3a6a2bbec8d758d61ba420d1f2b18a21727deaf3..8e4f593ce5d48d72ace686145858b7fcd108596b 100644 (file)
--- a/utils/ifacecheck/src/ifacecheck.cpp
+++ b/utils/ifacecheck/src/ifacecheck.cpp
@@ -336,8 +336,22 @@ void IfaceCheckApp::FixMethod(const wxString& header, const wxMethod* iface, con
         file.InsertLine(INDENTATION_STR + "*/", start++);
     }
 
         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
     // 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()) {
 
     // now save the modification
     if (!file.Write()) {

diff --git a/utils/ifacecheck/src/xmlparser.cpp b/utils/ifacecheck/src/xmlparser.cpp
index c8954f49fb1c3c9b308de3df2f58e01103c29c5b..728629371c3280995ebfd6dd68db6fee07c56bab 100644 (file)
--- a/utils/ifacecheck/src/xmlparser.cpp
+++ b/utils/ifacecheck/src/xmlparser.cpp
@@ -28,6 +28,7 @@
 
 #include <wx/arrimpl.cpp>
 WX_DEFINE_OBJARRAY(wxTypeArray)
 
 #include <wx/arrimpl.cpp>
 WX_DEFINE_OBJARRAY(wxTypeArray)

+WX_DEFINE_OBJARRAY(wxArgumentTypeArray)

 WX_DEFINE_OBJARRAY(wxMethodArray)
 WX_DEFINE_OBJARRAY(wxClassArray)
 
 WX_DEFINE_OBJARRAY(wxMethodArray)
 WX_DEFINE_OBJARRAY(wxClassArray)
 


@@ -47,7 +48,7 @@ extern bool g_verbose;
 
 wxType wxEmptyType;
 
 
 wxType wxEmptyType;
 

-void wxType::SetFromString(const wxString& t)
+void wxType::SetTypeFromString(const wxString& t)

 {
     /*
         TODO: optimize the following code writing a single function
 {
     /*
         TODO: optimize the following code writing a single function


@@ -109,6 +110,44 @@ bool wxType::operator==(const wxType& m) const
     return false;
 }
 
     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
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxMethod
 // ----------------------------------------------------------------------------


@@ -145,23 +184,6 @@ bool wxMethod::IsOk() const
     return true;
 }
 
     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() ||
 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++)
         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;
 }
 
             return false;
 
     return true;
 }
 

-wxString wxMethod::GetAsString() const
+wxString wxMethod::GetAsString(bool bWithArgumentNames) const

 {
     wxString ret;
 
 {
     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();
     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 += ", ";
     }
 
         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_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";
 
     if (IsConst())
         stream << " CONST";


@@ -812,8 +842,7 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p,
     }
 
     // resolve argument types
     }
 
     // resolve argument types

-    wxTypeArray argtypes;
-    wxArrayString argdefs;
+    wxArgumentTypeArray argtypes;

     wxXmlNode *arg = p->GetChildren();
     while (arg)
     {
     wxXmlNode *arg = p->GetChildren();
     while (arg)
     {


@@ -832,13 +861,7 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p,
                 return false;
             }
 
                 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();
         }
 
         arg = arg->GetNext();


@@ -846,7 +869,7 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p,
 
     m.SetReturnType(ret);
     m.SetName(name);
 
     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.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)
 {
 
 bool wxXmlDoxygenInterface::ParseMethod(const wxXmlNode* p, wxMethod& m, wxString& header)
 {

-    wxTypeArray args;
-    wxArrayString defs;
+    wxArgumentTypeArray args;

     long line;
 
     wxXmlNode *child = p->GetChildren();
     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")
         {
             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)
             {
             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);
                     // 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")
                 else if (n->GetName() == "defval")

-                    // same for the <defval> node

                     defstr = GetTextFromChildren(n);
                 else if (n->GetName() == "array")
                     arrstr = GetTextFromChildren(n);
                     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;
             }
 
                 return false;
             }
 

-            args.Add(wxType(typestr + arrstr));
-            defs.Add(defstr);
+            args.Add(wxArgumentType(typestr + arrstr, defstr, namestr));

         }
         else if (child->GetName() == "location")
         {
         }
         else if (child->GetName() == "location")
         {


@@ -1132,7 +1154,7 @@ bool wxXmlDoxygenInterface::ParseMethod(const wxXmlNode* p, wxMethod& m, wxStrin
         child = child->GetNext();
     }
 
         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.SetConst(p->GetAttribute("const")=="yes");
     m.SetStatic(p->GetAttribute("static")=="yes");
     m.SetVirtual(p->GetAttribute("virt")=="virtual");

diff --git a/utils/ifacecheck/src/xmlparser.h b/utils/ifacecheck/src/xmlparser.h
index cac59de9e89444386b8939489398e1255531dc60..4baa76de1c5578f44a0d2decafa6bae655594f27 100644 (file)
--- a/utils/ifacecheck/src/xmlparser.h
+++ b/utils/ifacecheck/src/xmlparser.h
@@ -32,14 +32,12 @@ class wxType
 public:
     wxType() {}
     wxType(const wxString& type)
 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 GetAsString() const
         { return m_strType; }
 

-    wxString GetClean() const;
-

     bool IsConst() const
         { return m_strType.Contains("const"); }
     bool IsStatic() const
     bool IsConst() const
         { return m_strType.Contains("const"); }
     bool IsStatic() const


@@ -57,12 +55,49 @@ public:
 
 protected:
     wxString m_strType;
 
 protected:
     wxString m_strType;

+
+    // utility for doing comparisons
+    wxString GetClean() const;

 };
 
 extern wxType wxEmptyType;
 WX_DECLARE_OBJARRAY(wxType, wxTypeArray);
 
 
 };
 
 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.
 
 // ----------------------------------------------------------------------------
 // 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,
         { 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)
              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
 
 
 
 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
 
     // 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; }
         { return m_retType; }
     wxString GetName() const
         { return m_strName; }

-    wxTypeArray GetArgumentTypes() const
+    wxArgumentTypeArray GetArgumentTypes() const

         { return m_args; }
         { return m_args; }

-    wxArrayString GetArgumentDefaults() const
-        { return m_argDefaults; }

     int GetLocation() const
         { return m_nLine; }
 
     int GetLocation() const
         { return m_nLine; }
 


@@ -124,7 +156,8 @@ public:     // setters
         { m_retType=t; }
     void SetName(const wxString& name)
         { m_strName=name; }
         { 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)
     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;
 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;
     bool m_bConst;
     bool m_bStatic;
     bool m_bVirtual;