#include "wx/arrimpl.cpp"
#include "wx/dynarray.h"
#include "wx/filename.h"
+
+#include <errno.h>
+
#include "xmlparser.h"
#define PROGRESS_RATE 1000 // each PROGRESS_RATE nodes processed print a dot
}
}
-
-/*
-void wxMethod::SetFromString(const wxString& proto)
-{
- m_strProto=proto.Strip(wxString::both);
-
- // make sure there is a space separing each token
- m_strProto.Replace("&", "& ");
- m_strProto.Replace("*", "* ");
- m_strProto.Replace(",", ", ");
-
- wxASSERT(m_strProto.Contains("::"));
- wxASSERT(m_strProto.Contains("(") && m_strProto.Contains(")"));
-}
-
-wxType wxMethod::GetReturnType() const
-{
- wxString leftpart = m_strProto.Left(m_strProto.Find("::")).Strip(wxString::both);
- if (!leftpart.Contains(" "))
- // this is a dtor or a ctor then...
- return wxEmptyType;
-
- // see SetFromString: all tokens are separed by a space!
- wxType ret(leftpart.BeforeFirst(' ').Strip(wxString::both));
- wxASSERT(ret.IsOk());
-
- return ret;
-}
-
-wxString wxMethod::GetName() const
-{
- int nstart = m_strProto.Find("::")+2,
- nend = m_strProto.Find("(");
- wxASSERT(nstart!=wxNOT_FOUND && nend!=wxNOT_FOUND);
-
- return m_strProto.Mid(nstart, nend-nstart).Strip(wxString::both);
-}
-
-bool wxMethod::IsConst() const
-{
- return m_strProto.EndsWith("const");
-}
-
-bool wxMethod::IsStatic() const
-{
- return m_strProto.StartsWith("static");
-}
-
-wxTypeArray wxMethod::GetArgumentTypes() const
-{
- int nstart = m_strProto.Find('(', false * start from beginning *)+1,
- nend = m_strProto.Find(')', true * start from end *);
- wxASSERT(nstart!=wxNOT_FOUND && nend!=wxNOT_FOUND);
-
- wxString argstr = m_strProto.Mid(nstart, nend-nstart).Strip(wxString::both);
- wxArrayString args = wxSplit(argstr, ',');
-
- wxTypeArray ret;
- for (unsigned int i=0; i<args.GetCount(); i++)
- {
- wxString arg = args[i].Strip(wxString::both);
-
- // arg may contain both the type and the argument name;
- // we need to get rid of the last one...
- wxArrayString temp = wxSplit(arg, ' ');
-
- if (temp.GetCount()>1 &&
- !temp.Last().Contains("&") &&
- !temp.Last().Contains("*") &&
- g_)
- arg.Replace(temp.Last(), ""); // looks like an argument name - remove it
-
- ret.Add(wxType(arg));
- }
-
- return ret;
-}
-*/
bool wxMethod::operator==(const wxMethod& m) const
{
if (GetReturnType() != m.GetReturnType() ||
}
// ----------------------------------------------------------------------------
-// wxXmlGccInterface
+// wxXmlGccInterface helper declarations
// ----------------------------------------------------------------------------
#define ATTRIB_CONST 1
#define ATTRIB_POINTER 4
#define ATTRIB_ARRAY 8
+#define GCCXML_BASE 35
+
class toResolveTypeItem
{
public:
toResolveTypeItem() { attribs=0; }
- toResolveTypeItem(const wxString& namestr, int attribint)
- : ref(namestr), attribs(attribint) {}
+ toResolveTypeItem(unsigned int refID, unsigned int attribint)
+ : ref(refID), attribs(attribint) {}
- wxString ref;
- int attribs;
+ unsigned long ref, attribs;
};
-//WX_DECLARE_STRING_HASH_MAP( toResolveTypeItem, wxToResolveTypeHashMap );
+#if 1
+
+// for wxToResolveTypeHashMap, keys == gccXML IDs and values == toResolveTypeItem
+WX_DECLARE_HASH_MAP( unsigned long, toResolveTypeItem,
+ wxIntegerHash, wxIntegerEqual,
+ wxToResolveTypeHashMap );
+
+// for wxClassMemberIdHashMap, keys == gccXML IDs and values == wxClass which owns that member ID
+WX_DECLARE_HASH_MAP( unsigned long, wxClass*,
+ wxIntegerHash, wxIntegerEqual,
+ wxClassMemberIdHashMap );
+#else
#include <map>
-typedef std::map<wxString, toResolveTypeItem> wxToResolveTypeHashMap;
+typedef std::map<unsigned long, toResolveTypeItem> wxToResolveTypeHashMap;
+#endif
-bool wxXmlGccInterface::Parse(const wxString& filename)
-{
- wxXmlDocument doc;
- wxXmlNode *child;
- int nodes = 0;
- LogMessage("Parsing %s...", filename);
+// utility to parse gccXML ID values;
+// this function is equivalent to wxString(str).Mid(1).ToULong(&id, GCCXML_BASE)
+// but is a little bit faster
+bool getID(unsigned long *id, const wxStringCharType* str)
+{
+ wxStringCharType *end;
+#if wxUSE_UNICODE_UTF8
+ unsigned long val = strtoul(str+1, &end, GCCXML_BASE);
+#else
+ unsigned long val = wcstoul(str+1, &end, GCCXML_BASE);
+#endif
- if (!doc.Load(filename)) {
- LogError("can't load %s", filename);
+ // return true only if scan was stopped by the terminating NUL and
+ // if the string was not empty to start with and no under/overflow
+ // occurred:
+ if ( *end != '\0' || end == str+1 || errno == ERANGE || errno == EINVAL )
return false;
- }
- // start processing the XML file
- if (doc.GetRoot()->GetName() != "GCC_XML") {
- LogError("invalid root node for %s", filename);
- return false;
- }
+ *id = val;
+ return true;
+}
- wxToResolveTypeHashMap toResolveTypes;
- wxArrayString arrMemberIds;
- wxStringHashMap types;
- wxStringHashMap files;
+// utility specialized to parse efficiently the gccXML list of IDs which occur
+// in nodes like <Class> ones... i.e. numeric values separed by " _" token
+bool getMemberIDs(wxClassMemberIdHashMap* map, wxClass* p, const wxStringCharType* str)
+{
+#if wxUSE_UNICODE_UTF8
+ size_t len = strlen(str);
+#else
+ size_t len = wcslen(str);
+#endif
- // prealloc quite a lot of memory!
- m_classes.Alloc(ESTIMATED_NUM_CLASSES);
- arrMemberIds.Alloc(ESTIMATED_NUM_TYPES);
+ if (len == 0 || str[0] != '_')
+ return false;
-#if 0
- // do a quick parsing of the <File> nodes; we take advantage of the fact that
- // gccxml puts all of them in a contiguos block at the end of the file it produces.
- child = doc.GetRoot()->GetChildren();
- while (child && child->GetName() != "File")
- child = child->GetNext(); // skip everything until first <File> node
+ const wxStringCharType *curpos = str,
+ *end = str + len;
+ wxStringCharType *nexttoken;
- // here starts the <File> node block
- while (child)
+ while (curpos < end)
{
- wxString id = child->GetAttribute("id", "");
- if (!id.StartsWith("f")) {
- LogError("Unexpected file ID: %s", id);
+ // curpos always points to the underscore of the next token to parse:
+#if wxUSE_UNICODE_UTF8
+ unsigned long id = strtoul(curpos+1, &nexttoken, GCCXML_BASE);
+#else
+ unsigned long id = wcstoul(curpos+1, &nexttoken, GCCXML_BASE);
+#endif
+ if ( *nexttoken != ' ' || errno == ERANGE || errno == EINVAL )
return false;
- }
- fileIds.Add(id);
- fileNames.Add(child->GetAttribute("name", ""));
+ // advance current position
+ curpos = nexttoken + 1;
- child = child->GetNext();
- }
-#endif
-
-#if 0
- wxString allWxClassesIds, allWxMethodsIds, allWxReferencesIds;
- allWxClassesIds.Alloc(240000);
- allWxMethodsIds.Alloc(240000);
- allWxReferencesIds.Alloc(240000);
- child = doc.GetRoot()->GetChildren();
- while (child)
- {
- if (child->GetName() == "Class")
- if (child->GetAttribute("name", wxEmptyString).StartsWith("wx"))
- allWxClassesIds += " " + child->GetAttribute("members", wxEmptyString);
- child = child->GetNext();
+ // add this ID to the hashmap
+ wxClassMemberIdHashMap::value_type v(id, p);
+ map->insert(v);
}
- child = doc.GetRoot()->GetChildren();
- while (child)
- {
- wxString n = child->GetName();
- if ((n == "Method" || n == "Constructor" || n == "Destructor" || n == "OperatorMethod") &&
- child->GetAttribute("access", wxEmptyString) == "public")
- {
- if (allWxClassesIds.Contains(child->GetAttribute("id", wxEmptyString)))
- {
- allWxMethodsIds += " " + child->GetAttribute("returns", wxEmptyString);
+ return true;
+}
- wxXmlNode *arg = child->GetChildren();
- while (arg)
- {
- if (arg->GetName() == "Argument")
- allWxMethodsIds += " " + arg->GetAttribute("type", wxEmptyString);
- arg = arg->GetNext();
- }
- }
- }
+// ----------------------------------------------------------------------------
+// wxXmlGccInterface
+// ----------------------------------------------------------------------------
- child = child->GetNext();
- }
+bool wxXmlGccInterface::Parse(const wxString& filename)
+{
+ wxXmlDocument doc;
+ wxXmlNode *child;
+ int nodes = 0;
- child = doc.GetRoot()->GetChildren();
- while (child)
- {
- if (allWxMethodsIds.Contains(child->GetAttribute("id", wxEmptyString)))
- {
- const wxString& type = child->GetAttribute("type", wxEmptyString);
- allWxReferencesIds += " " + type;
- }
+ LogMessage("Parsing %s...", filename);
- child = child->GetNext();
+ if (!doc.Load(filename)) {
+ LogError("can't load %s", filename);
+ return false;
}
- child = doc.GetRoot()->GetChildren();
- while (child)
- {
- if (allWxReferencesIds.Contains(child->GetAttribute("id", wxEmptyString)))
- {
- const wxString& type = child->GetAttribute("type", wxEmptyString);
- allWxReferencesIds += " " + type;
- }
-
- child = child->GetNext();
+ // start processing the XML file
+ if (doc.GetRoot()->GetName() != "GCC_XML") {
+ LogError("invalid root node for %s", filename);
+ return false;
}
- LogMessage("adfafdasfdas %d-%d-%d", allWxClassesIds.Len(),
- allWxMethodsIds.Len(), allWxReferencesIds.Len());
-#endif
+ 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();
while (child)
{
const wxString& n = child->GetName();
- const wxString& id = child->GetAttribute("id", wxEmptyString);
-#if 0
- if (!allWxClassesIds.Contains(id) && !allWxMethodsIds.Contains(id) && !allWxReferencesIds.Contains(id))
- ; // ignore this node
- else
-#endif
-#if 0
- wxString fid = child->GetAttribute("file", "");
- int fileidx = wxNOT_FOUND;
-
- if (!fid.IsEmpty()) {
- fileidx = fileIds.Index(fid);
- if (fileidx == wxNOT_FOUND) {
- LogError("couldn't find the file ID '%s'", fid);
- return false;
- }
- }
+ unsigned long id = 0;
+ if (!getID(&id, child->GetAttribute("id")) || (id == 0 && n != "File")) {
- if (fileidx!=wxNOT_FOUND && !fileNames[fileidx].Contains("wx"))
- {
- // skip this node: not wx related!
- } else
-#endif
+ // NOTE: <File> nodes can have an id == "f0"...
- /*if (child->GetAttribute("artificial", "") == "1")
- {
- // discard this immediately - we're not interested
+ LogError("Invalid id for node %s: %s", n, child->GetAttribute("id"));
+ return false;
}
- else*/
+
if (n == "Class")
{
- wxString cname = child->GetAttribute("name", wxEmptyString);
+ wxString cname = child->GetAttribute("name");
if (cname.IsEmpty()) {
LogError("Invalid empty name for '%s' node", n);
return false;
}
// only register wx classes (do remember also the IDs of their members)
- if (cname.StartsWith("wx")) {
- arrMemberIds.Add(child->GetAttribute("members", wxEmptyString));
-
+ if (cname.StartsWith("wx"))
+ {
// NB: "file" attribute contains an ID value that we'll resolve later
- m_classes.Add(wxClass(cname, child->GetAttribute("file", wxEmptyString)));
+ m_classes.Add(wxClass(cname, child->GetAttribute("file")));
+
+ const wxString& ids = child->GetAttribute("members");
+ if (ids.IsEmpty())
+ {
+ if (child->GetAttribute("incomplete") != "1") {
+ LogError("Invalid member IDs for '%s' class node (ID %s)",
+ cname, child->GetAttribute("id"));
+ return false;
+ }
+ //else: don't warn the user; it looks like "incomplete" classes
+ // never have any member...
+ }
+ else
+ {
+ // decode the non-empty list of IDs:
+ if (!getMemberIDs(&members, &m_classes.Last(), ids)) {
+ LogError("Invalid member IDs for '%s' class node (ID %s)",
+ cname, child->GetAttribute("id"));
+ return false;
+ }
+ }
}
// register this class also as possible return/argument type:
- //typeIds.Add(child->GetAttribute("id", wxEmptyString));
- //typeNames.Add(cname);
types[id] = cname;
}
else if (n == "PointerType" || n == "ReferenceType" ||
n == "CvQualifiedType" || n == "ArrayType")
{
- const wxString& type = child->GetAttribute("type", wxEmptyString);
- if (id.IsEmpty() || type.IsEmpty()) {
- LogError("Invalid empty type/id for '%s' node", n);
+ unsigned long type = 0;
+ if (!getID(&type, child->GetAttribute("type")) || type == 0) {
+ LogError("Invalid type for node %s: %s", n, child->GetAttribute("type"));
return false;
}
- int attr = 0;
+ unsigned long attr = 0;
if (n == "PointerType")
attr = ATTRIB_POINTER;
else if (n == "ReferenceType")
attr = ATTRIB_REFERENCE;
- else if (n == "CvQualifiedType" && child->GetAttribute("const", "") == "1")
+ else if (n == "CvQualifiedType" && child->GetAttribute("const") == "1")
attr = ATTRIB_CONST;
else if (n == "ArrayType")
attr = ATTRIB_ARRAY;
// these nodes make reference to other types... we'll resolve them later
- //toResolveTypeIds.Add(id);
- //toResolveRefType.Add(type);
- //toResolveAttrib.Add(attr);
toResolveTypes[id] = toResolveTypeItem(type, attr);
}
else if (n == "FunctionType" || n == "MethodType")
{
/* TODO: incomplete */
- const wxString& ret = child->GetAttribute("returns", wxEmptyString);
- if (id.IsEmpty() || ret.IsEmpty()) {
- LogError("Invalid empty ret/id for '%s' node", n);
+ unsigned long ret = 0;
+ if (!getID(&ret, child->GetAttribute("returns")) || ret == 0) {
+ LogError("Invalid empty returns value for '%s' node", n);
return false;
}
}
else if (n == "File")
{
- if (!id.StartsWith("f")) {
+ if (!child->GetAttribute("id").StartsWith("f")) {
LogError("Unexpected file ID: %s", id);
return false;
}
// just ignore this node... all file IDs/names were already parsed
- files[id] = child->GetAttribute("name", "");
+ files[id] = child->GetAttribute("name");
}
else
{
// we register everything else as a possible return/argument type:
- const wxString& name = child->GetAttribute("name", wxEmptyString);
- /*if (id.IsEmpty() || name.IsEmpty()) {
- LogError("Invalid empty name/id for '%s' node", n);
- return false;
- }*/
+ const wxString& name = child->GetAttribute("name");
if (!name.IsEmpty())
{
if (g_verbose)
LogWarning("Type '%s' with ID '%s' does not have name attribute", n, id);
- //typeIds.Add(id);
- //typeNames.Add("TOFIX");
types[id] = "TOFIX";
}
}
for (wxToResolveTypeHashMap::iterator i = toResolveTypes.begin();
i != toResolveTypes.end();)
{
- const wxString& id = i->first;
- const wxString& referenced = i->second.ref;
+ unsigned long id = i->first;
+ unsigned long referenced = i->second.ref;
- wxStringHashMap::iterator primary = types.find(referenced);
+ wxTypeIdHashMap::iterator primary = types.find(referenced);
if (primary != types.end())
{
// this to-resolve-type references a "primary" type
}
}
}
-/*
- // now get the return types of all wx methods parsed above
- child = doc.GetRoot()->GetChildren();
- int idx;
- while (child) {
-
- wxString n = child->GetName();
-
- if (n == "PointerType" || n == "ReferenceType" || n == "CvQualifiedType") {
- wxString id = child->GetAttribute("id", wxEmptyString);
- wxString type = child->GetAttribute("type", wxEmptyString);
-
- // are we interested to this id?
- while ((idx = retTypeIds.Index(id)) != wxNOT_FOUND)
- {
- // substitute this ID with the ID referenced by this node
- retTypeIds[idx] = type;
- // leave "incompleteMethods" array untouched
- }
- } else {
- wxString id = child->GetAttribute("id", wxEmptyString);
- wxString name = child->GetAttribute("name", wxEmptyString);
- if (!name.IsEmpty())
- {
- // are we interested to this id?
- while ((idx = retTypeIds.Index(id)) != wxNOT_FOUND)
- {
- wxMethod *p = (wxMethod*)incompleteMethods[idx];
- p->SetFromString(name + " " + p->GetAsString());
-
- //LogMessage("rettype node is named %s and is '%s'", n,
- // child->GetAttribute("name", ""));
-
- // prototype is now complete; remove it from the list of protos
- // waiting for completion
- retTypeIds.RemoveAt(idx);
- incompleteMethods.RemoveAt(idx);
- }
- }
- }
-
- child = child->GetNext();
-
- // give feedback to the user about the progress...
- if ((++nodes%PROGRESS_RATE)==0) ShowProgress();
- }*/
}
// resolve header names
for (unsigned int i=0; i<m_classes.GetCount(); i++)
{
- wxStringHashMap::const_iterator idx = files.find(m_classes[i].GetHeader());
+ unsigned long fileID = 0;
+ if (!getID(&fileID, m_classes[i].GetHeader()) || fileID == 0) {
+ LogError("invalid header id: %s", m_classes[i].GetHeader());
+ return false;
+ }
+
+ // search this file
+ wxTypeIdHashMap::const_iterator idx = files.find(fileID);
if (idx == files.end())
{
// this is an error!
{
wxString n = child->GetName();
- if (n == "Method" || n == "Constructor" || n == "Destructor" || n == "OperatorMethod")
+ // only register public methods
+ if (child->GetAttribute("access") == "public" &&
+ (n == "Method" || n == "Constructor" || n == "Destructor" || n == "OperatorMethod"))
{
- wxString id = child->GetAttribute("id", wxEmptyString);
+ unsigned long id = 0;
+ if (!getID(&id, child->GetAttribute("id"))) {
+ LogError("invalid ID for node '%s' with ID '%s'", n, child->GetAttribute("id"));
+ return false;
+ }
- // only register public methods
- if (child->GetAttribute("access", wxEmptyString) == "public")
+ wxClassMemberIdHashMap::const_iterator it = members.find(id);
+ if (it != members.end())
{
- wxASSERT(arrMemberIds.GetCount()==m_classes.GetCount());
+ wxClass *p = it->second;
- for (unsigned int i=0; i<m_classes.GetCount(); i++)
- {
- if (arrMemberIds[i].Contains(id))
- {
- // this <Method> node is a method of the i-th class!
- wxMethod newfunc;
- if (!ParseMethod(child, types, newfunc))
- return false;
-
- if (newfunc.IsCtor() && !m_classes[i].IsValidCtorForThisClass(newfunc)) {
- LogError("The method '%s' does not seem to be a ctor for '%s'",
- newfunc.GetName(), m_classes[i].GetName());
- return false;
- }
- if (newfunc.IsDtor() && !m_classes[i].IsValidDtorForThisClass(newfunc)) {
- LogError("The method '%s' does not seem to be a dtor for '%s'",
- newfunc.GetName(), m_classes[i].GetName());
- return false;
- }
+ // this <Method> node is a method of the i-th class!
+ wxMethod newfunc;
+ if (!ParseMethod(child, types, newfunc))
+ return false;
- m_classes[i].AddMethod(newfunc);
- }
+ if (newfunc.IsCtor() && !p->IsValidCtorForThisClass(newfunc)) {
+ LogError("The method '%s' does not seem to be a ctor for '%s'",
+ newfunc.GetName(), p->GetName());
+ return false;
}
+ if (newfunc.IsDtor() && !p->IsValidDtorForThisClass(newfunc)) {
+ LogError("The method '%s' does not seem to be a dtor for '%s'",
+ newfunc.GetName(), p->GetName());
+ return false;
+ }
+
+ p->AddMethod(newfunc);
}
}
}
bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p,
- const wxStringHashMap& types,
+ const wxTypeIdHashMap& types,
wxMethod& m)
{
// get the real name
- wxString name = p->GetAttribute("name", wxEmptyString).Strip(wxString::both);
+ wxString name = p->GetAttribute("name").Strip(wxString::both);
if (p->GetName() == "Destructor")
name = "~" + name;
else if (p->GetName() == "OperatorMethod")
// resolve return type
wxType ret;
- wxString retid = p->GetAttribute("returns", wxEmptyString);
- if (retid.IsEmpty())
+ unsigned long retid = 0;
+ if (!getID(&retid, p->GetAttribute("returns")) || retid == 0)
{
if (p->GetName() != "Destructor" && p->GetName() != "Constructor") {
LogError("Empty return ID for method '%s', with ID '%s'",
- name, p->GetAttribute("id", ""));
+ name, p->GetAttribute("id"));
return false;
}
}
else
{
- wxStringHashMap::const_iterator retidx = types.find(retid);
+ wxTypeIdHashMap::const_iterator retidx = types.find(retid);
if (retidx == types.end()) {
LogError("Could not find return type ID '%s'", retid);
return false;
ret = wxType(retidx->second);
if (!ret.IsOk()) {
LogError("Invalid return type '%s' for method '%s', with ID '%s'",
- retidx->second, name, p->GetAttribute("id", ""));
+ retidx->second, name, p->GetAttribute("id"));
return false;
}
}
{
if (arg->GetName() == "Argument")
{
- wxString id = arg->GetAttribute("type", wxEmptyString);
- wxStringHashMap::const_iterator idx = types.find(id);
+ unsigned long id = 0;
+ if (!getID(&id, arg->GetAttribute("type")) || id == 0) {
+ LogError("Invalid argument type ID '%s' for method '%s' with ID %s",
+ arg->GetAttribute("type"), name, p->GetAttribute("id"));
+ return false;
+ }
+
+ wxTypeIdHashMap::const_iterator idx = types.find(id);
if (idx == types.end()) {
LogError("Could not find argument type ID '%s'", id);
return false;
argtypes.Add(wxType(idx->second));
- wxString def = arg->GetAttribute("default", "");
+ wxString def = arg->GetAttribute("default");
if (def.Contains("wxGetTranslation"))
argdefs.Add(wxEmptyString); // TODO: wxGetTranslation gives problems to gccxml
else
m.SetReturnType(ret);
m.SetName(name);
m.SetArgumentTypes(argtypes, argdefs);
- 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");
if (!m.IsOk()) {
LogError("The prototype '%s' is not valid!", m.GetAsString());
while (compound)
{
if (compound->GetName() == "compound" &&
- compound->GetAttribute("kind", "") == "class")
+ compound->GetAttribute("kind") == "class")
{
- wxString refid = compound->GetAttribute("refid", "");
+ wxString refid = compound->GetAttribute("refid");
wxFileName fn(filename);
if (!ParseCompoundDefinition(fn.GetPath(wxPATH_GET_SEPARATOR) + refid + ".xml"))
while (child)
{
if (child->GetName() == "compounddef" &&
- child->GetAttribute("kind", wxEmptyString) == "class")
+ child->GetAttribute("kind") == "class")
{
// parse this class
wxClass klass;
while (subchild)
{
if (subchild->GetName() == "sectiondef" &&
- subchild->GetAttribute("kind", wxEmptyString) == "public-func")
+ subchild->GetAttribute("kind") == "public-func")
{
wxXmlNode *membernode = subchild->GetChildren();
while (membernode)
{
if (membernode->GetName() == "memberdef" &&
- membernode->GetAttribute("kind", wxEmptyString) == "function")
+ membernode->GetAttribute("kind") == "function")
{
wxMethod m;
}
else if (child->GetName() == "location")
{
- if (child->GetAttribute("line", "").ToLong(&line))
+ if (child->GetAttribute("line").ToLong(&line))
m.SetLocation((int)line);
- header = child->GetAttribute("file", "");
+ header = child->GetAttribute("file");
}
child = child->GetNext();
}
m.SetArgumentTypes(args, defs);
- 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");
if (!m.IsOk()) {
LogError("The prototype '%s' is not valid!", m.GetAsString());
projects / wxWidgets.git / blobdiff