utils/ifacecheck/src/xmlparser.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        xmlparser.cpp
   3 // Purpose:     Parser of the API/interface XML files
   4 // Author:      Francesco Montorsi
   5 // Created:     2008/03/17
   6 // RCS-ID:      $Id$
   7 // Copyright:   (c) 2008 Francesco Montorsi
   8 // Licence:     wxWindows licence
   9 /////////////////////////////////////////////////////////////////////////////
  10
  11 // For compilers that support precompilation, includes "wx/wx.h".
  12 #include "wx/wxprec.h"
  13
  14 #ifdef __BORLANDC__
  15     #pragma hdrstop
  16 #endif
  17
  18 // for all others, include the necessary headers
  19 #ifndef WX_PRECOMP
  20 #endif
  21
  22 #include "wx/xml/xml.h"
  23 #include "wx/wfstream.h"
  24 #include "wx/arrimpl.cpp"
  25 #include "wx/dynarray.h"
  26 #include "wx/filename.h"
  27
  28 #include <errno.h>
  29
  30 #include "xmlparser.h"
  31
  32 #define PROGRESS_RATE             1000     // each PROGRESS_RATE nodes processed print a dot
  33 #define ESTIMATED_NUM_CLASSES     600      // used by both wxXmlInterface-derived classes to prealloc mem
  34 #define ESTIMATED_NUM_TYPES       50000    // used only by wxGccXmlInterface to prealloc mem
  35 #define ESTIMATED_NUM_FILES       800      // used only by wxGccXmlInterface to prealloc mem
  36
  37 WX_DEFINE_OBJARRAY(wxTypeArray)
  38 WX_DEFINE_OBJARRAY(wxMethodArray)
  39 WX_DEFINE_OBJARRAY(wxClassArray)
  40
  41
  42 // declared in ifacecheck.cpp
  43 extern bool g_verbose;
  44
  45
  46
  47 // ----------------------------------------------------------------------------
  48 // wxType
  49 // ----------------------------------------------------------------------------
  50
  51 wxType wxEmptyType;
  52
  53 void wxType::SetFromString(const wxString& t)
  54 {
  55     m_strType = t.Strip(wxString::both);
  56
  57     // [] is the same as * for gccxml
  58     m_strType.Replace("[]", "*");
  59 }
  60
  61 bool wxType::IsOk() const
  62 {
  63     // NB: m_strType can contain the :: operator; think to e.g. the
  64     //     "reverse_iterator_impl<wxString::const_iterator>" type
  65     //     It can also contain commas, * and & operators etc
  66
  67     return !GetClean().IsEmpty();
  68 }
  69
  70 wxString wxType::GetClean() const
  71 {
  72     wxString ret(m_strType);
  73     ret.Replace("const", "");
  74     ret.Replace("static", "");
  75     ret.Replace("*", "");
  76     ret.Replace("&", "");
  77     ret.Replace("[]", "");
  78     return ret.Strip(wxString::both);
  79 }
  80
  81 bool wxType::operator==(const wxType& m) const
  82 {
  83     // brain-dead comparison:
  84
  85     if (GetClean() == m.GetClean() &&
  86         IsConst() == m.IsConst() &&
  87         IsStatic() == m.IsStatic() &&
  88         IsPointer() == m.IsPointer() &&
  89         IsReference() == m.IsReference())
  90         return true;
  91
  92     return false;
  93 }
  94
  95 // ----------------------------------------------------------------------------
  96 // wxMethod
  97 // ----------------------------------------------------------------------------
  98
  99 bool wxMethod::IsOk() const
 100 {
 101     // NOTE: m_retType can be a wxEmptyType, and means that this method
 102     //       is a ctor or a dtor.
 103     if (!m_retType.IsOk() && m_retType!=wxEmptyType) {
 104         LogError("'%s' method has invalid return type: %s", m_retType.GetAsString());
 105         return false;
 106     }
 107
 108     if (m_strName.IsEmpty())
 109         return false;
 110
 111     // a function can't be both const and static or virtual and static!
 112     if ((m_bConst && m_bStatic) || (m_bVirtual && m_bStatic)) {
 113         LogError("'%s' method can't be both const/static or virtual/static", m_strName);
 114         return false;
 115     }
 116
 117     for (unsigned int i=0; i<m_args.GetCount(); i++)
 118         if (!m_args[i].IsOk()) {
 119             LogError("'%s' method has invalid %d-th argument type: %s",
 120                      m_strName, i, m_args[i].GetAsString());
 121             return false;
 122         }
 123
 124     // NB: the default value of the arguments can contain pretty much everything
 125     //     (think to e.g. wxPoint(3+4/2,0)   or   *wxBLACK   or  someClass<type>)
 126     //     so we don't do any test on them.
 127
 128     return true;
 129 }
 130
 131 void wxMethod::SetArgumentTypes(const wxTypeArray& arr, const wxArrayString& defaults)
 132 {
 133     wxASSERT(arr.GetCount()==defaults.GetCount());
 134
 135     m_args=arr;
 136     m_argDefaults=defaults;
 137
 138     // in order to make valid&simple comparison on argument defaults,
 139     // we reduce some of the multiple forms in which the same things may appear
 140     // to a single form
 141     for (unsigned int i=0; i<m_argDefaults.GetCount(); i++)
 142     {
 143         m_argDefaults[i].Replace("NULL", "0");
 144         m_argDefaults[i].Replace("0u", "0");
 145     }
 146 }
 147
 148 bool wxMethod::operator==(const wxMethod& m) const
 149 {
 150     if (GetReturnType() != m.GetReturnType() ||
 151         GetName() != m.GetName() ||
 152         IsConst() != m.IsConst() ||
 153         IsStatic() != m.IsStatic() ||
 154         IsVirtual() != m.IsVirtual())
 155         return false;
 156
 157     if (m_args.GetCount()!=m.m_args.GetCount())
 158         return false;
 159
 160     for (unsigned int i=0; i<m_args.GetCount(); i++)
 161         if (m_args[i] != m.m_args[i] || m_argDefaults[i] != m.m_argDefaults[i])
 162             return false;
 163
 164     return true;
 165 }
 166
 167 wxString wxMethod::GetAsString() const
 168 {
 169     wxString ret;
 170
 171     if (m_retType!=wxEmptyType)
 172         ret += m_retType.GetAsString() + " ";
 173     //else; this is a ctor or dtor
 174
 175     ret += m_strName + "(";
 176
 177     for (unsigned int i=0; i<m_args.GetCount(); i++)
 178     {
 179         ret += m_args[i].GetAsString();
 180         if (!m_argDefaults[i].IsEmpty())
 181             ret += " = " + m_argDefaults[i];
 182         ret += ",";
 183     }
 184
 185     if (m_args.GetCount()>0)
 186         ret.RemoveLast();
 187
 188     ret += ")";
 189
 190     if (m_bConst)
 191         ret += " const";
 192     if (m_bStatic)
 193         ret = "static " + ret;
 194     if (m_bVirtual)
 195         ret = "virtual " + ret;
 196
 197     return ret;
 198 }
 199
 200 void wxMethod::Dump(wxTextOutputStream& stream) const
 201 {
 202     stream << "[" + m_retType.GetAsString() + "]";
 203     stream << "[" + m_strName + "]";
 204
 205     for (unsigned int i=0; i<m_args.GetCount(); i++)
 206         stream << "[" + m_args[i].GetAsString() + "=" + m_argDefaults[i] + "]";
 207
 208     if (IsConst())
 209         stream << " CONST";
 210     if (IsStatic())
 211         stream << " STATIC";
 212     if (IsVirtual())
 213         stream << " VIRTUAL";
 214
 215     // no final newline
 216 }
 217
 218 // ----------------------------------------------------------------------------
 219 // wxClass
 220 // ----------------------------------------------------------------------------
 221
 222 wxString wxClass::GetNameWithoutTemplate() const
 223 {
 224     // NB: I'm not sure this is the right terminology for this function!
 225
 226     if (m_strName.Contains("<"))
 227         return m_strName.Left(m_strName.Find("<"));
 228     return m_strName;
 229 }
 230
 231 bool wxClass::IsValidCtorForThisClass(const wxMethod& m) const
 232 {
 233     // remember that e.g. the ctor for wxWritableCharTypeBuffer<wchar_t> is
 234     // named wxWritableCharTypeBuffer, without the <...> part!
 235
 236     if (m.IsCtor() && m.GetName() == GetNameWithoutTemplate())
 237         return true;
 238
 239     return false;
 240 }
 241
 242 bool wxClass::IsValidDtorForThisClass(const wxMethod& m) const
 243 {
 244     if (m.IsDtor() && m.GetName() == "~" + GetNameWithoutTemplate())
 245         return true;
 246
 247     return false;
 248 }
 249
 250 void wxClass::Dump(wxTextOutputStream& out) const
 251 {
 252     out << m_strName + "\n";
 253
 254     for (unsigned int i=0; i<m_methods.GetCount(); i++) {
 255
 256         // dump all our methods
 257         out << "|- ";
 258         m_methods[i].Dump(out);
 259         out << "\n";
 260     }
 261
 262     out << "\n";
 263 }
 264
 265 bool wxClass::CheckConsistency() const
 266 {
 267     for (unsigned int i=0; i<m_methods.GetCount(); i++)
 268         for (unsigned int j=0; j<m_methods.GetCount(); j++)
 269             if (i!=j && m_methods[i] == m_methods[j])
 270             {
 271                 LogError("class %s has two methods with the same prototype: '%s'",
 272                          m_strName, m_methods[i].GetAsString());
 273                 return false;
 274             }
 275
 276     return true;
 277 }
 278
 279 const wxMethod* wxClass::FindMethod(const wxMethod& m) const
 280 {
 281     for (unsigned int i=0; i<m_methods.GetCount(); i++)
 282         if (m_methods[i] == m)
 283             return &m_methods[i];
 284     return NULL;
 285 }
 286
 287 wxMethodPtrArray wxClass::FindMethodNamed(const wxString& name) const
 288 {
 289     wxMethodPtrArray ret;
 290
 291     for (unsigned int i=0; i<m_methods.GetCount(); i++)
 292         if (m_methods[i].GetName() == name)
 293             ret.Add(&m_methods[i]);
 294
 295     return ret;
 296 }
 297
 298
 299 // ----------------------------------------------------------------------------
 300 // wxXmlInterface
 301 // ----------------------------------------------------------------------------
 302
 303 WX_DEFINE_SORTED_ARRAY(wxClass*, wxSortedClassArray);
 304
 305 int CompareWxClassObjects(wxClass *item1, wxClass *item2)
 306 {
 307     // sort alphabetically
 308     return item1->GetName().Cmp(item2->GetName());
 309 }
 310
 311 void wxXmlInterface::Dump(const wxString& filename)
 312 {
 313     wxFFileOutputStream apioutput( filename );
 314     wxTextOutputStream apiout( apioutput );
 315
 316     // dump the classes in alphabetical order
 317     wxSortedClassArray sorted(CompareWxClassObjects);
 318     sorted.Alloc(m_classes.GetCount());
 319     for (unsigned int i=0; i<m_classes.GetCount(); i++)
 320         sorted.Add(&m_classes[i]);
 321
 322     // now they have been sorted
 323     for (unsigned int i=0; i<sorted.GetCount(); i++)
 324         sorted[i]->Dump(apiout);
 325 }
 326
 327 bool wxXmlInterface::CheckParseResults() const
 328 {
 329     // this check can be quite slow, so do it only for debug releases:
 330 #ifdef __WXDEBUG__
 331     for (unsigned int i=0; i<m_classes.GetCount(); i++)
 332         if (!m_classes[i].CheckConsistency())
 333             return false;
 334 #endif
 335
 336     return true;
 337 }
 338
 339 // ----------------------------------------------------------------------------
 340 // wxXmlGccInterface helper declarations
 341 // ----------------------------------------------------------------------------
 342
 343 #define ATTRIB_CONST        1
 344 #define ATTRIB_REFERENCE    2
 345 #define ATTRIB_POINTER      4
 346 #define ATTRIB_ARRAY        8
 347
 348 #define GCCXML_BASE         35
 349
 350 class toResolveTypeItem
 351 {
 352 public:
 353     toResolveTypeItem() { attribs=0; }
 354     toResolveTypeItem(unsigned int refID, unsigned int attribint)
 355         : ref(refID), attribs(attribint) {}
 356
 357     unsigned long ref, attribs;
 358 };
 359
 360 #if 1
 361
 362 // for wxToResolveTypeHashMap, keys == gccXML IDs  and  values == toResolveTypeItem
 363 WX_DECLARE_HASH_MAP( unsigned long, toResolveTypeItem,
 364                      wxIntegerHash, wxIntegerEqual,
 365                      wxToResolveTypeHashMap );
 366
 367 // for wxClassMemberIdHashMap, keys == gccXML IDs  and  values == wxClass which owns that member ID
 368 WX_DECLARE_HASH_MAP( unsigned long, wxClass*,
 369                      wxIntegerHash, wxIntegerEqual,
 370                      wxClassMemberIdHashMap );
 371 #else
 372 #include <map>
 373 typedef std::map<unsigned long, toResolveTypeItem> wxToResolveTypeHashMap;
 374 #endif
 375
 376
 377 // utility to parse gccXML ID values;
 378 // this function is equivalent to wxString(str).Mid(1).ToULong(&id, GCCXML_BASE)
 379 // but is a little bit faster
 380 bool getID(unsigned long *id, const wxStringCharType* str)
 381 {
 382     wxStringCharType *end;
 383 #if wxUSE_UNICODE_UTF8
 384     unsigned long val = strtoul(str+1, &end, GCCXML_BASE);
 385 #else
 386     unsigned long val = wcstoul(str+1, &end, GCCXML_BASE);
 387 #endif
 388
 389     // return true only if scan was stopped by the terminating NUL and
 390     // if the string was not empty to start with and no under/overflow
 391     // occurred:
 392     if ( *end != '\0' || end == str+1 || errno == ERANGE || errno == EINVAL )
 393         return false;
 394
 395     *id = val;
 396     return true;
 397 }
 398
 399 // utility specialized to parse efficiently the gccXML list of IDs which occur
 400 // in nodes like <Class> ones... i.e. numeric values separed by " _" token
 401 bool getMemberIDs(wxClassMemberIdHashMap* map, wxClass* p, const wxStringCharType* str)
 402 {
 403 #if wxUSE_UNICODE_UTF8
 404     size_t len = strlen(str);
 405 #else
 406     size_t len = wcslen(str);
 407 #endif
 408
 409     if (len == 0 || str[0] != '_')
 410         return false;
 411
 412     const wxStringCharType *curpos = str,
 413                            *end = str + len;
 414     wxStringCharType *nexttoken;
 415
 416     while (curpos < end)
 417     {
 418         // curpos always points to the underscore of the next token to parse:
 419 #if wxUSE_UNICODE_UTF8
 420         unsigned long id = strtoul(curpos+1, &nexttoken, GCCXML_BASE);
 421 #else
 422         unsigned long id = wcstoul(curpos+1, &nexttoken, GCCXML_BASE);
 423 #endif
 424         if ( *nexttoken != ' ' || errno == ERANGE || errno == EINVAL )
 425             return false;
 426
 427         // advance current position
 428         curpos = nexttoken + 1;
 429
 430         // add this ID to the hashmap
 431         wxClassMemberIdHashMap::value_type v(id, p);
 432         map->insert(v);
 433     }
 434
 435     return true;
 436 }
 437
 438
 439 // ----------------------------------------------------------------------------
 440 // wxXmlGccInterface
 441 // ----------------------------------------------------------------------------
 442
 443 bool wxXmlGccInterface::Parse(const wxString& filename)
 444 {
 445     wxXmlDocument doc;
 446     wxXmlNode *child;
 447     int nodes = 0;
 448
 449     LogMessage("Parsing %s...", filename);
 450
 451     if (!doc.Load(filename)) {
 452         LogError("can't load %s", filename);
 453         return false;
 454     }
 455
 456     // start processing the XML file
 457     if (doc.GetRoot()->GetName() != "GCC_XML") {
 458         LogError("invalid root node for %s", filename);
 459         return false;
 460     }
 461
 462     wxToResolveTypeHashMap toResolveTypes;
 463     //wxArrayString arrMemberIds;
 464     wxClassMemberIdHashMap members;
 465     wxTypeIdHashMap types;
 466     wxTypeIdHashMap files;
 467
 468     // prealloc quite a lot of memory!
 469     m_classes.Alloc(ESTIMATED_NUM_CLASSES);
 470     //arrMemberIds.Alloc(ESTIMATED_NUM_TYPES);
 471
 472     // build a list of wx classes and in general of all existent types
 473     child = doc.GetRoot()->GetChildren();
 474     while (child)
 475     {
 476         const wxString& n = child->GetName();
 477
 478         unsigned long id = 0;
 479         if (!getID(&id, child->GetAttribute("id")) || (id == 0 && n != "File")) {
 480
 481             // NOTE: <File> nodes can have an id == "f0"...
 482
 483             LogError("Invalid id for node %s: %s", n, child->GetAttribute("id"));
 484             return false;
 485         }
 486
 487         if (n == "Class")
 488         {
 489             wxString cname = child->GetAttribute("name");
 490             if (cname.IsEmpty()) {
 491                 LogError("Invalid empty name for '%s' node", n);
 492                 return false;
 493             }
 494
 495             // only register wx classes (do remember also the IDs of their members)
 496             if (cname.StartsWith("wx"))
 497             {
 498                 // NB: "file" attribute contains an ID value that we'll resolve later
 499                 m_classes.Add(wxClass(cname, child->GetAttribute("file")));
 500
 501                 const wxString& ids = child->GetAttribute("members");
 502                 if (ids.IsEmpty())
 503                 {
 504                     if (child->GetAttribute("incomplete") != "1") {
 505                         LogError("Invalid member IDs for '%s' class node (ID %s)",
 506                                 cname, child->GetAttribute("id"));
 507                         return false;
 508                     }
 509                     //else: don't warn the user; it looks like "incomplete" classes
 510                     //      never have any member...
 511                 }
 512                 else
 513                 {
 514                     // decode the non-empty list of IDs:
 515                     if (!getMemberIDs(&members, &m_classes.Last(), ids)) {
 516                         LogError("Invalid member IDs for '%s' class node (ID %s)",
 517                                 cname, child->GetAttribute("id"));
 518                         return false;
 519                     }
 520                 }
 521             }
 522
 523             // register this class also as possible return/argument type:
 524             types[id] = cname;
 525         }
 526         else if (n == "PointerType" || n == "ReferenceType" ||
 527                  n == "CvQualifiedType" || n == "ArrayType")
 528         {
 529             unsigned long type = 0;
 530             if (!getID(&type, child->GetAttribute("type")) || type == 0) {
 531                 LogError("Invalid type for node %s: %s", n, child->GetAttribute("type"));
 532                 return false;
 533             }
 534
 535             unsigned long attr = 0;
 536             if (n == "PointerType")
 537                 attr = ATTRIB_POINTER;
 538             else if (n == "ReferenceType")
 539                 attr = ATTRIB_REFERENCE;
 540             else if (n == "CvQualifiedType" && child->GetAttribute("const") == "1")
 541                 attr = ATTRIB_CONST;
 542             else if (n == "ArrayType")
 543                 attr = ATTRIB_ARRAY;
 544
 545             // these nodes make reference to other types... we'll resolve them later
 546             toResolveTypes[id] = toResolveTypeItem(type, attr);
 547         }
 548         else if (n == "FunctionType" || n == "MethodType")
 549         {
 550             /* TODO: incomplete */
 551
 552             unsigned long ret = 0;
 553             if (!getID(&ret, child->GetAttribute("returns")) || ret == 0) {
 554                 LogError("Invalid empty returns value for '%s' node", n);
 555                 return false;
 556             }
 557
 558             // these nodes make reference to other types... we'll resolve them later
 559             toResolveTypes[id] = toResolveTypeItem(ret, 0);
 560         }
 561         else if (n == "File")
 562         {
 563             if (!child->GetAttribute("id").StartsWith("f")) {
 564                 LogError("Unexpected file ID: %s", id);
 565                 return false;
 566             }
 567
 568             // just ignore this node... all file IDs/names were already parsed
 569             files[id] = child->GetAttribute("name");
 570         }
 571         else
 572         {
 573             // we register everything else as a possible return/argument type:
 574             const wxString& name = child->GetAttribute("name");
 575
 576             if (!name.IsEmpty())
 577             {
 578                 //typeIds.Add(id);
 579                 //typeNames.Add(name);
 580                 types[id] = name;
 581             }
 582             else
 583             {
 584                 // this may happen with unnamed structs/union, special ctors,
 585                 // or other exotic things which we are not interested to, since
 586                 // they're never used as return/argument types by wxWidgets methods
 587
 588                 if (g_verbose)
 589                     LogWarning("Type '%s' with ID '%s' does not have name attribute", n, id);
 590
 591                 types[id] = "TOFIX";
 592             }
 593         }
 594
 595         child = child->GetNext();
 596
 597         // give feedback to the user about the progress...
 598         if ((++nodes%PROGRESS_RATE)==0) ShowProgress();
 599     }
 600
 601     // some nodes with IDs referenced by methods as return/argument types, do reference
 602     // in turn o ther nodes (see PointerType, ReferenceType and CvQualifierType above);
 603     // thus we need to resolve their name iteratively:
 604     while (toResolveTypes.size()>0)
 605     {
 606         if (g_verbose)
 607             LogMessage("%d types were collected; %d types need yet to be resolved...",
 608                        types.size(), toResolveTypes.size());
 609
 610         for (wxToResolveTypeHashMap::iterator i = toResolveTypes.begin();
 611              i != toResolveTypes.end();)
 612         {
 613             unsigned long id = i->first;
 614             unsigned long referenced = i->second.ref;
 615
 616             wxTypeIdHashMap::iterator primary = types.find(referenced);
 617             if (primary != types.end())
 618             {
 619                 // this to-resolve-type references a "primary" type
 620
 621                 wxString newtype;
 622                 int attribs = i->second.attribs;
 623
 624                 if (attribs & ATTRIB_CONST)
 625                     newtype = "const " + primary->second;
 626                 if (attribs & ATTRIB_REFERENCE)
 627                     newtype = primary->second + "&";
 628                 if (attribs & ATTRIB_POINTER)
 629                     newtype = primary->second + "*";
 630                 if (attribs & ATTRIB_ARRAY)
 631                     newtype = primary->second + "[]";
 632
 633                 // add the resolved type to the list of "primary" types
 634                 types[id] = newtype;
 635
 636                 // this one has been resolved; erase it through its iterator!
 637                 toResolveTypes.erase(i);
 638
 639                 // now iterator i is invalid; assign it again to the beginning
 640                 i = toResolveTypes.begin();
 641             }
 642             else
 643             {
 644                 // then search in the referenced types themselves:
 645                 wxToResolveTypeHashMap::iterator idx2 = toResolveTypes.find(referenced);
 646                 if (idx2 != toResolveTypes.end())
 647                 {
 648                     // merge this to-resolve-type with the idx2->second type
 649                     i->second.ref = idx2->second.ref;
 650                     i->second.attribs |= idx2->second.attribs;
 651
 652                     // this type will eventually be solved in the next while() iteration
 653                     i++;
 654                 }
 655                 else
 656                 {
 657 #if 1
 658                     LogError("Cannot solve '%s' reference type!", referenced);
 659                     return false;
 660 #else
 661                     typeIds.Add(toResolveTypeIds[i]);
 662                     typeNames.Add("TOFIX");
 663
 664                     // this one has been resolved!
 665                     toResolveTypeIds.RemoveAt(i);
 666                     toResolveRefType.RemoveAt(i);
 667                     toResolveAttrib.RemoveAt(i);
 668                     n--;
 669 #endif
 670                 }
 671             }
 672         }
 673     }
 674
 675     // resolve header names
 676     for (unsigned int i=0; i<m_classes.GetCount(); i++)
 677     {
 678         unsigned long fileID = 0;
 679         if (!getID(&fileID, m_classes[i].GetHeader()) || fileID == 0) {
 680             LogError("invalid header id: %s", m_classes[i].GetHeader());
 681             return false;
 682         }
 683
 684         // search this file
 685         wxTypeIdHashMap::const_iterator idx = files.find(fileID);
 686         if (idx == files.end())
 687         {
 688             // this is an error!
 689             LogError("couldn't find file ID '%s'", m_classes[i].GetHeader());
 690         }
 691         else
 692             m_classes[i].SetHeader(idx->second);
 693     }
 694
 695     // build the list of the wx methods
 696     child = doc.GetRoot()->GetChildren();
 697     while (child)
 698     {
 699         wxString n = child->GetName();
 700
 701         // only register public methods
 702         if (child->GetAttribute("access") == "public" &&
 703             (n == "Method" || n == "Constructor" || n == "Destructor" || n == "OperatorMethod"))
 704         {
 705             unsigned long id = 0;
 706             if (!getID(&id, child->GetAttribute("id"))) {
 707                 LogError("invalid ID for node '%s' with ID '%s'", n, child->GetAttribute("id"));
 708                 return false;
 709             }
 710
 711             wxClassMemberIdHashMap::const_iterator it = members.find(id);
 712             if (it != members.end())
 713             {
 714                 wxClass *p = it->second;
 715
 716                 // this <Method> node is a method of the i-th class!
 717                 wxMethod newfunc;
 718                 if (!ParseMethod(child, types, newfunc))
 719                     return false;
 720
 721                 if (newfunc.IsCtor() && !p->IsValidCtorForThisClass(newfunc)) {
 722                     LogError("The method '%s' does not seem to be a ctor for '%s'",
 723                                 newfunc.GetName(), p->GetName());
 724                     return false;
 725                 }
 726                 if (newfunc.IsDtor() && !p->IsValidDtorForThisClass(newfunc)) {
 727                     LogError("The method '%s' does not seem to be a dtor for '%s'",
 728                                 newfunc.GetName(), p->GetName());
 729                     return false;
 730                 }
 731
 732                 p->AddMethod(newfunc);
 733             }
 734         }
 735
 736         child = child->GetNext();
 737
 738         // give feedback to the user about the progress...
 739         if ((++nodes%PROGRESS_RATE)==0) ShowProgress();
 740     }
 741
 742     //wxPrint("\n");
 743     if (!CheckParseResults())
 744         return false;
 745
 746     return true;
 747 }
 748
 749 bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p,
 750                                     const wxTypeIdHashMap& types,
 751                                     wxMethod& m)
 752 {
 753     // get the real name
 754     wxString name = p->GetAttribute("name").Strip(wxString::both);
 755     if (p->GetName() == "Destructor")
 756         name = "~" + name;
 757     else if (p->GetName() == "OperatorMethod")
 758         name = "operator" + name;
 759
 760     // resolve return type
 761     wxType ret;
 762     unsigned long retid = 0;
 763     if (!getID(&retid, p->GetAttribute("returns")) || retid == 0)
 764     {
 765         if (p->GetName() != "Destructor" && p->GetName() != "Constructor") {
 766             LogError("Empty return ID for method '%s', with ID '%s'",
 767                      name, p->GetAttribute("id"));
 768             return false;
 769         }
 770     }
 771     else
 772     {
 773         wxTypeIdHashMap::const_iterator retidx = types.find(retid);
 774         if (retidx == types.end()) {
 775             LogError("Could not find return type ID '%s'", retid);
 776             return false;
 777         }
 778
 779         ret = wxType(retidx->second);
 780         if (!ret.IsOk()) {
 781             LogError("Invalid return type '%s' for method '%s', with ID '%s'",
 782                      retidx->second, name, p->GetAttribute("id"));
 783             return false;
 784         }
 785     }
 786
 787     // resolve argument types
 788     wxTypeArray argtypes;
 789     wxArrayString argdefs;
 790     wxXmlNode *arg = p->GetChildren();
 791     while (arg)
 792     {
 793         if (arg->GetName() == "Argument")
 794         {
 795             unsigned long id = 0;
 796             if (!getID(&id, arg->GetAttribute("type")) || id == 0) {
 797                 LogError("Invalid argument type ID '%s' for method '%s' with ID %s",
 798                          arg->GetAttribute("type"), name, p->GetAttribute("id"));
 799                 return false;
 800             }
 801
 802             wxTypeIdHashMap::const_iterator idx = types.find(id);
 803             if (idx == types.end()) {
 804                 LogError("Could not find argument type ID '%s'", id);
 805                 return false;
 806             }
 807
 808             argtypes.Add(wxType(idx->second));
 809
 810             wxString def = arg->GetAttribute("default");
 811             if (def.Contains("wxGetTranslation"))
 812                 argdefs.Add(wxEmptyString);     // TODO: wxGetTranslation gives problems to gccxml
 813             else
 814                 argdefs.Add(def);
 815         }
 816
 817         arg = arg->GetNext();
 818     }
 819
 820     m.SetReturnType(ret);
 821     m.SetName(name);
 822     m.SetArgumentTypes(argtypes, argdefs);
 823     m.SetConst(p->GetAttribute("const") == "1");
 824     m.SetStatic(p->GetAttribute("static") == "1");
 825     m.SetVirtual(p->GetAttribute("virtual") == "1");
 826
 827     if (!m.IsOk()) {
 828         LogError("The prototype '%s' is not valid!", m.GetAsString());
 829         return false;
 830     }
 831
 832     return true;
 833 }
 834
 835
 836 // ----------------------------------------------------------------------------
 837 // wxXmlDoxygenInterface
 838 // ----------------------------------------------------------------------------
 839
 840 bool wxXmlDoxygenInterface::Parse(const wxString& filename)
 841 {
 842     wxXmlDocument index;
 843     wxXmlNode *compound;
 844
 845     LogMessage("Parsing %s...", filename);
 846
 847     if (!index.Load(filename)) {
 848         LogError("can't load %s", filename);
 849         return false;
 850     }
 851
 852     // start processing the index:
 853     if (index.GetRoot()->GetName() != "doxygenindex") {
 854         LogError("invalid root node for %s", filename);
 855         return false;
 856     }
 857
 858     m_classes.Alloc(ESTIMATED_NUM_CLASSES);
 859
 860     // process files referenced by this index file
 861     compound = index.GetRoot()->GetChildren();
 862     while (compound)
 863     {
 864         if (compound->GetName() == "compound" &&
 865             compound->GetAttribute("kind") == "class")
 866         {
 867             wxString refid = compound->GetAttribute("refid");
 868
 869             wxFileName fn(filename);
 870             if (!ParseCompoundDefinition(fn.GetPath(wxPATH_GET_SEPARATOR) + refid + ".xml"))
 871                 return false;
 872         }
 873
 874         compound = compound->GetNext();
 875     }
 876     //wxPrint("\n");
 877
 878     if (!CheckParseResults())
 879         return false;
 880
 881     return true;
 882 }
 883
 884 bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename)
 885 {
 886     wxXmlDocument doc;
 887     wxXmlNode *child;
 888     int nodes = 0;
 889
 890     if (g_verbose)
 891         LogMessage("Parsing %s...", filename);
 892
 893     if (!doc.Load(filename)) {
 894         LogError("can't load %s", filename);
 895         return false;
 896     }
 897
 898     // start processing this compound definition XML
 899     if (doc.GetRoot()->GetName() != "doxygen") {
 900         LogError("invalid root node for %s", filename);
 901         return false;
 902     }
 903
 904     // build a list of wx classes
 905     child = doc.GetRoot()->GetChildren();
 906     while (child)
 907     {
 908         if (child->GetName() == "compounddef" &&
 909             child->GetAttribute("kind") == "class")
 910         {
 911             // parse this class
 912             wxClass klass;
 913             wxString absoluteFile, header;
 914
 915             wxXmlNode *subchild = child->GetChildren();
 916             while (subchild)
 917             {
 918                 if (subchild->GetName() == "sectiondef" &&
 919                     subchild->GetAttribute("kind") == "public-func")
 920                 {
 921
 922                     wxXmlNode *membernode = subchild->GetChildren();
 923                     while (membernode)
 924                     {
 925                         if (membernode->GetName() == "memberdef" &&
 926                             membernode->GetAttribute("kind") == "function")
 927                         {
 928
 929                             wxMethod m;
 930                             if (ParseMethod(membernode, m, header))
 931                             {
 932                                 if (absoluteFile.IsEmpty())
 933                                     absoluteFile = header;
 934                                 else if (header != absoluteFile)
 935                                 {
 936                                     LogError("The method '%s' is documented in a different "
 937                                              "file from others (which belong to '%s') ?",
 938                                              header, absoluteFile);
 939                                     return false;
 940                                 }
 941
 942                                 klass.AddMethod(m);
 943                             }
 944                         }
 945
 946                         membernode = membernode->GetNext();
 947                     }
 948
 949                     // all methods of this class were taken from the header "absoluteFile":
 950                     klass.SetHeader(absoluteFile);
 951                 }
 952                 else if (subchild->GetName() == "compoundname")
 953                 {
 954                     klass.SetName(subchild->GetNodeContent());
 955                 }
 956                 /*else if (subchild->GetName() == "includes")
 957                 {
 958                     // NOTE: we'll get the header from the <location> tags
 959                     //       scattered inside <memberdef> tags instead of
 960                     //       this <includes> tag since it does not contain
 961                     //       the absolute path of the header
 962
 963                     klass.SetHeader(subchild->GetNodeContent());
 964                 }*/
 965
 966                 subchild = subchild->GetNext();
 967             }
 968
 969             // add a new class
 970             if (klass.IsOk())
 971                 m_classes.Add(klass);
 972             else if (g_verbose)
 973                 LogWarning("discarding class '%s' with %d methods...",
 974                         klass.GetName(), klass.GetMethodCount());
 975         }
 976
 977         child = child->GetNext();
 978
 979         // give feedback to the user about the progress...
 980         if ((++nodes%PROGRESS_RATE)==0) ShowProgress();
 981     }
 982
 983     return true;
 984 }
 985
 986 static wxString GetTextFromChildren(const wxXmlNode *n)
 987 {
 988     wxString text;
 989
 990     // consider the tree
 991     //
 992     //  <a><b>this</b> is a <b>string</b></a>
 993     //
 994     // <a>
 995     // |- <b>
 996     // |   |- this
 997     // |- is a
 998     // |- <b>
 999     //     |- string
1000     //
1001     // unlike wxXmlNode::GetNodeContent() which would return " is a "
1002     // this function returns "this is a string"
1003
1004     wxXmlNode *ref = n->GetChildren();
1005     while (ref) {
1006         if (ref->GetType() == wxXML_ELEMENT_NODE)
1007             text += ref->GetNodeContent();
1008         else if (ref->GetType() == wxXML_TEXT_NODE)
1009             text += ref->GetContent();
1010         else
1011             LogWarning("Unexpected node type while getting text from '%s' node", n->GetName());
1012
1013         ref = ref->GetNext();
1014     }
1015
1016     return text;
1017 }
1018
1019 bool wxXmlDoxygenInterface::ParseMethod(const wxXmlNode* p, wxMethod& m, wxString& header)
1020 {
1021     wxTypeArray args;
1022     wxArrayString defs;
1023     long line;
1024
1025     wxXmlNode *child = p->GetChildren();
1026     while (child)
1027     {
1028         if (child->GetName() == "name")
1029             m.SetName(child->GetNodeContent());
1030         else if (child->GetName() == "type")
1031             m.SetReturnType(wxType(GetTextFromChildren(child)));
1032         else if (child->GetName() == "param")
1033         {
1034             wxString typestr, defstr, arrstr;
1035             wxXmlNode *n = child->GetChildren();
1036             while (n)
1037             {
1038                 if (n->GetName() == "type")
1039                     // if the <type> node has children, they should be all TEXT and <ref> nodes
1040                     // and we need to take the text they contain, in the order they appear
1041                     typestr = GetTextFromChildren(n);
1042                 else if (n->GetName() == "defval")
1043                     // same for the <defval> node
1044                     defstr = GetTextFromChildren(n);
1045                 else if (n->GetName() == "array")
1046                     arrstr = GetTextFromChildren(n);
1047
1048                 n = n->GetNext();
1049             }
1050
1051             if (typestr.IsEmpty()) {
1052                 LogError("cannot find type node for a param in method '%s'", m.GetName());
1053                 return false;
1054             }
1055
1056             args.Add(wxType(typestr + arrstr));
1057             defs.Add(defstr);
1058         }
1059         else if (child->GetName() == "location")
1060         {
1061             if (child->GetAttribute("line").ToLong(&line))
1062                 m.SetLocation((int)line);
1063             header = child->GetAttribute("file");
1064         }
1065
1066         child = child->GetNext();
1067     }
1068
1069     m.SetArgumentTypes(args, defs);
1070     m.SetConst(p->GetAttribute("const")=="yes");
1071     m.SetStatic(p->GetAttribute("static")=="yes");
1072     m.SetVirtual(p->GetAttribute("virt")=="virtual");
1073
1074     if (!m.IsOk()) {
1075         LogError("The prototype '%s' is not valid!", m.GetAsString());
1076         return false;
1077     }
1078
1079     return true;
1080 }