prototype fixes (in particular fix missing default value initializers)

[wxWidgets.git] / utils / ifacecheck / src / xmlparser.cpp

diff --git a/utils/ifacecheck/src/xmlparser.cpp b/utils/ifacecheck/src/xmlparser.cpp
index d5513341f61bf2da17c32232b3a001c0e655b859..35c9e008a374299e8bf35ba69964839880e073cb 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,12 +48,32 @@ extern bool g_verbose;
 
 wxType wxEmptyType;
 
 
 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("[]", "*");
 
     // [] 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
 }
 
 bool wxType::IsOk() const


@@ -89,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
 // ----------------------------------------------------------------------------


@@ -106,11 +165,13 @@ bool wxMethod::IsOk() const
         return false;
 
     // a function can't be both const and static or virtual and static!
         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;
     }
 
         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",
     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",


@@ -125,23 +186,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() ||


@@ -149,6 +193,7 @@ bool wxMethod::operator==(const wxMethod& m) const
         IsConst() != m.IsConst() ||
         IsStatic() != m.IsStatic() ||
         IsVirtual() != m.IsVirtual() ||
         IsConst() != m.IsConst() ||
         IsStatic() != m.IsStatic() ||
         IsVirtual() != m.IsVirtual() ||

+        IsPureVirtual() != m.IsPureVirtual() ||

         IsDeprecated() != m.IsDeprecated())
         return false;
 
         IsDeprecated() != m.IsDeprecated())
         return false;
 


@@ -156,13 +201,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;
 


@@ -175,13 +220,20 @@ 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];
-        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)
     }
 
     if (m_args.GetCount()>0)

-        ret.RemoveLast();
+        ret = ret.Left(ret.Len()-2);

 
     ret += ")";
 
 
     ret += ")";
 


@@ -189,11 +241,14 @@ wxString wxMethod::GetAsString() const
         ret += " const";
     if (m_bStatic)
         ret = "static " + ret;
         ret += " const";
     if (m_bStatic)
         ret = "static " + ret;

-    if (m_bVirtual)
+    if (m_bVirtual || m_bPureVirtual)

         ret = "virtual " + ret;
         ret = "virtual " + ret;

+    if (m_bPureVirtual)
+        ret = ret + " = 0";

 
 

-    if (m_bDeprecated)
-        ret = "wxDEPRECATED( " + ret + " )";
+    // in doxygen headers we don't need wxDEPRECATED:
+    //if (m_bDeprecated)
+    //    ret = "wxDEPRECATED( " + ret + " )";

 
     return ret;
 }
 
     return ret;
 }


@@ -204,7 +259,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";


@@ -212,6 +268,8 @@ void wxMethod::Dump(wxTextOutputStream& stream) const
         stream << " STATIC";
     if (IsVirtual())
         stream << " VIRTUAL";
         stream << " STATIC";
     if (IsVirtual())
         stream << " VIRTUAL";

+    if (IsPureVirtual())
+        stream << " PURE-VIRTUAL";

     if (IsDeprecated())
         stream << " DEPRECATED";
 
     if (IsDeprecated())
         stream << " DEPRECATED";
 


@@ -629,17 +687,18 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
             {
                 // this to-resolve-type references a "primary" type
 
             {
                 // this to-resolve-type references a "primary" type
 

-                wxString newtype;
+                wxString newtype = primary->second;

                 int attribs = i->second.attribs;
 
                 int attribs = i->second.attribs;
 

+                // attribs may contain a combination of ATTRIB_* flags:

                 if (attribs & ATTRIB_CONST)
                 if (attribs & ATTRIB_CONST)

-                    newtype = "const " + primary->second;
+                    newtype = "const " + newtype;

                 if (attribs & ATTRIB_REFERENCE)
                 if (attribs & ATTRIB_REFERENCE)

-                    newtype = primary->second + "&";
+                    newtype = newtype + "&";

                 if (attribs & ATTRIB_POINTER)
                 if (attribs & ATTRIB_POINTER)

-                    newtype = primary->second + "*";
+                    newtype = newtype + "*";

                 if (attribs & ATTRIB_ARRAY)
                 if (attribs & ATTRIB_ARRAY)

-                    newtype = primary->second + "[]";
+                    newtype = newtype + "[]";

 
                 // add the resolved type to the list of "primary" types
                 types[id] = newtype;
 
                 // add the resolved type to the list of "primary" types
                 types[id] = newtype;


@@ -785,8 +844,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)
     {


@@ -805,13 +863,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();


@@ -819,10 +871,11 @@ 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");

+    m.SetPureVirtual(p->GetAttribute("pure_virtual") == "1");

     m.SetDeprecated(p->GetAttribute("attributes") == "deprecated");
 
     if (!m.IsOk()) {
     m.SetDeprecated(p->GetAttribute("attributes") == "deprecated");
 
     if (!m.IsOk()) {


@@ -1048,8 +1101,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();


@@ -1061,7 +1113,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)
             {


@@ -1069,8 +1121,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);


@@ -1083,11 +1136,11 @@ 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")
         {

+            line = -1;

             if (child->GetAttribute("line").ToLong(&line))
                 m.SetLocation((int)line);
             header = child->GetAttribute("file");
             if (child->GetAttribute("line").ToLong(&line))
                 m.SetLocation((int)line);
             header = child->GetAttribute("file");


@@ -1103,10 +1156,11 @@ 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");

+    m.SetPureVirtual(p->GetAttribute("virt")=="pure-virtual");

 
     if (!m.IsOk()) {
         LogError("The prototype '%s' is not valid!", m.GetAsString());
 
     if (!m.IsOk()) {
         LogError("The prototype '%s' is not valid!", m.GetAsString());