X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/74bda2038c4bf33ebb99dbdfaca2801329c301e2..a6052817bb8cc906c8fc1dc801f8f21c58041f92:/utils/ifacecheck/src/xmlparser.cpp

diff --git a/utils/ifacecheck/src/xmlparser.cpp b/utils/ifacecheck/src/xmlparser.cpp
index c36cc450d6..35c9e008a3 100644
--- a/utils/ifacecheck/src/xmlparser.cpp
+++ b/utils/ifacecheck/src/xmlparser.cpp
@@ -21,25 +21,23 @@
 
 #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;
 
 
@@ -50,12 +48,32 @@ 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
@@ -92,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
 // ----------------------------------------------------------------------------
@@ -109,11 +165,13 @@ bool wxMethod::IsOk() const
         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",
@@ -128,43 +186,28 @@ 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() ||
         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;
 
@@ -177,13 +220,20 @@ 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];
-        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 += ")";
 
@@ -191,8 +241,14 @@ wxString wxMethod::GetAsString() const
         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;
 }
@@ -203,7 +259,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";
@@ -211,6 +268,10 @@ void wxMethod::Dump(wxTextOutputStream& stream) const
         stream << " STATIC";
     if (IsVirtual())
         stream << " VIRTUAL";
+    if (IsPureVirtual())
+        stream << " PURE-VIRTUAL";
+    if (IsDeprecated())
+        stream << " DEPRECATED";
 
     // no final newline
 }
@@ -460,14 +521,12 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
     }
 
     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();
@@ -547,16 +606,26 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
         }
         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")
         {
@@ -618,17 +687,18 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
             {
                 // 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;
@@ -654,19 +724,8 @@ bool wxXmlGccInterface::Parse(const wxString& filename)
                 }
                 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
                 }
             }
         }
@@ -785,8 +844,7 @@ bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p,
     }
 
     // resolve argument types
-    wxTypeArray argtypes;
-    wxArrayString argdefs;
+    wxArgumentTypeArray argtypes;
     wxXmlNode *arg = p->GetChildren();
     while (arg)
     {
@@ -805,13 +863,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();
@@ -819,10 +871,12 @@ 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");
+    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());
@@ -1016,10 +1070,38 @@ static wxString GetTextFromChildren(const wxXmlNode *n)
     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();
@@ -1031,7 +1113,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)
             {
@@ -1039,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);
+                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);
@@ -1053,23 +1136,31 @@ 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")
         {
+            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());