CMakeLua/Source/CTest/cmCTestBuildHandler.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmCTestBuildHandler.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2008/01/30 16:17:36 $
   7   Version:   $Revision: 1.61 $
   8
   9   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  10   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
  11
  12      This software is distributed WITHOUT ANY WARRANTY; without even
  13      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14      PURPOSE.  See the above copyright notices for more information.
  15
  16 =========================================================================*/
  17
  18 #include "cmCTestBuildHandler.h"
  19
  20 #include "cmCTest.h"
  21 #include "cmake.h"
  22 #include "cmMakefile.h"
  23 #include "cmLocalGenerator.h"
  24 #include "cmGlobalGenerator.h"
  25 #include "cmGeneratedFileStream.h"
  26
  27 //#include <cmsys/RegularExpression.hxx>
  28 #include <cmsys/Process.h>
  29
  30 // used for sleep
  31 #ifdef _WIN32
  32 #include "windows.h"
  33 #endif
  34
  35 #include <stdlib.h>
  36 #include <time.h>
  37 #include <math.h>
  38 #include <float.h>
  39
  40 #if defined(__BORLANDC__)
  41 # pragma warn -8060 /* possibly incorrect assignment */
  42 #endif
  43
  44 static const char* cmCTestErrorMatches[] = {
  45   "^[Bb]us [Ee]rror",
  46   "^[Ss]egmentation [Vv]iolation",
  47   "^[Ss]egmentation [Ff]ault",
  48   "([^ :]+):([0-9]+): ([^ \\t])",
  49   "([^:]+): error[ \\t]*[0-9]+[ \\t]*:",
  50   "^Error ([0-9]+):",
  51   "^Fatal",
  52   "^Error: ",
  53   "^Error ",
  54   "[0-9] ERROR: ",
  55   "^\"[^\"]+\", line [0-9]+: [^Ww]",
  56   "^cc[^C]*CC: ERROR File = ([^,]+), Line = ([0-9]+)",
  57   "^ld([^:])*:([ \\t])*ERROR([^:])*:",
  58   "^ild:([ \\t])*\\(undefined symbol\\)",
  59   "([^ :]+) : (error|fatal error|catastrophic error)",
  60   "([^:]+): (Error:|error|undefined reference|multiply defined)",
  61   "([^:]+)\\(([^\\)]+)\\) : (error|fatal error|catastrophic error)",
  62   "^fatal error C[0-9]+:",
  63   ": syntax error ",
  64   "^collect2: ld returned 1 exit status",
  65   "Unsatisfied symbols:",
  66   "^Unresolved:",
  67   "Undefined symbols:",
  68   "^Undefined[ \\t]+first referenced",
  69   "^CMake Error:",
  70   ":[ \\t]cannot find",
  71   ":[ \\t]can't find",
  72   ": \\*\\*\\* No rule to make target \\`.*\\'.  Stop",
  73   ": \\*\\*\\* No targets specified and no makefile found",
  74   ": Invalid loader fixup for symbol",
  75   ": Invalid fixups exist",
  76   ": Can't find library for",
  77   ": internal link edit command failed",
  78   ": Unrecognized option \\`.*\\'",
  79   "\", line [0-9]+\\.[0-9]+: [0-9]+-[0-9]+ \\([^WI]\\)",
  80   "ld: 0706-006 Cannot find or open library file: -l ",
  81   "ild: \\(argument error\\) can't find library argument ::",
  82   "^could not be found and will not be loaded.",
  83   "s:616 string too big",
  84   "make: Fatal error: ",
  85   "ld: 0711-993 Error occurred while writing to the output file:",
  86   "ld: fatal: ",
  87   "final link failed:",
  88   "make: \\*\\*\\*.*Error",
  89   "make\\[.*\\]: \\*\\*\\*.*Error",
  90   "\\*\\*\\* Error code",
  91   "nternal error:",
  92   "Makefile:[0-9]+: \\*\\*\\* .*  Stop\\.",
  93   ": No such file or directory",
  94   ": Invalid argument",
  95   "^The project cannot be built\\.",
  96   0
  97 };
  98
  99 static const char* cmCTestErrorExceptions[] = {
 100   "instantiated from ",
 101   "candidates are:",
 102   ": warning",
 103   ": \\(Warning\\)",
 104   ": note",
 105   "makefile:",
 106   "Makefile:",
 107   ":[ \\t]+Where:",
 108   "([^ :]+):([0-9]+): Warning",
 109   "------ Build started: .* ------",
 110   0
 111 };
 112
 113 static const char* cmCTestWarningMatches[] = {
 114   "([^ :]+):([0-9]+): warning:",
 115   "([^ :]+):([0-9]+): note:",
 116   "^cc[^C]*CC: WARNING File = ([^,]+), Line = ([0-9]+)",
 117   "^ld([^:])*:([ \\t])*WARNING([^:])*:",
 118   "([^:]+): warning ([0-9]+):",
 119   "^\"[^\"]+\", line [0-9]+: [Ww](arning|arnung)",
 120   "([^:]+): warning[ \\t]*[0-9]+[ \\t]*:",
 121   "^(Warning|Warnung) ([0-9]+):",
 122   "^(Warning|Warnung) ",
 123   "WARNING: ",
 124   "([^ :]+) : warning",
 125   "([^:]+): warning",
 126   "\", line [0-9]+\\.[0-9]+: [0-9]+-[0-9]+ \\([WI]\\)",
 127   "^cxx: Warning:",
 128   ".*file: .* has no symbols",
 129   "([^ :]+):([0-9]+): (Warning|Warnung)",
 130   "\\([0-9]*\\): remark #[0-9]*",
 131   "\".*\", line [0-9]+: remark\\([0-9]*\\):",
 132   "cc-[0-9]* CC: REMARK File = .*, Line = [0-9]*",
 133   0
 134 };
 135
 136 static const char* cmCTestWarningExceptions[] = {
 137   "/usr/.*/X11/Xlib\\.h:[0-9]+: war.*: ANSI C\\+\\+ forbids declaration",
 138   "/usr/.*/X11/Xutil\\.h:[0-9]+: war.*: ANSI C\\+\\+ forbids declaration",
 139   "/usr/.*/X11/XResource\\.h:[0-9]+: war.*: ANSI C\\+\\+ forbids declaration",
 140   "WARNING 84 :",
 141   "WARNING 47 :",
 142   "makefile:",
 143   "Makefile:",
 144   "warning:  Clock skew detected.  Your build may be incomplete.",
 145   "/usr/openwin/include/GL/[^:]+:",
 146   "bind_at_load",
 147   "XrmQGetResource",
 148   "IceFlush",
 149   "warning LNK4089: all references to [^ \\t]+ discarded by .OPT:REF",
 150   "ld32: WARNING 85: definition of dataKey in",
 151   "cc: warning 422: Unknown option \"\\+b",
 152   "_with_warning_C",
 153   0
 154 };
 155
 156 struct cmCTestBuildCompileErrorWarningRex
 157 {
 158   const char* RegularExpressionString;
 159   int FileIndex;
 160   int LineIndex;
 161 };
 162
 163 static cmCTestBuildCompileErrorWarningRex
 164 cmCTestWarningErrorFileLine[] = {
 165     { "^Warning W[0-9]+ ([a-zA-Z.\\:/0-9_+ ~-]+) ([0-9]+):", 1, 2 },
 166     { "^([a-zA-Z./0-9_+ ~-]+):([0-9]+):", 1, 2 },
 167     { "^([a-zA-Z.\\:/0-9_+ ~-]+)\\(([0-9]+)\\)", 1, 2 },
 168     { "^([a-zA-Z./0-9_+ ~-]+)\\(([0-9]+)\\)", 1, 2 },
 169     { "\"([a-zA-Z./0-9_+ ~-]+)\", line ([0-9]+)", 1, 2 },
 170     { "File = ([a-zA-Z./0-9_+ ~-]+), Line = ([0-9]+)", 1, 2 },
 171     { 0, 0, 0 }
 172 };
 173
 174 //----------------------------------------------------------------------
 175 cmCTestBuildHandler::cmCTestBuildHandler()
 176 {
 177   this->MaxPreContext = 6;
 178   this->MaxPostContext = 6;
 179
 180   this->MaxErrors = 50;
 181   this->MaxWarnings = 50;
 182
 183   this->LastErrorOrWarning = this->ErrorsAndWarnings.end();
 184
 185 }
 186
 187 //----------------------------------------------------------------------
 188 void cmCTestBuildHandler::Initialize()
 189 {
 190   this->Superclass::Initialize();
 191   this->StartBuild = "";
 192   this->EndBuild = "";
 193   this->CustomErrorMatches.clear();
 194   this->CustomErrorExceptions.clear();
 195   this->CustomWarningMatches.clear();
 196   this->CustomWarningExceptions.clear();
 197   this->ErrorWarningFileLineRegex.clear();
 198
 199   this->ErrorMatchRegex.clear();
 200   this->ErrorExceptionRegex.clear();
 201   this->WarningMatchRegex.clear();
 202   this->WarningExceptionRegex.clear();
 203   this->BuildProcessingQueue.clear();
 204   this->BuildProcessingErrorQueue.clear();
 205   this->BuildOutputLogSize = 0;
 206   this->CurrentProcessingLine.clear();
 207
 208   this->SimplifySourceDir = "";
 209   this->SimplifyBuildDir = "";
 210   this->OutputLineCounter = 0;
 211   this->ErrorsAndWarnings.clear();
 212   this->LastErrorOrWarning = this->ErrorsAndWarnings.end();
 213   this->PostContextCount = 0;
 214   this->MaxPreContext = 6;
 215   this->MaxPostContext = 6;
 216   this->PreContext.clear();
 217
 218   this->TotalErrors = 0;
 219   this->TotalWarnings = 0;
 220   this->LastTickChar = 0;
 221
 222   this->ErrorQuotaReached = false;
 223   this->WarningQuotaReached = false;
 224
 225   this->MaxErrors = 50;
 226   this->MaxWarnings = 50;
 227 }
 228
 229 //----------------------------------------------------------------------
 230 void cmCTestBuildHandler::PopulateCustomVectors(cmMakefile *mf)
 231 {
 232   this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_ERROR_MATCH",
 233                              this->CustomErrorMatches);
 234   this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_ERROR_EXCEPTION",
 235                              this->CustomErrorExceptions);
 236   this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_WARNING_MATCH",
 237                              this->CustomWarningMatches);
 238   this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_WARNING_EXCEPTION",
 239                              this->CustomWarningExceptions);
 240   this->CTest->PopulateCustomInteger(mf,
 241                           "CTEST_CUSTOM_MAXIMUM_NUMBER_OF_ERRORS",
 242                           this->MaxErrors);
 243   this->CTest->PopulateCustomInteger(mf,
 244                              "CTEST_CUSTOM_MAXIMUM_NUMBER_OF_WARNINGS",
 245                              this->MaxWarnings);
 246 }
 247
 248 //----------------------------------------------------------------------
 249 //clearly it would be nice if this were broken up into a few smaller
 250 //functions and commented...
 251 int cmCTestBuildHandler::ProcessHandler()
 252 {
 253   cmCTestLog(this->CTest, HANDLER_OUTPUT, "Build project" << std::endl);
 254
 255   // do we have time for this
 256   if (this->CTest->GetRemainingTimeAllowed() < 120)
 257     {
 258     return 0;
 259     }
 260
 261   int entry;
 262   for ( entry = 0;
 263     cmCTestWarningErrorFileLine[entry].RegularExpressionString;
 264     ++ entry )
 265     {
 266     cmCTestBuildHandler::cmCTestCompileErrorWarningRex r;
 267     if ( r.RegularExpression.compile(
 268         cmCTestWarningErrorFileLine[entry].RegularExpressionString) )
 269       {
 270       r.FileIndex = cmCTestWarningErrorFileLine[entry].FileIndex;
 271       r.LineIndex = cmCTestWarningErrorFileLine[entry].LineIndex;
 272       this->ErrorWarningFileLineRegex.push_back(r);
 273       }
 274     else
 275       {
 276       cmCTestLog(this->CTest, ERROR_MESSAGE,
 277         "Problem Compiling regular expression: "
 278        << cmCTestWarningErrorFileLine[entry].RegularExpressionString
 279        << std::endl);
 280       }
 281     }
 282
 283   // Determine build command and build directory
 284   const std::string &makeCommand
 285     = this->CTest->GetCTestConfiguration("MakeCommand");
 286   cmCTestLog(this->CTest,
 287              HANDLER_VERBOSE_OUTPUT, "MakeCommand:" << makeCommand <<
 288              "\n");
 289   if ( makeCommand.size() == 0 )
 290     {
 291     cmCTestLog(this->CTest, ERROR_MESSAGE,
 292       "Cannot find MakeCommand key in the DartConfiguration.tcl"
 293       << std::endl);
 294     return -1;
 295     }
 296   const std::string &buildDirectory
 297     = this->CTest->GetCTestConfiguration("BuildDirectory");
 298   if ( buildDirectory.size() == 0 )
 299     {
 300     cmCTestLog(this->CTest, ERROR_MESSAGE,
 301       "Cannot find BuildDirectory  key in the DartConfiguration.tcl"
 302       << std::endl);
 303     return -1;
 304     }
 305
 306   // Create a last build log
 307   cmGeneratedFileStream ofs;
 308   double elapsed_time_start = cmSystemTools::GetTime();
 309   if ( !this->StartLogFile("Build", ofs) )
 310     {
 311     cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot create build log file"
 312       << std::endl);
 313     }
 314
 315   // Create lists of regular expression strings for errors, error exceptions,
 316   // warnings and warning exceptions.
 317   std::vector<cmStdString>::size_type cc;
 318   for ( cc = 0; cmCTestErrorMatches[cc]; cc ++ )
 319     {
 320     this->CustomErrorMatches.push_back(cmCTestErrorMatches[cc]);
 321     }
 322   for ( cc = 0; cmCTestErrorExceptions[cc]; cc ++ )
 323     {
 324     this->CustomErrorExceptions.push_back(cmCTestErrorExceptions[cc]);
 325     }
 326   for ( cc = 0; cmCTestWarningMatches[cc]; cc ++ )
 327     {
 328     this->CustomWarningMatches.push_back(cmCTestWarningMatches[cc]);
 329     }
 330
 331   for ( cc = 0; cmCTestWarningExceptions[cc]; cc ++ )
 332     {
 333     this->CustomWarningExceptions.push_back(cmCTestWarningExceptions[cc]);
 334     }
 335
 336   // Pre-compile regular expressions objects for all regular expressions
 337   std::vector<cmStdString>::iterator it;
 338
 339 #define cmCTestBuildHandlerPopulateRegexVector(strings, regexes) \
 340   regexes.clear(); \
 341     cmCTestLog(this->CTest, DEBUG, this << "Add " #regexes \
 342     << std::endl); \
 343   for ( it = strings.begin(); it != strings.end(); ++it ) \
 344     { \
 345     cmCTestLog(this->CTest, DEBUG, "Add " #strings ": " \
 346     << it->c_str() << std::endl); \
 347     regexes.push_back(it->c_str()); \
 348     }
 349   cmCTestBuildHandlerPopulateRegexVector(
 350     this->CustomErrorMatches, this->ErrorMatchRegex);
 351   cmCTestBuildHandlerPopulateRegexVector(
 352     this->CustomErrorExceptions, this->ErrorExceptionRegex);
 353   cmCTestBuildHandlerPopulateRegexVector(
 354     this->CustomWarningMatches, this->WarningMatchRegex);
 355   cmCTestBuildHandlerPopulateRegexVector(
 356     this->CustomWarningExceptions, this->WarningExceptionRegex);
 357
 358
 359   // Determine source and binary tree substitutions to simplify the output.
 360   this->SimplifySourceDir = "";
 361   this->SimplifyBuildDir = "";
 362   if ( this->CTest->GetCTestConfiguration("SourceDirectory").size() > 20 )
 363     {
 364     std::string srcdir
 365       = this->CTest->GetCTestConfiguration("SourceDirectory") + "/";
 366     std::string srcdirrep;
 367     for ( cc = srcdir.size()-2; cc > 0; cc -- )
 368       {
 369       if ( srcdir[cc] == '/' )
 370         {
 371         srcdirrep = srcdir.c_str() + cc;
 372         srcdirrep = "/..." + srcdirrep;
 373         srcdir = srcdir.substr(0, cc+1);
 374         break;
 375         }
 376       }
 377     this->SimplifySourceDir = srcdir;
 378     }
 379   if ( this->CTest->GetCTestConfiguration("BuildDirectory").size() > 20 )
 380     {
 381     std::string bindir
 382       = this->CTest->GetCTestConfiguration("BuildDirectory") + "/";
 383     std::string bindirrep;
 384     for ( cc = bindir.size()-2; cc > 0; cc -- )
 385       {
 386       if ( bindir[cc] == '/' )
 387         {
 388         bindirrep = bindir.c_str() + cc;
 389         bindirrep = "/..." + bindirrep;
 390         bindir = bindir.substr(0, cc+1);
 391         break;
 392         }
 393       }
 394     this->SimplifyBuildDir = bindir;
 395     }
 396
 397
 398   // Ok, let's do the build
 399
 400   // Remember start build time
 401   this->StartBuild = this->CTest->CurrentTime();
 402   this->StartBuildTime = cmSystemTools::GetTime();
 403   int retVal = 0;
 404   int res = cmsysProcess_State_Exited;
 405   if ( !this->CTest->GetShowOnly() )
 406     {
 407     res = this->RunMakeCommand(makeCommand.c_str(), &retVal,
 408       buildDirectory.c_str(), 0, ofs);
 409     }
 410   else
 411     {
 412     cmCTestLog(this->CTest, DEBUG, "Build with command: " << makeCommand
 413       << std::endl);
 414     }
 415
 416   // Remember end build time and calculate elapsed time
 417   this->EndBuild = this->CTest->CurrentTime();
 418   this->EndBuildTime = cmSystemTools::GetTime();
 419   double elapsed_build_time = cmSystemTools::GetTime() - elapsed_time_start;
 420   if (res != cmsysProcess_State_Exited || retVal )
 421     {
 422     cmCTestLog(this->CTest, ERROR_MESSAGE, "Error(s) when building project"
 423       << std::endl);
 424     }
 425
 426   // Cleanups strings in the errors and warnings list.
 427   t_ErrorsAndWarningsVector::iterator evit;
 428   if ( !this->SimplifySourceDir.empty() )
 429     {
 430     for ( evit = this->ErrorsAndWarnings.begin();
 431       evit != this->ErrorsAndWarnings.end();
 432       ++ evit )
 433       {
 434       cmSystemTools::ReplaceString(
 435         evit->Text, this->SimplifySourceDir.c_str(), "/.../");
 436       cmSystemTools::ReplaceString(
 437         evit->PreContext, this->SimplifySourceDir.c_str(), "/.../");
 438       cmSystemTools::ReplaceString(
 439         evit->PostContext, this->SimplifySourceDir.c_str(), "/.../");
 440       }
 441     }
 442
 443   if ( !this->SimplifyBuildDir.empty() )
 444     {
 445     for ( evit = this->ErrorsAndWarnings.begin();
 446       evit != this->ErrorsAndWarnings.end();
 447       ++ evit )
 448       {
 449       cmSystemTools::ReplaceString(
 450         evit->Text, this->SimplifyBuildDir.c_str(), "/.../");
 451       cmSystemTools::ReplaceString(
 452         evit->PreContext, this->SimplifyBuildDir.c_str(), "/.../");
 453       cmSystemTools::ReplaceString(
 454         evit->PostContext, this->SimplifyBuildDir.c_str(), "/.../");
 455       }
 456     }
 457
 458   // Display message about number of errors and warnings
 459   cmCTestLog(this->CTest, HANDLER_OUTPUT, "   " << this->TotalErrors
 460     << (this->TotalErrors >= this->MaxErrors ? " or more" : "")
 461     << " Compiler errors" << std::endl);
 462   cmCTestLog(this->CTest, HANDLER_OUTPUT, "   " << this->TotalWarnings
 463     << (this->TotalWarnings >= this->MaxWarnings ? " or more" : "")
 464     << " Compiler warnings" << std::endl);
 465
 466   // Generate XML output
 467   cmGeneratedFileStream xofs;
 468   if( !this->StartResultingXML("Build", xofs))
 469     {
 470     cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot create build XML file"
 471       << std::endl);
 472     return -1;
 473     }
 474   this->GenerateDartBuildOutput(
 475     xofs, this->ErrorsAndWarnings, elapsed_build_time);
 476   return 0;
 477 }
 478
 479 //----------------------------------------------------------------------
 480 void cmCTestBuildHandler::GenerateDartBuildOutput(
 481   std::ostream& os,
 482   std::vector<cmCTestBuildErrorWarning> ew,
 483   double elapsed_build_time)
 484 {
 485   this->CTest->StartXML(os);
 486   os << "<Build>\n"
 487      << "\t<StartDateTime>" << this->StartBuild << "</StartDateTime>\n"
 488      << "\t<StartBuildTime>" <<
 489     static_cast<unsigned int>(this->StartBuildTime)
 490      << "</StartBuildTime>\n"
 491      << "<BuildCommand>"
 492      << this->CTest->MakeXMLSafe(
 493        this->CTest->GetCTestConfiguration("MakeCommand"))
 494      << "</BuildCommand>" << std::endl;
 495
 496   std::vector<cmCTestBuildErrorWarning>::iterator it;
 497
 498   // only report the first 50 warnings and first 50 errors
 499   unsigned short numErrorsAllowed = this->MaxErrors;
 500   unsigned short numWarningsAllowed = this->MaxWarnings;
 501   std::string srcdir = this->CTest->GetCTestConfiguration("SourceDirectory");
 502   // make sure the source dir is in the correct case on windows
 503   // via a call to collapse full path.
 504   srcdir = cmSystemTools::CollapseFullPath(srcdir.c_str());
 505   srcdir += "/";
 506   for ( it = ew.begin();
 507         it != ew.end() && (numErrorsAllowed || numWarningsAllowed); it++ )
 508     {
 509     cmCTestBuildErrorWarning *cm = &(*it);
 510     if (cm->Error && numErrorsAllowed ||
 511         !cm->Error && numWarningsAllowed)
 512       {
 513       if (cm->Error)
 514         {
 515         numErrorsAllowed--;
 516         }
 517       else
 518         {
 519         numWarningsAllowed--;
 520         }
 521       os << "\t<" << (cm->Error ? "Error" : "Warning") << ">\n"
 522          << "\t\t<BuildLogLine>" << cm->LogLine << "</BuildLogLine>\n"
 523          << "\t\t<Text>" << this->CTest->MakeXMLSafe(cm->Text)
 524          << "\n</Text>" << std::endl;
 525       std::vector<cmCTestCompileErrorWarningRex>::iterator rit;
 526       for ( rit = this->ErrorWarningFileLineRegex.begin();
 527             rit != this->ErrorWarningFileLineRegex.end(); ++ rit )
 528         {
 529         cmsys::RegularExpression* re = &rit->RegularExpression;
 530         if ( re->find(cm->Text.c_str() ) )
 531           {
 532           cm->SourceFile = re->match(rit->FileIndex);
 533           // At this point we need to make this->SourceFile relative to
 534           // the source root of the project, so cvs links will work
 535           cmSystemTools::ConvertToUnixSlashes(cm->SourceFile);
 536           if(cm->SourceFile.find("/.../") != cm->SourceFile.npos)
 537             {
 538             cmSystemTools::ReplaceString(cm->SourceFile, "/.../", "");
 539             std::string::size_type p = cm->SourceFile.find("/");
 540             if(p != cm->SourceFile.npos)
 541               {
 542               cm->SourceFile = cm->SourceFile.substr(
 543                 p+1, cm->SourceFile.size()-p);
 544               }
 545             }
 546           else
 547             {
 548             // make sure it is a full path with the correct case
 549             cm->SourceFile = cmSystemTools::CollapseFullPath(
 550               cm->SourceFile.c_str());
 551             cmSystemTools::ReplaceString(
 552               cm->SourceFile, srcdir.c_str(), "");
 553             }
 554           cm->LineNumber = atoi(re->match(rit->LineIndex).c_str());
 555           break;
 556           }
 557         }
 558       if ( !cm->SourceFile.empty() && cm->LineNumber >= 0 )
 559         {
 560         if ( cm->SourceFile.size() > 0 )
 561           {
 562           os << "\t\t<SourceFile>" << cm->SourceFile << "</SourceFile>"
 563             << std::endl;
 564           }
 565         if ( cm->SourceFileTail.size() > 0 )
 566           {
 567           os << "\t\t<SourceFileTail>" << cm->SourceFileTail
 568             << "</SourceFileTail>" << std::endl;
 569           }
 570         if ( cm->LineNumber >= 0 )
 571           {
 572           os << "\t\t<SourceLineNumber>" << cm->LineNumber
 573             << "</SourceLineNumber>" << std::endl;
 574           }
 575         }
 576       os << "\t\t<PreContext>" << this->CTest->MakeXMLSafe(cm->PreContext)
 577          << "</PreContext>\n"
 578          << "\t\t<PostContext>" << this->CTest->MakeXMLSafe(cm->PostContext);
 579       // is this the last warning or error, if so notify
 580       if (cm->Error && !numErrorsAllowed ||
 581           !cm->Error && !numWarningsAllowed)
 582         {
 583         os << "\nThe maximum number of reported warnings or errors has been "
 584           "reached!!!\n";
 585         }
 586       os << "</PostContext>\n"
 587          << "\t\t<RepeatCount>0</RepeatCount>\n"
 588          << "</" << (cm->Error ? "Error" : "Warning") << ">\n\n"
 589          << std::endl;
 590       }
 591     }
 592   os << "\t<Log Encoding=\"base64\" Compression=\"/bin/gzip\">\n\t</Log>\n"
 593      << "\t<EndDateTime>" << this->EndBuild << "</EndDateTime>\n"
 594      << "\t<EndBuildTime>" << static_cast<unsigned int>(this->EndBuildTime)
 595      << "</EndBuildTime>\n"
 596      << "<ElapsedMinutes>" << static_cast<int>(elapsed_build_time/6)/10.0
 597      << "</ElapsedMinutes>"
 598      << "</Build>" << std::endl;
 599   this->CTest->EndXML(os);
 600 }
 601
 602 //######################################################################
 603 //######################################################################
 604 //######################################################################
 605 //######################################################################
 606
 607 //----------------------------------------------------------------------
 608 int cmCTestBuildHandler::RunMakeCommand(const char* command,
 609   int* retVal, const char* dir, int timeout, std::ofstream& ofs)
 610 {
 611   // First generate the command and arguments
 612   std::vector<cmStdString> args = cmSystemTools::ParseArguments(command);
 613
 614   if(args.size() < 1)
 615     {
 616     return false;
 617     }
 618
 619   std::vector<const char*> argv;
 620   for(std::vector<cmStdString>::const_iterator a = args.begin();
 621     a != args.end(); ++a)
 622     {
 623     argv.push_back(a->c_str());
 624     }
 625   argv.push_back(0);
 626
 627   cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Run command:");
 628   std::vector<const char*>::iterator ait;
 629   for ( ait = argv.begin(); ait != argv.end() && *ait; ++ ait )
 630     {
 631     cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, " \"" << *ait << "\"");
 632     }
 633   cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl);
 634
 635   // Now create process object
 636   cmsysProcess* cp = cmsysProcess_New();
 637   cmsysProcess_SetCommand(cp, &*argv.begin());
 638   cmsysProcess_SetWorkingDirectory(cp, dir);
 639   cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
 640   cmsysProcess_SetTimeout(cp, timeout);
 641   cmsysProcess_Execute(cp);
 642
 643   // Initialize tick's
 644   std::string::size_type tick = 0;
 645   const std::string::size_type tick_len = 1024;
 646
 647   char* data;
 648   int length;
 649   cmCTestLog(this->CTest, HANDLER_OUTPUT,
 650     "   Each symbol represents " << tick_len << " bytes of output."
 651     << std::endl
 652     << "   '!' represents an error and '*' a warning." << std::endl
 653     << "    " << std::flush);
 654
 655   // Initialize building structures
 656   this->BuildProcessingQueue.clear();
 657   this->OutputLineCounter = 0;
 658   this->ErrorsAndWarnings.clear();
 659   this->TotalErrors = 0;
 660   this->TotalWarnings = 0;
 661   this->BuildOutputLogSize = 0;
 662   this->LastTickChar = '.';
 663   this->WarningQuotaReached = false;
 664   this->ErrorQuotaReached = false;
 665
 666   // For every chunk of data
 667   int res;
 668   while((res = cmsysProcess_WaitForData(cp, &data, &length, 0)))
 669     {
 670     // Replace '\0' with '\n', since '\0' does not really make sense. This is
 671     // for Visual Studio output
 672     for(int cc =0; cc < length; ++cc)
 673       {
 674       if(data[cc] == 0)
 675         {
 676         data[cc] = '\n';
 677         }
 678       }
 679
 680     // Process the chunk of data
 681     if ( res == cmsysProcess_Pipe_STDERR )
 682       {
 683       this->ProcessBuffer(data, length, tick, tick_len, ofs,
 684         &this->BuildProcessingErrorQueue);
 685       }
 686     else
 687       {
 688       this->ProcessBuffer(data, length, tick, tick_len, ofs,
 689         &this->BuildProcessingQueue);
 690       }
 691     }
 692
 693   this->ProcessBuffer(0, 0, tick, tick_len, ofs, &this->BuildProcessingQueue);
 694   this->ProcessBuffer(0, 0, tick, tick_len, ofs,
 695     &this->BuildProcessingErrorQueue);
 696   cmCTestLog(this->CTest, OUTPUT, " Size of output: "
 697     << int(this->BuildOutputLogSize / 1024.0) << "K" << std::endl);
 698
 699   // Properly handle output of the build command
 700   cmsysProcess_WaitForExit(cp, 0);
 701   int result = cmsysProcess_GetState(cp);
 702
 703   if(result == cmsysProcess_State_Exited)
 704     {
 705     if (retVal)
 706       {
 707       *retVal = cmsysProcess_GetExitValue(cp);
 708       cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
 709       "Command exited with the value: " << *retVal << std::endl);
 710       // if a non zero return value
 711       if (*retVal)
 712         {
 713         // If there was an error running command, report that on the
 714         // dashboard.
 715         cmCTestBuildErrorWarning errorwarning;
 716         errorwarning.LogLine     = 1;
 717         errorwarning.Text
 718           = "*** WARNING non-zero return value in ctest from: ";
 719         errorwarning.Text        += argv[0];
 720         errorwarning.PreContext  = "";
 721         errorwarning.PostContext = "";
 722         errorwarning.Error       = false;
 723         this->ErrorsAndWarnings.push_back(errorwarning);
 724         this->TotalWarnings ++;
 725         }
 726       }
 727     }
 728   else if(result == cmsysProcess_State_Exception)
 729     {
 730     if (retVal)
 731       {
 732       *retVal = cmsysProcess_GetExitException(cp);
 733       cmCTestLog(this->CTest, WARNING, "There was an exception: " << *retVal
 734                  << std::endl);
 735       }
 736     }
 737   else if(result == cmsysProcess_State_Expired)
 738     {
 739     cmCTestLog(this->CTest, WARNING, "There was a timeout" << std::endl);
 740     }
 741   else if(result == cmsysProcess_State_Error)
 742     {
 743     // If there was an error running command, report that on the dashboard.
 744     cmCTestBuildErrorWarning errorwarning;
 745     errorwarning.LogLine     = 1;
 746     errorwarning.Text        = "*** ERROR executing: ";
 747     errorwarning.Text        += cmsysProcess_GetErrorString(cp);
 748     errorwarning.PreContext  = "";
 749     errorwarning.PostContext = "";
 750     errorwarning.Error       = true;
 751     this->ErrorsAndWarnings.push_back(errorwarning);
 752     this->TotalErrors ++;
 753     cmCTestLog(this->CTest, ERROR_MESSAGE, "There was an error: "
 754       << cmsysProcess_GetErrorString(cp) << std::endl);
 755     }
 756
 757   cmsysProcess_Delete(cp);
 758
 759   return result;
 760 }
 761
 762 //######################################################################
 763 //######################################################################
 764 //######################################################################
 765 //######################################################################
 766
 767 //----------------------------------------------------------------------
 768 void cmCTestBuildHandler::ProcessBuffer(const char* data, int length,
 769   size_t& tick, size_t tick_len, std::ofstream& ofs,
 770   t_BuildProcessingQueueType* queue)
 771 {
 772   const std::string::size_type tick_line_len = 50;
 773   const char* ptr;
 774   for ( ptr = data; ptr < data+length; ptr ++ )
 775     {
 776     queue->push_back(*ptr);
 777     }
 778   this->BuildOutputLogSize += length;
 779
 780   // until there are any lines left in the buffer
 781   while ( 1 )
 782     {
 783     // Find the end of line
 784     t_BuildProcessingQueueType::iterator it;
 785     for ( it = queue->begin();
 786       it != queue->end();
 787       ++ it )
 788       {
 789       if ( *it == '\n' )
 790         {
 791         break;
 792         }
 793       }
 794
 795     // Once certain number of errors or warnings reached, ignore future errors
 796     // or warnings.
 797     if ( this->TotalWarnings >= this->MaxWarnings )
 798       {
 799       this->WarningQuotaReached = true;
 800       }
 801     if ( this->TotalErrors >= this->MaxErrors )
 802       {
 803       this->ErrorQuotaReached = true;
 804       }
 805
 806     // If the end of line was found
 807     if ( it != queue->end() )
 808       {
 809       // Create a contiguous array for the line
 810       this->CurrentProcessingLine.clear();
 811       t_BuildProcessingQueueType::iterator cit;
 812       for ( cit = queue->begin(); cit != it; ++cit )
 813         {
 814         this->CurrentProcessingLine.push_back(*cit);
 815         }
 816       this->CurrentProcessingLine.push_back(0);
 817       const char* line = &*this->CurrentProcessingLine.begin();
 818
 819       // Process the line
 820       int lineType = this->ProcessSingleLine(line);
 821
 822       // Erase the line from the queue
 823       queue->erase(queue->begin(), it+1);
 824
 825       // Depending on the line type, produce error or warning, or nothing
 826       cmCTestBuildErrorWarning errorwarning;
 827       bool found = false;
 828       switch ( lineType )
 829         {
 830       case b_WARNING_LINE:
 831         this->LastTickChar = '*';
 832         errorwarning.Error = false;
 833         found = true;
 834         this->TotalWarnings ++;
 835         break;
 836       case b_ERROR_LINE:
 837         this->LastTickChar = '!';
 838         errorwarning.Error = true;
 839         found = true;
 840         this->TotalErrors ++;
 841         break;
 842         }
 843       if ( found )
 844         {
 845         // This is an error or warning, so generate report
 846         errorwarning.LogLine   = static_cast<int>(this->OutputLineCounter+1);
 847         errorwarning.Text        = line;
 848         errorwarning.PreContext  = "";
 849         errorwarning.PostContext = "";
 850
 851         // Copy pre-context to report
 852         std::deque<cmStdString>::iterator pcit;
 853         for ( pcit = this->PreContext.begin();
 854           pcit != this->PreContext.end();
 855           ++pcit )
 856           {
 857           errorwarning.PreContext += *pcit + "\n";
 858           }
 859         this->PreContext.clear();
 860
 861         // Store report
 862         this->ErrorsAndWarnings.push_back(errorwarning);
 863         this->LastErrorOrWarning = this->ErrorsAndWarnings.end()-1;
 864         this->PostContextCount = 0;
 865         }
 866       else
 867         {
 868         // This is not an error or warning.
 869         // So, figure out if this is a post-context line
 870         if ( this->ErrorsAndWarnings.size() &&
 871              this->LastErrorOrWarning != this->ErrorsAndWarnings.end() &&
 872              this->PostContextCount < this->MaxPostContext )
 873           {
 874           this->PostContextCount ++;
 875           this->LastErrorOrWarning->PostContext += line;
 876           if ( this->PostContextCount < this->MaxPostContext )
 877             {
 878             this->LastErrorOrWarning->PostContext += "\n";
 879             }
 880           }
 881         else
 882           {
 883           // Otherwise store pre-context for the next error
 884           this->PreContext.push_back(line);
 885           if ( this->PreContext.size() > this->MaxPreContext )
 886             {
 887             this->PreContext.erase(this->PreContext.begin(),
 888               this->PreContext.end()-this->MaxPreContext);
 889             }
 890           }
 891         }
 892       this->OutputLineCounter ++;
 893       }
 894     else
 895       {
 896       break;
 897       }
 898     }
 899
 900   // Now that the buffer is processed, display missing ticks
 901   int tickDisplayed = false;
 902   while ( this->BuildOutputLogSize > (tick * tick_len) )
 903     {
 904     tick ++;
 905     cmCTestLog(this->CTest, HANDLER_OUTPUT, this->LastTickChar);
 906     tickDisplayed = true;
 907     if ( tick % tick_line_len == 0 && tick > 0 )
 908       {
 909       cmCTestLog(this->CTest, HANDLER_OUTPUT, "  Size: "
 910         << int((this->BuildOutputLogSize / 1024.0) + 1) << "K" << std::endl
 911         << "    ");
 912       }
 913     }
 914   if ( tickDisplayed )
 915     {
 916     this->LastTickChar = '.';
 917     }
 918
 919   // And if this is verbose output, display the content of the chunk
 920   cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
 921     cmCTestLogWrite(data, length));
 922
 923   // Always store the chunk to the file
 924   ofs << cmCTestLogWrite(data, length);
 925 }
 926
 927 //----------------------------------------------------------------------
 928 int cmCTestBuildHandler::ProcessSingleLine(const char* data)
 929 {
 930   cmCTestLog(this->CTest, DEBUG, "Line: [" << data << "]" << std::endl);
 931
 932   std::vector<cmsys::RegularExpression>::iterator it;
 933
 934   int warningLine = 0;
 935   int errorLine = 0;
 936
 937   // Check for regular expressions
 938
 939   if ( !this->ErrorQuotaReached )
 940     {
 941     // Errors
 942     int wrxCnt = 0;
 943     for ( it = this->ErrorMatchRegex.begin();
 944       it != this->ErrorMatchRegex.end();
 945       ++ it )
 946       {
 947       if ( it->find(data) )
 948         {
 949         errorLine = 1;
 950         cmCTestLog(this->CTest, DEBUG, "  Error Line: " << data
 951           << " (matches: " << this->CustomErrorMatches[wrxCnt] << ")"
 952           << std::endl);
 953         break;
 954         }
 955       wrxCnt ++;
 956       }
 957     // Error exceptions
 958     wrxCnt = 0;
 959     for ( it = this->ErrorExceptionRegex.begin();
 960       it != this->ErrorExceptionRegex.end();
 961       ++ it )
 962       {
 963       if ( it->find(data) )
 964         {
 965         errorLine = 0;
 966         cmCTestLog(this->CTest, DEBUG, "  Not an error Line: " << data
 967           << " (matches: " << this->CustomErrorExceptions[wrxCnt] << ")"
 968           << std::endl);
 969         break;
 970         }
 971       wrxCnt ++;
 972       }
 973     }
 974   if ( !this->WarningQuotaReached )
 975     {
 976     // Warnings
 977     int wrxCnt = 0;
 978     for ( it = this->WarningMatchRegex.begin();
 979       it != this->WarningMatchRegex.end();
 980       ++ it )
 981       {
 982       if ( it->find(data) )
 983         {
 984         warningLine = 1;
 985         cmCTestLog(this->CTest, DEBUG,
 986           "  Warning Line: " << data
 987           << " (matches: " << this->CustomWarningMatches[wrxCnt] << ")"
 988           << std::endl);
 989         break;
 990         }
 991       wrxCnt ++;
 992       }
 993
 994     wrxCnt = 0;
 995     // Warning exceptions
 996     for ( it = this->WarningExceptionRegex.begin();
 997       it != this->WarningExceptionRegex.end();
 998       ++ it )
 999       {
1000       if ( it->find(data) )
1001         {
1002         warningLine = 0;
1003         cmCTestLog(this->CTest, DEBUG, "  Not a warning Line: " << data
1004           << " (matches: " << this->CustomWarningExceptions[wrxCnt] << ")"
1005           << std::endl);
1006         break;
1007         }
1008       wrxCnt ++;
1009       }
1010     }
1011   if ( errorLine )
1012     {
1013     return b_ERROR_LINE;
1014     }
1015   if ( warningLine )
1016     {
1017     return b_WARNING_LINE;
1018     }
1019   return b_REGULAR_LINE;
1020 }
1021