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     #include "wx/crt.h"
  21 #endif
  22
  23 #include "wx/xml/xml.h"
  24 #include "wx/wfstream.h"
  25 #include "wx/hashmap.h"
  26 #include "wx/filename.h"
  27 #include "xmlparser.h"
  28 #include <errno.h>
  29
  30 #include <wx/arrimpl.cpp>
  31 WX_DEFINE_OBJARRAY(wxTypeArray)
  32 WX_DEFINE_OBJARRAY(wxArgumentTypeArray)
  33 WX_DEFINE_OBJARRAY(wxMethodArray)
  34 WX_DEFINE_OBJARRAY(wxClassArray)
  35
  36
  37 #define PROGRESS_RATE             1000     // each PROGRESS_RATE nodes processed print a dot
  38 #define ESTIMATED_NUM_CLASSES     600      // used by both wxXmlInterface-derived classes to prealloc mem
  39
  40
  41 // defined in ifacecheck.cpp
  42 extern bool g_verbose;
  43
  44 // global variable:
  45 bool g_bLogEnabled = true;
  46
  47
  48
  49 // ----------------------------------------------------------------------------
  50 // wxType
  51 // ----------------------------------------------------------------------------
  52
  53 wxType wxEmptyType;
  54
  55 void wxType::SetTypeFromString(const wxString& t)
  56 {
  57     /*
  58         TODO: optimize the following code writing a single function
  59               which works at char-level and does everything in a single pass
  60     */
  61
  62     m_strType = t;
  63
  64     // [] is the same as * for gccxml
  65     m_strType.Replace("[]", "*");
  66     m_strType.Replace("long int", "long");      // in wx typically we never write "long int", just "long"
  67
  68     // make sure the * and & operator always use the same spacing rules
  69     // (to make sure GetAsString() output is always consistent)
  70     m_strType.Replace("*", "* ");
  71     m_strType.Replace("&", "& ");
  72     m_strType.Replace(" *", "*");
  73     m_strType.Replace(" &", "&");
  74
  75     while (m_strType.Contains("  "))
  76         m_strType.Replace("  ", " ");       // do it once again
  77
  78     m_strType.Replace(" ,", ",");
  79
  80     m_strType = m_strType.Strip(wxString::both);
  81
  82     // now set the clean version
  83     m_strTypeClean = m_strType;
  84     m_strTypeClean.Replace("const", "");
  85     m_strTypeClean.Replace("static", "");
  86     m_strTypeClean.Replace("*", "");
  87     m_strTypeClean.Replace("&", "");
  88     m_strTypeClean.Replace("[]", "");
  89     m_strTypeClean = m_strTypeClean.Strip(wxString::both);
  90
  91     // to avoid false errors types like wxStandardPaths and wxStandardPathsBase
  92     // need to be considered as the same type
  93     if (m_strTypeClean.EndsWith("Base"))
  94         m_strTypeClean = m_strTypeClean.Left(m_strTypeClean.Len()-4);
  95
  96     // ADHOC-FIX:
  97     // doxygen likes to put wxDateTime:: in front of all wxDateTime enums;
  98     // fix this to avoid false positives
  99     m_strTypeClean.Replace("wxDateTime::", "");
 100     m_strTypeClean.Replace("wxStockGDI::", "");     // same story for some other classes
 101     m_strTypeClean.Replace("wxHelpEvent::", "");
 102 }
 103
 104 bool wxType::IsOk() const
 105 {
 106     // NB: m_strType can contain the :: operator; think to e.g. the
 107     //     "reverse_iterator_impl<wxString::const_iterator>" type
 108     //     It can also contain commas, * and & operators etc
 109
 110     return !m_strTypeClean.IsEmpty();
 111 }
 112
 113 bool wxType::operator==(const wxType& m) const
 114 {
 115     // brain-dead comparison:
 116
 117     if (m_strTypeClean == m.m_strTypeClean &&
 118         IsConst() == m.IsConst() &&
 119         IsStatic() == m.IsStatic() &&
 120         IsPointer() == m.IsPointer() &&
 121         IsReference() == m.IsReference())
 122         return true;
 123
 124     if (g_verbose)
 125     {
 126         LogMessage("Type '%s' does not match type '%s'", m_strType, m.m_strType);
 127         LogMessage(" => TypeClean %s / %s;  IsConst %d / %d; IsStatic %d / %d; IsPointer %d / %d; IsReference %d / %d",
 128                    m_strTypeClean, m.m_strTypeClean, IsConst(), m.IsConst(),
 129                    IsStatic(), m.IsStatic(), IsPointer(), m.IsPointer(),
 130                    IsReference(), m.IsReference());
 131     }
 132
 133     return false;
 134 }
 135
 136
 137 // ----------------------------------------------------------------------------
 138 // wxArgumentType
 139 // ----------------------------------------------------------------------------
 140
 141 void wxArgumentType::SetDefaultValue(const wxString& defval, const wxString& defvalForCmp)
 142 {
 143     m_strDefaultValue = defval.Strip(wxString::both);
 144     m_strDefaultValueForCmp = defvalForCmp.IsEmpty() ? m_strDefaultValue : defvalForCmp.Strip(wxString::both);
 145
 146     // adjust aesthetic form of DefaultValue for the modify mode of ifacecheck:
 147     // we may need to write it out in an interface header
 148     if (m_strDefaultValue == "0u")
 149         m_strDefaultValue = "0";
 150
 151     // in order to make valid&simple comparison on argument defaults,
 152     // we reduce some of the multiple forms in which the same things may appear
 153     // to a single form:
 154     if (m_strDefaultValueForCmp == "0u")
 155         m_strDefaultValueForCmp = "0";
 156
 157     m_strDefaultValue.Replace("0x000000001", "1");
 158     m_strDefaultValueForCmp.Replace("0x000000001", "1");
 159
 160     // fix for unicode strings:
 161     m_strDefaultValue.Replace("\\000\\000\\000", "");
 162     m_strDefaultValueForCmp.Replace("\\000\\000\\000", "");
 163
 164     if (m_strDefaultValueForCmp.StartsWith("wxT(") &&
 165         m_strDefaultValueForCmp.EndsWith(")"))
 166     {
 167         // get rid of the wxT() part
 168         unsigned int len = m_strDefaultValueForCmp.Len();
 169         m_strDefaultValueForCmp = m_strDefaultValueForCmp.Mid(4,len-5);
 170     }
 171
 172 /*
 173     if (IsPointer())
 174         m_strDefaultValueForCmp.Replace("0", "NULL");
 175     else
 176         m_strDefaultValueForCmp.Replace("NULL", "0");
 177 */
 178     // ADHOC-FIX:
 179     // doxygen likes to put wxDateTime:: in front of all wxDateTime enums;
 180     // fix this to avoid false positives
 181     m_strDefaultValueForCmp.Replace("wxDateTime::", "");
 182     m_strDefaultValueForCmp.Replace("wxStockGDI::", "");     // same story for some other classes
 183     m_strDefaultValueForCmp.Replace("wxHelpEvent::", "");    // same story for some other classes
 184
 185     m_strDefaultValueForCmp.Replace("wxGet_wxConvLocal()", "wxConvLocal");
 186
 187     m_strDefaultValueForCmp.Replace("* GetColour(COLOUR_BLACK)", "*wxBLACK");
 188
 189     // ADHOC-FIX:
 190     if (m_strDefaultValueForCmp.Contains("wxGetTranslation"))
 191         m_strDefaultValueForCmp = "_(TOFIX)";     // TODO: wxGetTranslation gives problems to gccxml
 192 }
 193
 194 bool wxArgumentType::operator==(const wxArgumentType& m) const
 195 {
 196     if ((const wxType&)(*this) != (const wxType&)m)
 197         return false;
 198
 199     // ADHOC-FIX:
 200     // default values for style attributes of wxWindow-derived classes in gccxml appear as raw
 201     // numbers; avoid false positives in this case!
 202     if (m_strArgName == m.m_strArgName && m_strArgName == "style" &&
 203         (m_strDefaultValueForCmp.IsNumber() || m.m_strDefaultValueForCmp.IsNumber()))
 204         return true;
 205
 206     // fix for default values which were replaced by gcc-xml with their numeric values
 207     // (at this point we know that m_strTypeClean == m.m_strTypeClean):
 208     if (m_strTypeClean == "long" || m_strTypeClean == "int")
 209     {
 210         if ((m_strDefaultValueForCmp.IsNumber() && m.m_strDefaultValueForCmp.StartsWith("wx")) ||
 211             (m.m_strDefaultValueForCmp.IsNumber() && m_strDefaultValueForCmp.StartsWith("wx")))
 212         {
 213             if (g_verbose)
 214                 LogMessage("Supposing '%s'  default value to be the same of '%s'...",
 215                            m_strDefaultValueForCmp, m.m_strDefaultValueForCmp);
 216
 217             return true;
 218         }
 219     }
 220
 221     if (m_strDefaultValueForCmp != m.m_strDefaultValueForCmp)
 222     {
 223         // maybe the default values are numbers.
 224         // in this case gccXML gives as default values things like '-0x0000001' instead of just '-1'.
 225         // To handle these cases, we try to convert the default value strings to numbers:
 226         long def1val, def2val;
 227         if (m_strDefaultValueForCmp.ToLong(&def1val, 0 /* auto-detect */) &&
 228             m.m_strDefaultValueForCmp.ToLong(&def2val, 0 /* auto-detect */))
 229         {
 230             if (def1val == def2val)
 231                 return true;        // the default values match
 232         }
 233
 234         if (g_verbose)
 235             LogMessage("Argument type '%s = %s' has different default value from '%s = %s'",
 236                        m_strType, m_strDefaultValueForCmp, m.m_strType, m.m_strDefaultValueForCmp);
 237         return false;
 238     }
 239
 240     // we deliberately avoid checks on the argument name
 241
 242     return true;
 243 }
 244
 245
 246 // ----------------------------------------------------------------------------
 247 // wxMethod
 248 // ----------------------------------------------------------------------------
 249
 250 bool wxMethod::IsOk() const
 251 {
 252     // NOTE: m_retType can be a wxEmptyType, and means that this method
 253     //       is a ctor or a dtor.
 254     if (!m_retType.IsOk() && m_retType!=wxEmptyType) {
 255         LogError("'%s' method has invalid return type: %s", m_retType.GetAsString());
 256         return false;
 257     }
 258
 259     if (m_strName.IsEmpty())
 260         return false;
 261
 262     // a function can't be both const and static or virtual and static!
 263     if ((m_bConst && m_bStatic) || ((m_bVirtual || m_bPureVirtual) && m_bStatic)) {
 264         LogError("'%s' method can't be both const/static or virtual/static", m_strName);
 265         return false;
 266     }
 267
 268     wxASSERT(!m_bPureVirtual || (m_bPureVirtual && m_bVirtual));
 269
 270     for (unsigned int i=0; i<m_args.GetCount(); i++)
 271         if (!m_args[i].IsOk()) {
 272             LogError("'%s' method has invalid %d-th argument type: %s",
 273                      m_strName, i+1, m_args[i].GetAsString());
 274             return false;
 275         }
 276
 277     // NB: the default value of the arguments can contain pretty much everything
 278     //     (think to e.g. wxPoint(3+4/2,0)   or   *wxBLACK   or  someClass<type>)
 279     //     so we don't do any test on their contents
 280     if (m_args.GetCount()>0)
 281     {
 282         bool previousArgHasDefault = m_args[0].HasDefaultValue();
 283         for (unsigned int i=1; i<m_args.GetCount(); i++)
 284         {
 285             if (previousArgHasDefault && !m_args[i].HasDefaultValue()) {
 286                 LogError("'%s' method has %d-th argument which has no default value "
 287                          "(while the previous one had one!)",
 288                          m_strName, i+1);
 289                 return false;
 290             }
 291
 292             previousArgHasDefault = m_args[i].HasDefaultValue();
 293         }
 294     }
 295
 296     return true;
 297 }
 298
 299 bool wxMethod::MatchesExceptForAttributes(const wxMethod& m) const
 300 {
 301     if (GetReturnType() != m.GetReturnType() ||
 302         GetName() != m.GetName())
 303     {
 304         if (g_verbose)
 305             LogMessage("The method '%s' does not match method '%s'; different names/rettype", GetName(), m.GetName());
 306         return false;
 307     }
 308
 309     if (m_args.GetCount()!=m.m_args.GetCount()) {
 310         if (g_verbose)
 311             LogMessage("Method '%s' has %d arguments while '%s' has %d arguments",
 312                        m_strName, m_args.GetCount(), m_strName, m.m_args.GetCount());
 313         return false;
 314     }
 315
 316     // compare argument types
 317     for (unsigned int i=0; i<m_args.GetCount(); i++)
 318         if (m_args[i] != m.m_args[i])
 319             return false;
 320
 321     return true;
 322 }
 323
 324 bool wxMethod::operator==(const wxMethod& m) const
 325 {
 326     // check attributes
 327     if (IsConst() != m.IsConst() ||
 328         IsStatic() != m.IsStatic() ||
 329         IsVirtual() != m.IsVirtual() ||
 330         IsPureVirtual() != m.IsPureVirtual() ||
 331         IsDeprecated() != m.IsDeprecated() ||
 332         GetAccessSpecifier() != m.GetAccessSpecifier())
 333     {
 334         if (g_verbose)
 335             LogMessage("The method '%s' does not match method '%s'; different attributes", GetName(), m.GetName());
 336
 337         return false;
 338     }
 339
 340     // check everything else
 341     return MatchesExceptForAttributes(m);
 342 }
 343
 344 wxString wxMethod::GetAsString(bool bWithArgumentNames, bool bCleanDefaultValues,
 345                                bool bDeprecated, bool bAccessSpec) const
 346 {
 347     wxString ret;
 348
 349     // NOTE: for return and argument types, never use wxType::GetAsCleanString
 350     //       since in that way we'd miss important decorators like &,*,const etc
 351
 352     if (m_retType!=wxEmptyType)
 353         ret += m_retType.GetAsString() + " ";
 354     //else; this is a ctor or dtor
 355
 356     ret += m_strName + "(";
 357
 358     for (unsigned int i=0; i<m_args.GetCount(); i++)
 359     {
 360         ret += m_args[i].GetAsString();
 361
 362         const wxString& name = m_args[i].GetArgumentName();
 363         if (bWithArgumentNames && !name.IsEmpty())
 364             ret += " " + name;
 365
 366         const wxString& def = bCleanDefaultValues ?
 367             m_args[i].GetDefaultCleanValue() : m_args[i].GetDefaultValue();
 368         if (!def.IsEmpty())
 369             ret += " = " + def;
 370
 371         ret += ", ";
 372     }
 373
 374     if (m_args.GetCount()>0)
 375         ret = ret.Left(ret.Len()-2);
 376
 377     ret += ")";
 378
 379     if (m_bConst)
 380         ret += " const";
 381     if (m_bStatic)
 382         ret = "static " + ret;
 383     if (m_bVirtual || m_bPureVirtual)
 384         ret = "virtual " + ret;
 385     if (m_bPureVirtual)
 386         ret += " = 0";
 387     if (m_bDeprecated && bDeprecated)
 388         ret += " [deprecated]";
 389
 390     if (bAccessSpec)
 391     {
 392         switch (m_access)
 393         {
 394         case wxMAS_PUBLIC:
 395             ret += " [public]";
 396             break;
 397         case wxMAS_PROTECTED:
 398             ret += " [protected]";
 399             break;
 400         case wxMAS_PRIVATE:
 401             ret += " [private]";
 402             break;
 403         }
 404     }
 405
 406     return ret;
 407 }
 408
 409 void wxMethod::Dump(wxTextOutputStream& stream) const
 410 {
 411     stream << "[" + m_retType.GetAsString() + "]";
 412     stream << "[" + m_strName + "]";
 413
 414     for (unsigned int i=0; i<m_args.GetCount(); i++)
 415         stream << "[" + m_args[i].GetAsString() + " " + m_args[i].GetArgumentName() +
 416                   "=" + m_args[i].GetDefaultValue() + "]";
 417
 418     if (IsConst())
 419         stream << " CONST";
 420     if (IsStatic())
 421         stream << " STATIC";
 422     if (IsVirtual())
 423         stream << " VIRTUAL";
 424     if (IsPureVirtual())
 425         stream << " PURE-VIRTUAL";
 426     if (IsDeprecated())
 427         stream << " DEPRECATED";
 428
 429     // no final newline
 430 }
 431
 432 // ----------------------------------------------------------------------------
 433 // wxClass
 434 // ----------------------------------------------------------------------------
 435
 436 wxString wxClass::GetNameWithoutTemplate() const
 437 {
 438     // NB: I'm not sure this is the right terminology for this function!
 439
 440     if (m_strName.Contains("<"))
 441         return m_strName.Left(m_strName.Find("<"));
 442     return m_strName;
 443 }
 444
 445 bool wxClass::IsValidCtorForThisClass(const wxMethod& m) const
 446 {
 447     // remember that e.g. the ctor for wxWritableCharTypeBuffer<wchar_t> is
 448     // named wxWritableCharTypeBuffer, without the <...> part!
 449
 450     if (m.IsCtor() && m.GetName() == GetNameWithoutTemplate())
 451         return true;
 452
 453     return false;
 454 }
 455
 456 bool wxClass::IsValidDtorForThisClass(const wxMethod& m) const
 457 {
 458     if (m.IsDtor() && m.GetName() == "~" + GetNameWithoutTemplate())
 459         return true;
 460
 461     return false;
 462 }
 463
 464 void wxClass::Dump(wxTextOutputStream& out) const
 465 {
 466     out << m_strName + "\n";
 467
 468     for (unsigned int i=0; i<m_methods.GetCount(); i++) {
 469
 470         // dump all our methods
 471         out << "|- ";
 472         m_methods[i].Dump(out);
 473         out << "\n";
 474     }
 475
 476     out << "\n";
 477 }
 478
 479 bool wxClass::CheckConsistency() const
 480 {
 481     for (unsigned int i=0; i<m_methods.GetCount(); i++)
 482         for (unsigned int j=0; j<m_methods.GetCount(); j++)
 483             if (i!=j && m_methods[i] == m_methods[j])
 484             {
 485                 LogError("class %s has two methods with the same prototype: '%s'",
 486                          m_strName, m_methods[i].GetAsString());
 487                 return false;
 488
 489                 // fix the problem?
 490                 //((wxClass*)this)->m_methods.RemoveAt(j);
 491                 //j--;
 492             }
 493
 494     return true;
 495 }
 496
 497 const wxMethod* wxClass::FindMethod(const wxMethod& m) const
 498 {
 499     for (unsigned int i=0; i<m_methods.GetCount(); i++)
 500         if (m_methods[i] == m)
 501             return &m_methods[i];
 502     return NULL;
 503 }
 504
 505 const wxMethod* wxClass::RecursiveUpwardFindMethod(const wxMethod& m,
 506                                                    const wxXmlInterface* allclasses) const
 507 {
 508     // first, search into *this
 509     const wxMethod* ret = FindMethod(m);
 510     if (ret)
 511         return ret;
 512
 513     // then, search into its parents
 514     for (unsigned int i=0; i<m_parents.GetCount(); i++)
 515     {
 516         // ignore non-wx-classes parents
 517         // AD-HOC FIX: discard wxScrolledT_Helper parent as it always gives errors
 518         if (m_parents[i].StartsWith("wx") && m_parents[i] != "wxScrolledT_Helper")
 519         {
 520             const wxClass *parent = allclasses->FindClass(m_parents[i]);
 521             if (!parent) {
 522                 LogError("Could not find parent '%s' of class '%s'...",
 523                          m_parents[i], GetName());
 524                 return false;
 525             }
 526
 527             const wxMethod *parentMethod = parent->RecursiveUpwardFindMethod(m, allclasses);
 528             if (parentMethod)
 529                 return parentMethod;
 530         }
 531     }
 532
 533     // could not find anything even in parent classes...
 534     return NULL;
 535 }
 536
 537 wxMethodPtrArray wxClass::FindMethodsNamed(const wxString& name) const
 538 {
 539     wxMethodPtrArray ret;
 540
 541     for (unsigned int i=0; i<m_methods.GetCount(); i++)
 542         if (m_methods[i].GetName() == name)
 543             ret.Add(&m_methods[i]);
 544
 545     return ret;
 546 }
 547
 548
 549 wxMethodPtrArray wxClass::RecursiveUpwardFindMethodsNamed(const wxString& name,
 550                                                           const wxXmlInterface* allclasses) const
 551 {
 552     // first, search into *this
 553     wxMethodPtrArray ret = FindMethodsNamed(name);
 554     if (ret.GetCount()>0)
 555         return ret;         // stop here, don't look upward in the parents
 556
 557     // then, search into parents of this class
 558     for (unsigned int i=0; i<m_parents.GetCount(); i++)
 559     {
 560         // AD-HOC FIX: discard wxScrolledT_Helper parent as it always gives errors
 561         if (m_parents[i].StartsWith("wx") && m_parents[i] != "wxScrolledT_Helper")
 562         {
 563             const wxClass *parent = allclasses->FindClass(m_parents[i]);
 564             if (!parent) {
 565                 LogError("Could not find parent '%s' of class '%s'...",
 566                          m_parents[i], GetName());
 567                 return false;
 568             }
 569
 570             wxMethodPtrArray temp = parent->RecursiveUpwardFindMethodsNamed(name, allclasses);
 571             WX_APPEND_ARRAY(ret, temp);
 572         }
 573     }
 574
 575     return ret;
 576 }
 577
 578
 579
 580 // ----------------------------------------------------------------------------
 581 // wxXmlInterface
 582 // ----------------------------------------------------------------------------
 583
 584 WX_DEFINE_SORTED_ARRAY(wxClass*, wxSortedClassArray);
 585
 586 int CompareWxClassObjects(wxClass *item1, wxClass *item2)
 587 {
 588     // sort alphabetically
 589     return item1->GetName().Cmp(item2->GetName());
 590 }
 591
 592 void wxXmlInterface::Dump(const wxString& filename)
 593 {
 594     wxFFileOutputStream apioutput( filename );
 595     wxTextOutputStream apiout( apioutput );
 596
 597     // dump the classes in alphabetical order
 598     wxSortedClassArray sorted(CompareWxClassObjects);
 599     sorted.Alloc(m_classes.GetCount());
 600     for (unsigned int i=0; i<m_classes.GetCount(); i++)
 601         sorted.Add(&m_classes[i]);
 602
 603     // now they have been sorted
 604     for (unsigned int i=0; i<sorted.GetCount(); i++)
 605         sorted[i]->Dump(apiout);
 606 }
 607
 608 bool wxXmlInterface::CheckParseResults() const
 609 {
 610     // this check can be quite slow, so do it only for debug releases:
 611 //#ifdef __WXDEBUG__
 612     for (unsigned int i=0; i<m_classes.GetCount(); i++)
 613         if (!m_classes[i].CheckConsistency())
 614             return false;
 615 //#endif
 616
 617     return true;
 618 }
 619
 620 wxClassPtrArray wxXmlInterface::FindClassesDefinedIn(const wxString& headerfile) const
 621 {
 622     wxClassPtrArray ret;
 623
 624     for (unsigned int i=0; i<m_classes.GetCount(); i++)
 625         if (m_classes[i].GetHeader() == headerfile)
 626             ret.Add(&m_classes[i]);
 627
 628     return ret;
 629 }
 630
 631
 632 // ----------------------------------------------------------------------------
 633 // wxXmlGccInterface helper declarations
 634 // ----------------------------------------------------------------------------
 635
 636 // or-able flags for a toResolveTypeItem->attrib:
 637 #define ATTRIB_CONST        1
 638 #define ATTRIB_REFERENCE    2
 639 #define ATTRIB_POINTER      4
 640 #define ATTRIB_ARRAY        8
 641
 642 // it may sound strange but gccxml, in order to produce shorter ID names
 643 // uses (after the underscore) characters in range 0-9 and a-z in the ID names;
 644 // in order to be able to translate such strings into numbers using strtoul()
 645 // we use as base 10 (possible digits) + 25 (possible characters) = 35
 646 #define GCCXML_BASE         35
 647
 648 class toResolveTypeItem
 649 {
 650 public:
 651     toResolveTypeItem() { attribs=0; }
 652     toResolveTypeItem(unsigned int refID, unsigned int attribint)
 653         : ref(refID), attribs(attribint) {}
 654
 655     unsigned long ref,       // the referenced type's ID
 656                   attribs;   // the attributes of this reference
 657 };
 658
 659 #if 1
 660
 661 // for wxToResolveTypeHashMap, keys == gccXML IDs  and  values == toResolveTypeItem
 662 WX_DECLARE_HASH_MAP( unsigned long, toResolveTypeItem,
 663                      wxIntegerHash, wxIntegerEqual,
 664                      wxToResolveTypeHashMap );
 665
 666 // for wxClassMemberIdHashMap, keys == gccXML IDs  and  values == wxClass which owns that member ID
 667 WX_DECLARE_HASH_MAP( unsigned long, wxClass*,
 668                      wxIntegerHash, wxIntegerEqual,
 669                      wxClassMemberIdHashMap );
 670
 671 #else
 672 #include <map>
 673 typedef std::map<unsigned long, toResolveTypeItem> wxToResolveTypeHashMap;
 674 #endif
 675
 676
 677 // utility to parse gccXML ID values;
 678 // this function is equivalent to wxString(str).Mid(1).ToULong(&id, GCCXML_BASE)
 679 // but is a little bit faster
 680 bool getID(unsigned long *id, const wxString& str)
 681 {
 682     const wxStringCharType * const start = str.wx_str()+1;
 683     wxStringCharType *end;
 684 #if wxUSE_UNICODE_WCHAR
 685     unsigned long val = wcstoul(start, &end, GCCXML_BASE);
 686 #else
 687     unsigned long val = strtoul(start, &end, GCCXML_BASE);
 688 #endif
 689
 690     // return true only if scan was stopped by the terminating NUL and
 691     // if the string was not empty to start with and no under/overflow
 692     // occurred:
 693     if ( *end != '\0' || end == start || errno == ERANGE || errno == EINVAL )
 694         return false;
 695
 696     *id = val;
 697     return true;
 698 }
 699
 700 // utility specialized to parse efficiently the gccXML list of IDs which occur
 701 // in nodes like <Class> ones... i.e. numeric values separed by " _" token
 702 bool getMemberIDs(wxClassMemberIdHashMap* map, wxClass* p, const wxString& str)
 703 {
 704     const wxStringCharType * const start = str.wx_str();
 705 #if wxUSE_UNICODE_WCHAR
 706     size_t len = wcslen(start);
 707 #else
 708     size_t len = strlen(start);
 709 #endif
 710
 711     if (len == 0 || start[0] != '_')
 712         return false;
 713
 714     const wxStringCharType *curpos = start,
 715                            *end = start + len;
 716     wxStringCharType *nexttoken;
 717
 718     while (curpos < end)
 719     {
 720         // curpos always points to the underscore of the next token to parse:
 721 #if wxUSE_UNICODE_WCHAR
 722         unsigned long id = wcstoul(curpos+1, &nexttoken, GCCXML_BASE);
 723 #else
 724         unsigned long id = strtoul(curpos+1, &nexttoken, GCCXML_BASE);
 725 #endif
 726         if ( *nexttoken != ' ' || errno == ERANGE || errno == EINVAL )
 727             return false;
 728
 729         // advance current position
 730         curpos = nexttoken + 1;
 731
 732         // add this ID to the hashmap
 733         wxClassMemberIdHashMap::value_type v(id, p);
 734         map->insert(v);
 735     }
 736
 737     return true;
 738 }
 739
 740
 741 // ----------------------------------------------------------------------------
 742 // wxXmlGccInterface
 743 // ----------------------------------------------------------------------------
 744
 745 bool wxXmlGccInterface::Parse(const wxString& filename)
 746 {
 747     wxXmlDocument doc;
 748     wxXmlNode *child;
 749     int nodes = 0;
 750
 751     LogMessage("Parsing %s...", filename);
 752
 753     if (!doc.Load(filename)) {
 754         LogError("can't load %s", filename);
 755         return false;
 756     }
 757
 758     // start processing the XML file
 759     if (doc.GetRoot()->GetName() != "GCC_XML") {
 760         LogError("invalid root node for %s", filename);
 761         return false;
 762     }
 763
 764     wxString version = doc.GetRoot()->GetAttribute("cvs_revision");
 765     bool old = false;
 766
 767 #define MIN_REVISION  120
 768
 769     if (!version.StartsWith("1."))
 770         old = true;
 771     if (!old)
 772     {
 773         unsigned long rev = 0;
 774         if (!version.Mid(2).ToULong(&rev))
 775             old = true;
 776         else
 777             if (rev < MIN_REVISION)
 778                 old = true;
 779     }
 780
 781     if (old)
 782     {
 783         LogError("The version of GCC-XML used for the creation of %s is too old; "
 784                  "the cvs_revision attribute of the root node reports '%s', "
 785                  "minimal required is 1.%d.", filename, version, MIN_REVISION);
 786         return false;
 787     }
 788
 789     wxToResolveTypeHashMap toResolveTypes;
 790     wxClassMemberIdHashMap members;
 791     wxTypeIdHashMap types;
 792     wxTypeIdHashMap files;
 793     wxTypeIdHashMap typedefs;
 794
 795     // prealloc quite a lot of memory!
 796     m_classes.Alloc(ESTIMATED_NUM_CLASSES);
 797
 798     // build a list of wx classes and in general of all existent types
 799     child = doc.GetRoot()->GetChildren();
 800     while (child)
 801     {
 802         const wxString& n = child->GetName();
 803
 804         unsigned long id = 0;
 805         if (!getID(&id, child->GetAttribute("id")) || (id == 0 && n != "File")) {
 806
 807             // NOTE: <File> nodes can have an id == "f0"...
 808
 809             LogError("Invalid id for node %s: %s", n, child->GetAttribute("id"));
 810             return false;
 811         }
 812
 813         if (n == "Class")
 814         {
 815             wxString cname = child->GetAttribute("name");
 816             if (cname.IsEmpty()) {
 817                 LogError("Invalid empty name for '%s' node", n);
 818                 return false;
 819             }
 820
 821             // only register wx classes (do remember also the IDs of their members)
 822             if (cname.StartsWith("wx"))
 823             {
 824                 // NB: "file" attribute contains an ID value that we'll resolve later
 825                 m_classes.Add(wxClass(cname, child->GetAttribute("file")));
 826
 827                 // the just-inserted class:
 828                 wxClass *newClass = &m_classes.Last();
 829
 830                 // now get a list of the base classes:
 831                 wxXmlNode *baseNode = child->GetChildren();
 832                 while (baseNode)
 833                 {
 834                     // for now we store as "parents" only the parent IDs...
 835                     // later we will resolve them into full class names
 836                     if (baseNode->GetName() == "Base")
 837                         newClass->AddParent(baseNode->GetAttribute("type"));
 838
 839                     baseNode = baseNode->GetNext();
 840                 }
 841
 842                 const wxString& ids = child->GetAttribute("members");
 843                 if (ids.IsEmpty())
 844                 {
 845                     if (child->GetAttribute("incomplete") != "1") {
 846                         LogError("Invalid member IDs for '%s' class node: %s",
 847                                 cname, child->GetAttribute("id"));
 848                         return false;
 849                     }
 850                     //else: don't warn the user; it looks like "incomplete" classes
 851                     //      never have any member...
 852                 }
 853                 else
 854                 {
 855                     // decode the non-empty list of IDs:
 856                     if (!getMemberIDs(&members, newClass, ids)) {
 857                         LogError("Invalid member IDs for '%s' class node: %s",
 858                                 cname, child->GetAttribute("id"));
 859                         return false;
 860                     }
 861                 }
 862             }
 863
 864             // register this class also as possible return/argument type:
 865             types[id] = cname;
 866         }
 867         else if (n == "Typedef")
 868         {
 869             unsigned long typeId = 0;
 870             if (!getID(&typeId, child->GetAttribute("type"))) {
 871                 LogError("Invalid type for node %s: %s", n, child->GetAttribute("type"));
 872                 return false;
 873             }
 874
 875             // this typedef node tell us that every type referenced with the
 876             // "typeId" ID should be called with another name:
 877             wxString name = child->GetAttribute("name");
 878
 879             // save this typedef in a separate hashmap...
 880             typedefs[typeId] = name;
 881
 882             types[id] = name;
 883         }
 884         else if (n == "PointerType" || n == "ReferenceType" ||
 885                  n == "CvQualifiedType" || n == "ArrayType")
 886         {
 887             unsigned long type = 0;
 888             if (!getID(&type, child->GetAttribute("type")) || type == 0) {
 889                 LogError("Invalid type for node %s: %s", n, child->GetAttribute("type"));
 890                 return false;
 891             }
 892
 893             unsigned long attr = 0;
 894             if (n == "PointerType")
 895                 attr = ATTRIB_POINTER;
 896             else if (n == "ReferenceType")
 897                 attr = ATTRIB_REFERENCE;
 898             else if (n == "CvQualifiedType" && child->GetAttribute("const") == "1")
 899                 attr = ATTRIB_CONST;
 900             else if (n == "ArrayType")
 901                 attr = ATTRIB_ARRAY;
 902
 903             // these nodes make reference to other types... we'll resolve them later
 904             toResolveTypes[id] = toResolveTypeItem(type, attr);
 905         }
 906         else if (n == "FunctionType" || n == "MethodType")
 907         {
 908             /*
 909                  TODO: parsing FunctionType and MethodType nodes is not as easy
 910                        as for other "simple" types.
 911             */
 912
 913             wxString argstr;
 914             wxXmlNode *arg = child->GetChildren();
 915             while (arg)
 916             {
 917                 if (arg->GetName() == "Argument")
 918                     argstr += arg->GetAttribute("type") + ", ";
 919                 arg = arg->GetNext();
 920             }
 921
 922             if (argstr.Len() > 0)
 923                 argstr = argstr.Left(argstr.Len()-2);       // remove final comma
 924
 925             // these nodes make reference to other types... we'll resolve them later
 926             //toResolveTypes[id] = toResolveTypeItem(ret, 0);
 927             //types[id] = child->GetAttribute("returns") + "(" + argstr + ")";
 928
 929             types[id] = "TOFIX";   // typically this type will be "fixed" thanks
 930                                    // to a typedef later...
 931         }
 932         else if (n == "File")
 933         {
 934             if (!child->GetAttribute("id").StartsWith("f")) {
 935                 LogError("Unexpected file ID: %s", child->GetAttribute("id"));
 936                 return false;
 937             }
 938
 939             // just ignore this node... all file IDs/names were already parsed
 940             files[id] = child->GetAttribute("name");
 941         }
 942         else
 943         {
 944             // we register everything else as a possible return/argument type:
 945             const wxString& name = child->GetAttribute("name");
 946
 947             if (!name.IsEmpty())
 948             {
 949                 //typeIds.Add(id);
 950                 //typeNames.Add(name);
 951                 types[id] = name;
 952             }
 953             else
 954             {
 955                 // this may happen with unnamed structs/union, special ctors,
 956                 // or other exotic things which we are not interested to, since
 957                 // they're never used as return/argument types by wxWidgets methods
 958
 959                 if (g_verbose)
 960                     LogWarning("Type node '%s' with ID '%s' does not have name attribute",
 961                                n, child->GetAttribute("id"));
 962
 963                 types[id] = "TOFIX";
 964             }
 965         }
 966
 967         child = child->GetNext();
 968
 969         // give feedback to the user about the progress...
 970         if ((++nodes%PROGRESS_RATE)==0) ShowProgress();
 971     }
 972
 973     // some nodes with IDs referenced by methods as return/argument types, do reference
 974     // in turn other nodes (see PointerType, ReferenceType and CvQualifierType above);
 975     // thus we need to resolve their name iteratively:
 976     while (toResolveTypes.size()>0)
 977     {
 978         if (g_verbose)
 979             LogMessage("%d types were collected; %d types need yet to be resolved...",
 980                        types.size(), toResolveTypes.size());
 981
 982         for (wxToResolveTypeHashMap::iterator i = toResolveTypes.begin();
 983              i != toResolveTypes.end();)
 984         {
 985             unsigned long id = i->first;
 986             unsigned long referenced = i->second.ref;
 987
 988             wxTypeIdHashMap::iterator primary = types.find(referenced);
 989             if (primary != types.end())
 990             {
 991                 // this to-resolve-type references a "primary" type
 992
 993                 wxString newtype = primary->second;
 994                 int attribs = i->second.attribs;
 995
 996                 // attribs may contain a combination of ATTRIB_* flags:
 997                 if (attribs & ATTRIB_CONST)
 998                     newtype = "const " + newtype;
 999                 if (attribs & ATTRIB_REFERENCE)
1000                     newtype = newtype + "&";
1001                 if (attribs & ATTRIB_POINTER)
1002                     newtype = newtype + "*";
1003                 if (attribs & ATTRIB_ARRAY)
1004                     newtype = newtype + "[]";
1005
1006                 // add the resolved type to the list of "primary" types
1007                 if (newtype.Contains("TOFIX") && typedefs[id] != "")
1008                     types[id] = typedefs[id];       // better use a typedef for this type!
1009                 else
1010                     types[id] = newtype;
1011
1012                 // this one has been resolved; erase it through its iterator!
1013                 toResolveTypes.erase(i);
1014
1015                 // now iterator i is invalid; assign it again to the beginning
1016                 i = toResolveTypes.begin();
1017             }
1018             else
1019             {
1020                 // then search in the referenced types themselves:
1021                 wxToResolveTypeHashMap::iterator idx2 = toResolveTypes.find(referenced);
1022                 if (idx2 != toResolveTypes.end())
1023                 {
1024                     // merge this to-resolve-type with the idx2->second type
1025                     i->second.ref = idx2->second.ref;
1026                     i->second.attribs |= idx2->second.attribs;
1027
1028                     // this type will eventually be solved in the next while() iteration
1029                     i++;
1030                 }
1031                 else
1032                 {
1033                     LogError("Cannot solve '%d' reference type!", referenced);
1034                     return false;
1035                 }
1036             }
1037         }
1038     }
1039
1040     // resolve header names
1041     for (unsigned int i=0; i<m_classes.GetCount(); i++)
1042     {
1043         unsigned long fileID = 0;
1044         if (!getID(&fileID, m_classes[i].GetHeader()) || fileID == 0) {
1045             LogError("invalid header id: %s", m_classes[i].GetHeader());
1046             return false;
1047         }
1048
1049         // search this file
1050         wxTypeIdHashMap::const_iterator idx = files.find(fileID);
1051         if (idx == files.end())
1052         {
1053             // this is an error!
1054             LogError("couldn't find file ID '%s'", m_classes[i].GetHeader());
1055         }
1056         else
1057             m_classes[i].SetHeader(idx->second);
1058     }
1059
1060     // resolve parent names
1061     for (unsigned int i=0; i<m_classes.GetCount(); i++)
1062     {
1063         for (unsigned int k=0; k<m_classes[i].GetParentCount(); k++)
1064         {
1065             unsigned long id;
1066
1067             if (!getID(&id, m_classes[i].GetParent(k))) {
1068                 LogError("invalid parent class ID for '%s'", m_classes[i].GetName());
1069                 return false;
1070             }
1071
1072             wxTypeIdHashMap::const_iterator idx = types.find(id);
1073             if (idx == types.end())
1074             {
1075                 // this is an error!
1076                 LogError("couldn't find parent class ID '%d'", id);
1077             }
1078             else
1079                 // replace k-th parent with its true name:
1080                 m_classes[i].SetParent(k, idx->second);
1081         }
1082     }
1083
1084     // build the list of the wx methods
1085     child = doc.GetRoot()->GetChildren();
1086     while (child)
1087     {
1088         wxString n = child->GetName(), acc = child->GetAttribute("access");
1089
1090         // only register public&protected methods
1091         if ((acc == "public" || acc == "protected") &&
1092             (n == "Method" || n == "Constructor" || n == "Destructor" || n == "OperatorMethod"))
1093         {
1094             unsigned long id = 0;
1095             if (!getID(&id, child->GetAttribute("id"))) {
1096                 LogError("invalid ID for node '%s' with ID '%s'", n, child->GetAttribute("id"));
1097                 return false;
1098             }
1099
1100             wxClassMemberIdHashMap::const_iterator it = members.find(id);
1101             if (it != members.end())
1102             {
1103                 wxClass *p = it->second;
1104
1105                 // this <Method> node is a method of the i-th class!
1106                 wxMethod newfunc;
1107                 if (!ParseMethod(child, types, newfunc)) {
1108                     LogError("The method '%s' could not be added to class '%s'",
1109                              child->GetAttribute("demangled"), p->GetName());
1110                     return false;
1111                 }
1112
1113                 // do some additional check that we can do only here:
1114
1115                 if (newfunc.IsCtor() && !p->IsValidCtorForThisClass(newfunc)) {
1116                     LogError("The method '%s' does not seem to be a ctor for '%s'",
1117                              newfunc.GetName(), p->GetName());
1118                     return false;
1119                 }
1120                 if (newfunc.IsDtor() && !p->IsValidDtorForThisClass(newfunc)) {
1121                     LogError("The method '%s' does not seem to be a dtor for '%s'",
1122                              newfunc.GetName(), p->GetName());
1123                     return false;
1124                 }
1125
1126                 p->AddMethod(newfunc);
1127             }
1128         }
1129
1130         child = child->GetNext();
1131
1132         // give feedback to the user about the progress...
1133         if ((++nodes%PROGRESS_RATE)==0) ShowProgress();
1134     }
1135
1136     if (!CheckParseResults())
1137         return false;
1138
1139     return true;
1140 }
1141
1142 bool wxXmlGccInterface::ParseMethod(const wxXmlNode *p,
1143                                     const wxTypeIdHashMap& types,
1144                                     wxMethod& m)
1145 {
1146     // get the real name
1147     wxString name = p->GetAttribute("name").Strip(wxString::both);
1148     if (p->GetName() == "Destructor")
1149         name = "~" + name;
1150     else if (p->GetName() == "OperatorMethod")
1151         name = "operator" + name;
1152
1153     // resolve return type
1154     wxType ret;
1155     unsigned long retid = 0;
1156     if (!getID(&retid, p->GetAttribute("returns")) || retid == 0)
1157     {
1158         if (p->GetName() != "Destructor" && p->GetName() != "Constructor") {
1159             LogError("Empty return ID for method '%s', with ID '%s'",
1160                      name, p->GetAttribute("id"));
1161             return false;
1162         }
1163     }
1164     else
1165     {
1166         wxTypeIdHashMap::const_iterator retidx = types.find(retid);
1167         if (retidx == types.end()) {
1168             LogError("Could not find return type ID '%s'", retid);
1169             return false;
1170         }
1171
1172         ret = wxType(retidx->second);
1173         if (!ret.IsOk()) {
1174             LogError("Invalid return type '%s' for method '%s', with ID '%s'",
1175                      retidx->second, name, p->GetAttribute("id"));
1176             return false;
1177         }
1178     }
1179
1180     // resolve argument types
1181     wxArgumentTypeArray argtypes;
1182     wxXmlNode *arg = p->GetChildren();
1183     while (arg)
1184     {
1185         if (arg->GetName() == "Argument")
1186         {
1187             unsigned long id = 0;
1188             if (!getID(&id, arg->GetAttribute("type")) || id == 0) {
1189                 LogError("Invalid argument type ID '%s' for method '%s' with ID %s",
1190                          arg->GetAttribute("type"), name, p->GetAttribute("id"));
1191                 return false;
1192             }
1193
1194             wxTypeIdHashMap::const_iterator idx = types.find(id);
1195             if (idx == types.end()) {
1196                 LogError("Could not find argument type ID '%s'", id);
1197                 return false;
1198             }
1199
1200             argtypes.Add(wxArgumentType(idx->second,
1201                                         arg->GetAttribute("default"),
1202                                         arg->GetAttribute("name")));
1203         }
1204
1205         arg = arg->GetNext();
1206     }
1207
1208     m.SetReturnType(ret);
1209     m.SetName(name);
1210     m.SetArgumentTypes(argtypes);
1211     m.SetConst(p->GetAttribute("const") == "1");
1212     m.SetStatic(p->GetAttribute("static") == "1");
1213
1214     // NOTE: gccxml is smart enough to mark as virtual those functions
1215     //       which are declared virtual in base classes but don't have
1216     //       the "virtual" keyword explicitely indicated in the derived
1217     //       classes... so we don't need any further logic for virtuals
1218
1219     m.SetVirtual(p->GetAttribute("virtual") == "1");
1220     m.SetPureVirtual(p->GetAttribute("pure_virtual") == "1");
1221     m.SetDeprecated(p->GetAttribute("attributes") == "deprecated");
1222
1223     // decode access specifier
1224     if (p->GetAttribute("access") == "public")
1225         m.SetAccessSpecifier(wxMAS_PUBLIC);
1226     else if (p->GetAttribute("access") == "protected")
1227         m.SetAccessSpecifier(wxMAS_PROTECTED);
1228     else if (p->GetAttribute("access") == "private")
1229         m.SetAccessSpecifier(wxMAS_PRIVATE);
1230
1231     if (!m.IsOk()) {
1232         LogError("The prototype '%s' is not valid!", m.GetAsString());
1233         return false;
1234     }
1235
1236     return true;
1237 }
1238
1239
1240
1241 // ----------------------------------------------------------------------------
1242 // wxXmlDoxygenInterface global helpers
1243 // ----------------------------------------------------------------------------
1244
1245 static wxString GetTextFromChildren(const wxXmlNode *n)
1246 {
1247     wxString text;
1248
1249     // consider the tree
1250     //
1251     //  <a><b>this</b> is a <b>string</b></a>
1252     //
1253     // <a>
1254     // |- <b>
1255     // |   |- this
1256     // |- is a
1257     // |- <b>
1258     //     |- string
1259     //
1260     // unlike wxXmlNode::GetNodeContent() which would return " is a "
1261     // this function returns "this is a string"
1262
1263     wxXmlNode *ref = n->GetChildren();
1264     while (ref) {
1265         if (ref->GetType() == wxXML_ELEMENT_NODE)
1266             text += ref->GetNodeContent();
1267         else if (ref->GetType() == wxXML_TEXT_NODE)
1268             text += ref->GetContent();
1269         else
1270             LogWarning("Unexpected node type while getting text from '%s' node", n->GetName());
1271
1272         ref = ref->GetNext();
1273     }
1274
1275     return text;
1276 }
1277
1278 static bool HasTextNodeContaining(const wxXmlNode *parent, const wxString& name)
1279 {
1280     if (!parent)
1281         return false;
1282
1283     wxXmlNode *p = parent->GetChildren();
1284     while (p)
1285     {
1286         switch (p->GetType())
1287         {
1288             case wxXML_TEXT_NODE:
1289                 if (p->GetContent() == name)
1290                     return true;
1291                 break;
1292
1293             case wxXML_ELEMENT_NODE:
1294                 // recurse into this node...
1295                 if (HasTextNodeContaining(p, name))
1296                     return true;
1297                 break;
1298
1299             default:
1300                 // skip it
1301                 break;
1302         }
1303
1304         p = p->GetNext();
1305     }
1306
1307     return false;
1308 }
1309
1310 static const wxXmlNode* FindNodeNamed(const wxXmlNode* parent, const wxString& name)
1311 {
1312     if (!parent)
1313         return NULL;
1314
1315     const wxXmlNode *p = parent->GetChildren();
1316     while (p)
1317     {
1318         if (p->GetName() == name)
1319             return p;       // found!
1320
1321         // search recursively in the children of this node
1322         const wxXmlNode *ret = FindNodeNamed(p, name);
1323         if (ret)
1324             return ret;
1325
1326         p = p->GetNext();
1327     }
1328
1329     return NULL;
1330 }
1331
1332 int GetAvailabilityFor(const wxXmlNode *node)
1333 {
1334     // identify <onlyfor> custom XML tags
1335     const wxXmlNode* onlyfor = FindNodeNamed(node, "onlyfor");
1336     if (!onlyfor)
1337         return wxPORT_UNKNOWN;
1338
1339     wxArrayString ports = wxSplit(onlyfor->GetNodeContent(), ',');
1340     int nAvail = wxPORT_UNKNOWN;
1341     for (unsigned int i=0; i < ports.GetCount(); i++)
1342     {
1343         if (!ports[i].StartsWith("wx")) {
1344             LogError("unexpected port ID '%s'", ports[i]);
1345             return false;
1346         }
1347
1348         nAvail |= wxPlatformInfo::GetPortId(ports[i].Mid(2));
1349     }
1350
1351     return nAvail;
1352 }
1353
1354
1355 // ----------------------------------------------------------------------------
1356 // wxXmlDoxygenInterface
1357 // ----------------------------------------------------------------------------
1358
1359 bool wxXmlDoxygenInterface::Parse(const wxString& filename)
1360 {
1361     wxXmlDocument index;
1362     wxXmlNode *compound;
1363
1364     LogMessage("Parsing %s...", filename);
1365
1366     if (!index.Load(filename)) {
1367         LogError("can't load %s", filename);
1368         return false;
1369     }
1370
1371     // start processing the index:
1372     if (index.GetRoot()->GetName() != "doxygenindex") {
1373         LogError("invalid root node for %s", filename);
1374         return false;
1375     }
1376
1377     /*
1378         NB: we may need in future to do a version-check here if the
1379             format of the XML generated by doxygen changes.
1380             For now (doxygen version 1.5.5), this check is not required
1381             since AFAIK the XML format never changed since it was introduced.
1382     */
1383
1384     m_classes.Alloc(ESTIMATED_NUM_CLASSES);
1385
1386     // process files referenced by this index file
1387     compound = index.GetRoot()->GetChildren();
1388     while (compound)
1389     {
1390         if (compound->GetName() == "compound" &&
1391             compound->GetAttribute("kind") == "class")
1392         {
1393             wxString refid = compound->GetAttribute("refid");
1394
1395             wxFileName fn(filename);
1396             if (!ParseCompoundDefinition(fn.GetPath(wxPATH_GET_SEPARATOR) + refid + ".xml"))
1397                 return false;
1398         }
1399
1400         compound = compound->GetNext();
1401     }
1402     //wxPrint("\n");
1403
1404     if (!CheckParseResults())
1405         return false;
1406
1407     return true;
1408 }
1409
1410 bool wxXmlDoxygenInterface::ParseCompoundDefinition(const wxString& filename)
1411 {
1412     wxClassMemberIdHashMap parents;
1413     wxXmlDocument doc;
1414     wxXmlNode *child;
1415     int nodes = 0;
1416
1417     if (g_verbose)
1418         LogMessage("Parsing %s...", filename);
1419
1420     if (!doc.Load(filename)) {
1421         LogError("can't load %s", filename);
1422         return false;
1423     }
1424
1425     // start processing this compound definition XML
1426     if (doc.GetRoot()->GetName() != "doxygen") {
1427         LogError("invalid root node for %s", filename);
1428         return false;
1429     }
1430
1431     // build a list of wx classes
1432     child = doc.GetRoot()->GetChildren();
1433     while (child)
1434     {
1435         if (child->GetName() == "compounddef" &&
1436             child->GetAttribute("kind") == "class")
1437         {
1438             // parse this class
1439             wxClass klass;
1440             wxString absoluteFile, header;
1441
1442             wxXmlNode *subchild = child->GetChildren();
1443             while (subchild)
1444             {
1445                 wxString kind = subchild->GetAttribute("kind");
1446
1447                 // parse only public&protected functions:
1448                 if (subchild->GetName() == "sectiondef" &&
1449                     (kind == "public-func" || kind == "protected-func"))
1450                 {
1451
1452                     wxXmlNode *membernode = subchild->GetChildren();
1453                     while (membernode)
1454                     {
1455                         if (membernode->GetName() == "memberdef" &&
1456                             membernode->GetAttribute("kind") == "function")
1457                         {
1458
1459                             wxMethod m;
1460                             if (!ParseMethod(membernode, m, header)) {
1461                                 LogError("The method '%s' could not be added to class '%s'",
1462                                          m.GetName(), klass.GetName());
1463                                 return false;
1464                             }
1465
1466                             if (kind == "public-func")
1467                                 m.SetAccessSpecifier(wxMAS_PUBLIC);
1468                             else if (kind == "protected-func")
1469                                 m.SetAccessSpecifier(wxMAS_PROTECTED);
1470                             else if (kind == "private-func")
1471                                 m.SetAccessSpecifier(wxMAS_PRIVATE);
1472
1473                             if (absoluteFile.IsEmpty())
1474                                 absoluteFile = header;
1475                             else if (header != absoluteFile)
1476                             {
1477                                 LogError("The method '%s' is documented in a different "
1478                                             "file from others (which belong to '%s') ?",
1479                                             header, absoluteFile);
1480                                 return false;
1481                             }
1482
1483                             klass.AddMethod(m);
1484                         }
1485
1486                         membernode = membernode->GetNext();
1487                     }
1488
1489                     // all methods of this class were taken from the header "absoluteFile":
1490                     klass.SetHeader(absoluteFile);
1491                 }
1492                 else if (subchild->GetName() == "compoundname")
1493                 {
1494                     klass.SetName(subchild->GetNodeContent());
1495                 }
1496                 /*else if (subchild->GetName() == "includes")
1497                 {
1498                     // NOTE: we'll get the header from the <location> tags
1499                     //       scattered inside <memberdef> tags instead of
1500                     //       this <includes> tag since it does not contain
1501                     //       the absolute path of the header
1502
1503                     klass.SetHeader(subchild->GetNodeContent());
1504                 }*/
1505                 else if (subchild->GetName() == "detaileddescription")
1506                 {
1507                     // identify <onlyfor> custom XML tags
1508                     klass.SetAvailability(GetAvailabilityFor(subchild));
1509                 }
1510                 else if (subchild->GetName() == "basecompoundref")
1511                 {
1512                     // add the name of this parent to the list of klass' parents
1513                     klass.AddParent(subchild->GetNodeContent());
1514                 }
1515
1516                 subchild = subchild->GetNext();
1517             }
1518
1519             // add a new class
1520             if (klass.IsOk())
1521                 m_classes.Add(klass);
1522             else if (g_verbose)
1523                 LogWarning("discarding class '%s' with %d methods...",
1524                         klass.GetName(), klass.GetMethodCount());
1525         }
1526
1527         child = child->GetNext();
1528
1529         // give feedback to the user about the progress...
1530         if ((++nodes%PROGRESS_RATE)==0) ShowProgress();
1531     }
1532
1533     return true;
1534 }
1535
1536 bool wxXmlDoxygenInterface::ParseMethod(const wxXmlNode* p, wxMethod& m, wxString& header)
1537 {
1538     wxArgumentTypeArray args;
1539     long line;
1540
1541     wxXmlNode *child = p->GetChildren();
1542     while (child)
1543     {
1544         if (child->GetName() == "name")
1545             m.SetName(child->GetNodeContent());
1546         else if (child->GetName() == "type")
1547             m.SetReturnType(wxType(GetTextFromChildren(child)));
1548         else if (child->GetName() == "param")
1549         {
1550             wxString typestr, namestr, defstr, arrstr;
1551             wxXmlNode *n = child->GetChildren();
1552             while (n)
1553             {
1554                 if (n->GetName() == "type")
1555                     // if the <type> node has children, they should be all TEXT and <ref> nodes
1556                     // and we need to take the text they contain, in the order they appear
1557                     typestr = GetTextFromChildren(n);
1558                 else if (n->GetName() == "declname")
1559                     namestr = GetTextFromChildren(n);
1560                 else if (n->GetName() == "defval")
1561                     defstr = GetTextFromChildren(n).Strip(wxString::both);
1562                 else if (n->GetName() == "array")
1563                     arrstr = GetTextFromChildren(n);
1564
1565                 n = n->GetNext();
1566             }
1567
1568             if (typestr.IsEmpty()) {
1569                 LogError("cannot find type node for a param in method '%s'", m.GetName());
1570                 return false;
1571             }
1572
1573             wxArgumentType newarg(typestr + arrstr, defstr, namestr);
1574
1575             // can we use preprocessor output to transform the default value
1576             // into the same form which gets processed by wxXmlGccInterface?
1577             wxStringHashMap::const_iterator it = m_preproc.find(defstr);
1578             if (it != m_preproc.end())
1579                 newarg.SetDefaultValue(defstr, it->second);
1580
1581             args.Add(newarg);
1582         }
1583         else if (child->GetName() == "location")
1584         {
1585             line = -1;
1586             if (child->GetAttribute("line").ToLong(&line))
1587                 m.SetLocation((int)line);
1588             header = child->GetAttribute("file");
1589         }
1590         else if (child->GetName() == "detaileddescription")
1591         {
1592             // when a method has a @deprecated tag inside its description,
1593             // Doxygen outputs somewhere nested inside <detaileddescription>
1594             // a <xreftitle>Deprecated</xreftitle> tag.
1595             m.SetDeprecated(HasTextNodeContaining(child, "Deprecated"));
1596
1597             // identify <onlyfor> custom XML tags
1598             m.SetAvailability(GetAvailabilityFor(child));
1599         }
1600
1601         child = child->GetNext();
1602     }
1603
1604     m.SetArgumentTypes(args);
1605     m.SetConst(p->GetAttribute("const")=="yes");
1606     m.SetStatic(p->GetAttribute("static")=="yes");
1607
1608     // NOTE: Doxygen is smart enough to mark as virtual those functions
1609     //       which are declared virtual in base classes but don't have
1610     //       the "virtual" keyword explicitely indicated in the derived
1611     //       classes... so we don't need any further logic for virtuals
1612
1613     m.SetVirtual(p->GetAttribute("virt")=="virtual");
1614     m.SetPureVirtual(p->GetAttribute("virt")=="pure-virtual");
1615
1616     if (!m.IsOk()) {
1617         LogError("The prototype '%s' is not valid!", m.GetAsString());
1618         return false;
1619     }
1620
1621     return true;
1622 }