utils/ifacecheck/src/ifacecheck.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        ifacecheck.cpp
   3 // Purpose:     Interface headers <=> real headers coherence checker
   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/app.h"
  21     #include "wx/crt.h"
  22 #endif
  23
  24 #include "wx/cmdline.h"
  25 #include "wx/textfile.h"
  26 #include "wx/filename.h"
  27 #include "wx/stopwatch.h"       // for wxGetLocalTime
  28 #include "xmlparser.h"
  29
  30 // global verbosity flag
  31 bool g_verbose = false;
  32
  33
  34
  35 // ----------------------------------------------------------------------------
  36 // IfaceCheckApp
  37 // ----------------------------------------------------------------------------
  38
  39 #define API_DUMP_FILE               "dump.api.txt"
  40 #define INTERFACE_DUMP_FILE         "dump.interface.txt"
  41
  42 #define PROCESS_ONLY_OPTION         "p"
  43 #define USE_PREPROCESSOR_OPTION     "u"
  44
  45 #define MODIFY_SWITCH               "m"
  46 #define DUMP_SWITCH                 "d"
  47 #define HELP_SWITCH                 "h"
  48 #define VERBOSE_SWITCH              "v"
  49
  50 static const wxCmdLineEntryDesc g_cmdLineDesc[] =
  51 {
  52     { wxCMD_LINE_OPTION, USE_PREPROCESSOR_OPTION, "use-preproc",
  53         "uses the preprocessor output to increase the checker accuracy",
  54         wxCMD_LINE_VAL_STRING, wxCMD_LINE_NEEDS_SEPARATOR },
  55     { wxCMD_LINE_OPTION, PROCESS_ONLY_OPTION, "process-only",
  56         "processes only header files matching the given wildcard",
  57         wxCMD_LINE_VAL_STRING, wxCMD_LINE_NEEDS_SEPARATOR },
  58     { wxCMD_LINE_SWITCH, MODIFY_SWITCH, "modify",
  59         "modify the interface headers to match the real ones" },
  60     { wxCMD_LINE_SWITCH, DUMP_SWITCH, "dump",
  61         "dump both interface and API to plain text dump.*.txt files" },
  62     { wxCMD_LINE_SWITCH, HELP_SWITCH, "help",
  63         "show help message", wxCMD_LINE_VAL_NONE, wxCMD_LINE_OPTION_HELP },
  64     { wxCMD_LINE_SWITCH, VERBOSE_SWITCH, "verbose",
  65         "be verbose" },
  66     { wxCMD_LINE_PARAM,  NULL, NULL,
  67         "gccXML", wxCMD_LINE_VAL_STRING, wxCMD_LINE_OPTION_MANDATORY },
  68     { wxCMD_LINE_PARAM,  NULL, NULL,
  69         "doxygenXML", wxCMD_LINE_VAL_STRING, wxCMD_LINE_OPTION_MANDATORY },
  70     wxCMD_LINE_DESC_END
  71 };
  72
  73 class IfaceCheckLog : public wxLog
  74 {
  75 public:
  76     IfaceCheckLog() {}
  77
  78     virtual void DoLogText(const wxString& msg)
  79     {
  80         // send all messages to stdout (normal behaviour is to sent them to stderr)
  81         wxPuts(msg);
  82         fflush(stdout);
  83     }
  84 };
  85
  86 class IfaceCheckApp : public wxAppConsole
  87 {
  88 public:
  89     // don't use builtin cmd line parsing:
  90     virtual bool OnInit() { m_modify=false; return true; }
  91     virtual int OnRun();
  92
  93     bool ParsePreprocessorOutput(const wxString& filename);
  94
  95     bool Compare();
  96     int CompareClasses(const wxClass* iface, const wxClass* api);
  97     bool FixMethod(const wxString& header, const wxMethod* iface, const wxMethod* api);
  98     bool StringContainsMethodName(const wxString& str, const wxMethod* m);
  99
 100     void PrintStatistics(long secs);
 101
 102     bool IsToProcess(const wxString& headername) const
 103     {
 104         if (m_strToMatch.IsEmpty())
 105             return true;
 106         return wxMatchWild(m_strToMatch, headername, false);
 107     }
 108
 109 protected:
 110     wxXmlGccInterface m_gccInterface;                  // "real" headers API
 111     wxXmlDoxygenInterface m_doxyInterface;             // doxygen-commented headers API
 112
 113     // was the MODIFY_SWITCH passed?
 114     bool m_modify;
 115
 116     // if non-empty, then PROCESS_ONLY_OPTION was passed and this is the
 117     // wildcard expression to match
 118     wxString m_strToMatch;
 119 };
 120
 121 IMPLEMENT_APP_CONSOLE(IfaceCheckApp)
 122
 123 int IfaceCheckApp::OnRun()
 124 {
 125     long startTime = wxGetLocalTime();      // for timing purpose
 126
 127     wxCmdLineParser parser(g_cmdLineDesc, argc, argv);
 128     parser.SetLogo(
 129         wxString::Format("wxWidgets Interface checker utility (built %s against %s)",
 130                          __DATE__, wxVERSION_STRING));
 131
 132     // make the output more readable:
 133     wxLog::SetActiveTarget(new IfaceCheckLog);
 134     wxLog::DisableTimestamp();
 135
 136     // parse the command line...
 137     bool ok = true;
 138     wxString preprocFile;
 139     switch (parser.Parse())
 140     {
 141         case 0:
 142             if (parser.Found(VERBOSE_SWITCH))
 143                 g_verbose = true;
 144
 145             // IMPORTANT: parsing #define values must be done _before_ actually
 146             //            parsing the GCC/doxygen XML files
 147             if (parser.Found(USE_PREPROCESSOR_OPTION, &preprocFile))
 148             {
 149                 if (!ParsePreprocessorOutput(preprocFile))
 150                     return 1;
 151             }
 152
 153             // in any case set basic std preprocessor #defines:
 154             m_doxyInterface.AddPreprocessorValue("NULL", "0");
 155
 156             // parse the two XML files which contain the real and the doxygen interfaces
 157             // for wxWidgets API:
 158             if (!m_gccInterface.Parse(parser.GetParam(0)) ||
 159                 !m_doxyInterface.Parse(parser.GetParam(1)))
 160                 return 1;
 161
 162             if (parser.Found(DUMP_SWITCH))
 163             {
 164                 wxLogMessage("Dumping real API to '%s'...", API_DUMP_FILE);
 165                 m_gccInterface.Dump(API_DUMP_FILE);
 166
 167                 wxLogMessage("Dumping interface API to '%s'...", INTERFACE_DUMP_FILE);
 168                 m_doxyInterface.Dump(INTERFACE_DUMP_FILE);
 169             }
 170             else
 171             {
 172                 if (parser.Found(MODIFY_SWITCH))
 173                     m_modify = true;
 174
 175                 if (parser.Found(PROCESS_ONLY_OPTION, &m_strToMatch))
 176                 {
 177                     size_t len = m_strToMatch.Len();
 178                     if (m_strToMatch.StartsWith("\"") &&
 179                         m_strToMatch.EndsWith("\"") &&
 180                         len > 2)
 181                         m_strToMatch = m_strToMatch.Mid(1, len-2);
 182                 }
 183
 184
 185                 ok = Compare();
 186             }
 187
 188             PrintStatistics(wxGetLocalTime() - startTime);
 189             return ok ? 0 : 1;
 190
 191         default:
 192             wxPrintf("\nThis utility checks that the interface XML files created by Doxygen are in\n");
 193             wxPrintf("synch with the real headers (whose contents are extracted by the gcc XML file).\n\n");
 194             wxPrintf("The 'gccXML' parameter should be the wxapi.xml file created by the 'rungccxml.sh'\n");
 195             wxPrintf("script which resides in 'utils/ifacecheck'.\n");
 196             wxPrintf("The 'doxygenXML' parameter should be the index.xml file created by Doxygen\n");
 197             wxPrintf("for the wxWidgets 'interface' folder.\n\n");
 198             wxPrintf("Since the gcc XML file does not contain info about #defines, if you use\n");
 199             wxPrintf("the -%s option, you'll get a smaller number of false warnings.\n",
 200                      USE_PREPROCESSOR_OPTION);
 201
 202             // HELP_SWITCH was passed or a syntax error occurred
 203             return 0;
 204     }
 205 }
 206
 207 bool IfaceCheckApp::Compare()
 208 {
 209     const wxClassArray& interfaces = m_doxyInterface.GetClasses();
 210     const wxClass* c;
 211     int mcount = 0, ccount = 0;
 212
 213     wxLogMessage("Comparing the interface API to the real API (%d classes to compare)...",
 214                  interfaces.GetCount());
 215
 216     if (!m_strToMatch.IsEmpty())
 217     {
 218         wxLogMessage("Processing only header files matching '%s' expression.", m_strToMatch);
 219     }
 220
 221     for (unsigned int i=0; i<interfaces.GetCount(); i++)
 222     {
 223         // only compare the methods which are available for the port
 224         // for which the gcc XML was produced
 225         if (interfaces[i].GetAvailability() != wxPORT_UNKNOWN &&
 226             (interfaces[i].GetAvailability() & m_gccInterface.GetInterfacePort()) == 0) {
 227
 228             if (g_verbose)
 229             {
 230                 wxLogMessage("skipping class '%s' since it's not available for the %s port.",
 231                            interfaces[i].GetName(), m_gccInterface.GetInterfacePortName());
 232             }
 233
 234             continue;       // skip this method
 235         }
 236
 237         // shorten the name of the header so the log file is more readable
 238         // and also for calling IsToProcess() against it
 239         wxString header = wxFileName(interfaces[i].GetHeader()).GetFullName();
 240
 241         if (!IsToProcess(header))
 242             continue;       // skip this one
 243
 244         wxString cname = interfaces[i].GetName();
 245
 246         // search in the real headers for i-th interface class; we search for
 247         // both class cname and cnameBase since in wxWidgets world tipically
 248         // class cname is platform-specific while the real public interface of
 249         // that class is part of the cnameBase class.
 250         /*c = m_gccInterface.FindClass(cname + "Base");
 251         if (c) api.Add(c);*/
 252
 253         c = m_gccInterface.FindClass(cname);
 254         if (!c)
 255         {
 256             // sometimes the platform-specific class is named "wxGeneric" + cname
 257             // or similar:
 258             c = m_gccInterface.FindClass("wxGeneric" + cname.Mid(2));
 259             if (!c)
 260             {
 261                 c = m_gccInterface.FindClass("wxGtk" + cname.Mid(2));
 262             }
 263         }
 264
 265         if (c) {
 266
 267             // there is a class with the same (logic) name!
 268             mcount += CompareClasses(&interfaces[i], c);
 269
 270         } else {
 271
 272             wxLogMessage("%s: couldn't find the real interface for the '%s' class",
 273                        header, cname);
 274             ccount++;
 275         }
 276     }
 277
 278     wxLogMessage("%d on a total of %d methods (%.1f%%) of the interface headers do not exist in the real headers",
 279                mcount, m_doxyInterface.GetMethodCount(), (float)(100.0 * mcount/m_doxyInterface.GetMethodCount()));
 280     wxLogMessage("%d on a total of %d classes (%.1f%%) of the interface headers do not exist in the real headers",
 281                ccount, m_doxyInterface.GetClassesCount(), (float)(100.0 * ccount/m_doxyInterface.GetClassesCount()));
 282
 283     return true;
 284 }
 285
 286 int IfaceCheckApp::CompareClasses(const wxClass* iface, const wxClass* api)
 287 {
 288     const wxMethod *real;
 289     int count = 0;
 290
 291     wxASSERT(iface && api);
 292
 293     // shorten the name of the header so the log file is more readable
 294     wxString header = wxFileName(iface->GetHeader()).GetFullName();
 295
 296     for (unsigned int i=0; i<iface->GetMethodCount(); i++)
 297     {
 298         const wxMethod& m = iface->GetMethod(i);
 299
 300         // only compare the methods which are available for the port
 301         // for which the gcc XML was produced
 302         if (m.GetAvailability() != wxPORT_UNKNOWN &&
 303             (m.GetAvailability() & m_gccInterface.GetInterfacePort()) == 0) {
 304
 305             if (g_verbose)
 306             {
 307                 wxLogMessage("skipping method '%s' since it's not available for the %s port.",
 308                            m.GetAsString(), m_gccInterface.GetInterfacePortName());
 309             }
 310
 311             continue;       // skip this method
 312         }
 313
 314         // search in the methods of the api classes provided
 315         real = api->RecursiveUpwardFindMethod(m, &m_gccInterface);
 316
 317         // avoid some false positives:
 318         if (!real && m.ActsAsDefaultCtor())
 319         {
 320             // build an artificial default ctor for this class:
 321             wxMethod temp(m);
 322             temp.GetArgumentTypes().Clear();
 323
 324             // repeat search:
 325             real = api->RecursiveUpwardFindMethod(temp, &m_gccInterface);
 326         }
 327
 328         // no matches?
 329         if (!real)
 330         {
 331             bool proceed = true;
 332             wxMethodPtrArray overloads =
 333                 api->RecursiveUpwardFindMethodsNamed(m.GetName(), &m_gccInterface);
 334
 335             // avoid false positives:
 336             for (unsigned int k=0; k<overloads.GetCount(); k++)
 337                 if (overloads[k]->MatchesExceptForAttributes(m) &&
 338                     m.IsDeprecated() && !overloads[k]->IsDeprecated())
 339                 {
 340                     // maybe the iface method is marked as deprecated but the
 341                     // real method is not?
 342                     wxMethod tmp(*overloads[k]);
 343                     tmp.SetDeprecated(true);
 344
 345                     if (tmp == m)
 346                     {
 347                         // in this case, we can disregard this warning... the real
 348                         // method probably is included in WXWIN_COMPAT sections!
 349                         proceed = false;    // skip this method
 350                     }
 351                 }
 352
 353 #define HACK_TO_AUTO_CORRECT_ONLY_METHOD_ATTRIBUTES        0
 354 #if HACK_TO_AUTO_CORRECT_ONLY_METHOD_ATTRIBUTES
 355             for (unsigned int k=0; k<overloads.GetCount(); k++)
 356                 if (overloads[k]->MatchesExceptForAttributes(m))
 357                 {
 358                     // fix default values of results[k]:
 359                     wxMethod tmp(*overloads[k]);
 360                     tmp.SetArgumentTypes(m.GetArgumentTypes());
 361
 362                     // modify interface header
 363                     if (FixMethod(iface->GetHeader(), &m, &tmp))
 364                     {
 365                         wxLogMessage("Adjusted attributes of '%s' method", m.GetAsString());
 366                     }
 367
 368                     proceed = false;
 369                     break;
 370                 }
 371 #endif // HACK_TO_AUTO_CORRECT_ONLY_METHOD_ATTRIBUTES
 372
 373             if (proceed)
 374             {
 375                 if (overloads.GetCount()==0)
 376                 {
 377                     wxLogMessage("%s: real '%s' class and their parents have no method '%s'",
 378                                 header, api->GetName(), m.GetAsString());
 379                     // we've found no overloads
 380                 }
 381                 else
 382                 {
 383                     // first, output a warning
 384                     wxString warning = header;
 385                     if (overloads.GetCount()>1)
 386                         warning += wxString::Format(": in the real headers there are %d overloads of '%s' for "
 387                                                     "'%s' all with different signatures:\n",
 388                                                     overloads.GetCount(), m.GetName(), api->GetName());
 389                     else {
 390                         warning += wxString::Format(": in the real headers there is a method '%s' for '%s'"
 391                                                     " but has different signature:\n",
 392                                                     m.GetName(), api->GetName());
 393                     }
 394
 395                     // get a list of the prototypes with _all_ possible attributes:
 396                     warning += "\tdoxy header: " + m.GetAsString(true, true, true, true);
 397                     for (unsigned int j=0; j<overloads.GetCount(); j++)
 398                         warning += "\n\treal header: " + overloads[j]->GetAsString(true, true, true, true);
 399
 400                     wxLogWarning("%s", warning);
 401                     count++;
 402
 403                     if (overloads.GetCount()>1)
 404                     {
 405                         // TODO: decide which of these overloads is the most "similar" to m
 406                         //       and eventually modify it
 407                         if (m_modify)
 408                         {
 409                             wxLogWarning("\tmanual fix is required");
 410                         }
 411                     }
 412                     else
 413                     {
 414                         wxASSERT(overloads.GetCount() == 1);
 415
 416                         if (m_modify || m.IsCtor())
 417                         {
 418                             wxLogWarning("\tfixing it...");
 419
 420                             // try to modify it!
 421                             FixMethod(iface->GetHeader(), &m, overloads[0]);
 422                         }
 423                     }
 424                 }
 425
 426                 count++;
 427             }       // if (proceed)
 428         }
 429     }
 430
 431     return count;
 432 }
 433
 434 bool IfaceCheckApp::StringContainsMethodName(const wxString& str, const wxMethod* m)
 435 {
 436     return str.Contains(m->GetName()) ||
 437            (m->IsOperator() && str.Contains("operator"));
 438 }
 439
 440 bool IfaceCheckApp::FixMethod(const wxString& header, const wxMethod* iface, const wxMethod* api)
 441 {
 442     unsigned int i,j;
 443     wxASSERT(iface && api);
 444
 445     wxTextFile file;
 446     if (!file.Open(header)) {
 447         wxLogError("\tcan't open the '%s' header file.", header);
 448         return false;
 449     }
 450
 451     // GetLocation() returns the line where the last part of the prototype is placed;
 452     // i.e. the line containing the semicolon at the end of the declaration.
 453     int end = iface->GetLocation()-1;
 454     if (end <= 0 || end >= (int)file.GetLineCount()) {
 455         wxLogWarning("\tinvalid location info for method '%s': %d.",
 456                    iface->GetAsString(), iface->GetLocation());
 457         return false;
 458     }
 459
 460     if (!file.GetLine(end).Contains(";")) {
 461         wxLogWarning("\tinvalid location info for method '%s': %d.",
 462                    iface->GetAsString(), iface->GetLocation());
 463         return false;
 464     }
 465
 466     // is this a one-line prototype declaration?
 467     bool founddecl = false;
 468     int start;
 469     if (StringContainsMethodName(file.GetLine(end), iface))
 470     {
 471         // yes, this prototype is all on this line:
 472         start = end;
 473         founddecl = true;
 474     }
 475     else
 476     {
 477         start = end;    // will be decremented inside the while{} loop below
 478
 479         // find the start point of this prototype declaration; i.e. the line
 480         // containing the function name, which is also the line following
 481         // the marker '*/' for the closure of the doxygen comment
 482         do
 483         {
 484             start--;        // go up one line
 485
 486             if (StringContainsMethodName(file.GetLine(start), iface))
 487                 founddecl = true;
 488         }
 489         while (start > 0 && !founddecl &&
 490                !file.GetLine(start).Contains(";") &&
 491                !file.GetLine(start).Contains("*/"));
 492     }
 493
 494     if (start <= 0 || !founddecl)
 495     {
 496         wxLogError("\tcan't find the beginning of the declaration of '%s' method in '%s' header looking backwards from line %d; I arrived at %d and gave up",
 497                  iface->GetAsString(), header, end+1 /* zero-based => 1-based */, start);
 498         return false;
 499     }
 500
 501     // remove the old prototype
 502     for (int k=start; k<=end; k++)
 503         file.RemoveLine(start);     // remove (end-start)-nth times the start-th line
 504
 505 #define INDENTATION_STR  wxString("    ")
 506
 507     // if possible, add also the @deprecated tag in the doxygen comment if it's missing
 508     int deprecationOffset = 0;
 509     if (file.GetLine(start-1).Contains("*/") &&
 510         (api->IsDeprecated() && !iface->IsDeprecated()))
 511     {
 512         file.RemoveLine(start-1);
 513         file.InsertLine(INDENTATION_STR + INDENTATION_STR +
 514                         "@deprecated @todo provide deprecation description", start-1);
 515         file.InsertLine(INDENTATION_STR + "*/", start++);
 516
 517         // we have added a new line in the final balance
 518         deprecationOffset=1;
 519     }
 520
 521     wxMethod tmp(*api);
 522
 523     // discard gcc XML argument names and replace them with those parsed from doxygen XML;
 524     // in this way we should avoid introducing doxygen warnings about cases where the argument
 525     // 'xx' of the prototype is called 'yy' in the function's docs.
 526     const wxArgumentTypeArray& doxygenargs = iface->GetArgumentTypes();
 527     const wxArgumentTypeArray& realargs = api->GetArgumentTypes();
 528     if (realargs.GetCount() == doxygenargs.GetCount())
 529     {
 530         for (j=0; j<doxygenargs.GetCount(); j++)
 531             if (doxygenargs[j]==realargs[j])
 532             {
 533                 realargs[j].SetArgumentName(doxygenargs[j].GetArgumentName());
 534
 535                 if (realargs[j].GetDefaultValue().IsNumber() &&
 536                     doxygenargs[j].GetDefaultValue().StartsWith("wx"))
 537                     realargs[j].SetDefaultValue(doxygenargs[j].GetDefaultValue());
 538             }
 539
 540         tmp.SetArgumentTypes(realargs);
 541     }
 542
 543 #define WRAP_COLUMN     80
 544
 545     wxArrayString toinsert;
 546     toinsert.Add(INDENTATION_STR + tmp.GetAsString() + ";");
 547
 548     int nStartColumn = toinsert[0].Find('(');
 549     wxASSERT(nStartColumn != wxNOT_FOUND);
 550
 551     // wrap lines too long at comma boundaries
 552     for (i=0; i<toinsert.GetCount(); i++)
 553     {
 554         size_t len = toinsert[i].Len();
 555         if (len > WRAP_COLUMN)
 556         {
 557             wxASSERT(i == toinsert.GetCount()-1);
 558
 559             // break this line
 560             wxString tmpleft = toinsert[i].Left(WRAP_COLUMN);
 561             int comma = tmpleft.Find(',', true /* from end */);
 562             if (comma == wxNOT_FOUND)
 563                 break;     // break out of the for cycle...
 564
 565             toinsert.Add(wxString(' ', nStartColumn+1) +
 566                          toinsert[i].Right(len-comma-2));   // exclude the comma and the space after it
 567             toinsert[i] = tmpleft.Left(comma+1);            // include the comma
 568         }
 569     }
 570
 571     // insert the new lines
 572     for (i=0; i<toinsert.GetCount(); i++)
 573         file.InsertLine(toinsert[i], start+i);
 574
 575     // now save the modification
 576     if (!file.Write()) {
 577         wxLogError("\tcan't save the '%s' header file.", header);
 578         return false;
 579     }
 580
 581     // how many lines did we add/remove in total?
 582     int nOffset = toinsert.GetCount() + deprecationOffset - (end-start+1);
 583     if (nOffset == 0)
 584         return false;
 585
 586     if (g_verbose)
 587     {
 588         wxLogMessage("\tthe final row offset for following methods is %d lines.", nOffset);
 589     }
 590
 591     // update the other method's locations for those methods which belong to the modified header
 592     // and are placed _below_ the modified method
 593     wxClassPtrArray cToUpdate = m_doxyInterface.FindClassesDefinedIn(header);
 594     for (i=0; i < cToUpdate.GetCount(); i++)
 595     {
 596         for (j=0; j < cToUpdate[i]->GetMethodCount(); j++)
 597         {
 598             wxMethod& m = cToUpdate[i]->GetMethod(j);
 599             if (m.GetLocation() > iface->GetLocation())
 600             {
 601                 // update the location of this method
 602                 m.SetLocation(m.GetLocation()+nOffset);
 603             }
 604         }
 605     }
 606
 607     return true;
 608 }
 609
 610 bool IfaceCheckApp::ParsePreprocessorOutput(const wxString& filename)
 611 {
 612     wxTextFile tf;
 613     if (!tf.Open(filename)) {
 614         wxLogError("can't open the '%s' preprocessor output file.", filename);
 615         return false;
 616     }
 617
 618     size_t useful = 0;
 619     for (unsigned int i=0; i < tf.GetLineCount(); i++)
 620     {
 621         const wxString& line = tf.GetLine(i);
 622         wxString defnameval = line.Mid(8);     // what follows the "#define " string
 623
 624         // the format of this line should be:
 625         //    #define DEFNAME DEFVALUE
 626         if (!line.StartsWith("#define ")) {
 627             wxLogError("unexpected content in '%s' at line %d.", filename, i+1);
 628             return false;
 629         }
 630
 631         if (defnameval.Contains(" "))
 632         {
 633             // get DEFNAME
 634             wxString defname = defnameval.BeforeFirst(' ');
 635             if (defname.Contains("("))
 636                 continue;       // this is a macro, skip it!
 637
 638             // get DEFVAL
 639             wxString defval = defnameval.AfterFirst(' ').Strip(wxString::both);
 640             if (defval.StartsWith("(") && defval.EndsWith(")"))
 641                 defval = defval.Mid(1, defval.Len()-2);
 642
 643             // store this pair in the doxygen interface, where it can be useful
 644             m_doxyInterface.AddPreprocessorValue(defname, defval);
 645             useful++;
 646         }
 647         else
 648         {
 649             // it looks like the format of this line is:
 650             //    #define DEFNAME
 651             // we are not interested to symbols #defined to nothing,
 652             // so we just ignore this line.
 653         }
 654     }
 655
 656     wxLogMessage("Parsed %d preprocessor #defines from '%s' which will be used later...",
 657                useful, filename);
 658
 659     return true;
 660 }
 661
 662 void IfaceCheckApp::PrintStatistics(long secs)
 663 {
 664     // these stats, for what regards the gcc XML, are all referred to the wxWidgets
 665     // classes only!
 666
 667     wxLogMessage("wx real headers contains declaration of %d classes (%d methods)",
 668                m_gccInterface.GetClassesCount(), m_gccInterface.GetMethodCount());
 669     wxLogMessage("wx interface headers contains declaration of %d classes (%d methods)",
 670                m_doxyInterface.GetClassesCount(), m_doxyInterface.GetMethodCount());
 671
 672     // build a list of the undocumented wx classes
 673     wxString list;
 674     int undoc = 0;
 675     const wxClassArray& arr = m_gccInterface.GetClasses();
 676     for (unsigned int i=0; i<arr.GetCount(); i++) {
 677         if (m_doxyInterface.FindClass(arr[i].GetName()) == NULL) {
 678             list += arr[i].GetName() + ", ";
 679             undoc++;
 680         }
 681     }
 682
 683     list.RemoveLast();
 684     list.RemoveLast();
 685
 686     wxLogMessage("the list of the %d undocumented wx classes is: %s", undoc, list);
 687     wxLogMessage("total processing took %d seconds.", secs);
 688 }
 689