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: 2007-06-14 17:05:09 $
   7   Version:   $Revision: 1.60 $
   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   int retVal = 0;
 403   int res = cmsysProcess_State_Exited;
 404   if ( !this->CTest->GetShowOnly() )
 405     {
 406     res = this->RunMakeCommand(makeCommand.c_str(), &retVal,
 407       buildDirectory.c_str(), 0, ofs);
 408     }
 409   else
 410     {
 411     cmCTestLog(this->CTest, DEBUG, "Build with command: " << makeCommand
 412       << std::endl);
 413     }
 414
 415   // Remember end build time and calculate elapsed time
 416   this->EndBuild = this->CTest->CurrentTime();
 417   double elapsed_build_time = cmSystemTools::GetTime() - elapsed_time_start;
 418   if (res != cmsysProcess_State_Exited || retVal )
 419     {
 420     cmCTestLog(this->CTest, ERROR_MESSAGE, "Error(s) when building project"
 421       << std::endl);
 422     }
 423
 424   // Cleanups strings in the errors and warnings list.
 425   t_ErrorsAndWarningsVector::iterator evit;
 426   if ( !this->SimplifySourceDir.empty() )
 427     {
 428     for ( evit = this->ErrorsAndWarnings.begin();
 429       evit != this->ErrorsAndWarnings.end();
 430       ++ evit )
 431       {
 432       cmSystemTools::ReplaceString(
 433         evit->Text, this->SimplifySourceDir.c_str(), "/.../");
 434       cmSystemTools::ReplaceString(
 435         evit->PreContext, this->SimplifySourceDir.c_str(), "/.../");
 436       cmSystemTools::ReplaceString(
 437         evit->PostContext, this->SimplifySourceDir.c_str(), "/.../");
 438       }
 439     }
 440
 441   if ( !this->SimplifyBuildDir.empty() )
 442     {
 443     for ( evit = this->ErrorsAndWarnings.begin();
 444       evit != this->ErrorsAndWarnings.end();
 445       ++ evit )
 446       {
 447       cmSystemTools::ReplaceString(
 448         evit->Text, this->SimplifyBuildDir.c_str(), "/.../");
 449       cmSystemTools::ReplaceString(
 450         evit->PreContext, this->SimplifyBuildDir.c_str(), "/.../");
 451       cmSystemTools::ReplaceString(
 452         evit->PostContext, this->SimplifyBuildDir.c_str(), "/.../");
 453       }
 454     }
 455
 456   // Display message about number of errors and warnings
 457   cmCTestLog(this->CTest, HANDLER_OUTPUT, "   " << this->TotalErrors
 458     << (this->TotalErrors >= this->MaxErrors ? " or more" : "")
 459     << " Compiler errors" << std::endl);
 460   cmCTestLog(this->CTest, HANDLER_OUTPUT, "   " << this->TotalWarnings
 461     << (this->TotalWarnings >= this->MaxWarnings ? " or more" : "")
 462     << " Compiler warnings" << std::endl);
 463
 464   // Generate XML output
 465   cmGeneratedFileStream xofs;
 466   if( !this->StartResultingXML("Build", xofs))
 467     {
 468     cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot create build XML file"
 469       << std::endl);
 470     return -1;
 471     }
 472   this->GenerateDartBuildOutput(
 473     xofs, this->ErrorsAndWarnings, elapsed_build_time);
 474   return 0;
 475 }
 476
 477 //----------------------------------------------------------------------
 478 void cmCTestBuildHandler::GenerateDartBuildOutput(
 479   std::ostream& os,
 480   std::vector<cmCTestBuildErrorWarning> ew,
 481   double elapsed_build_time)
 482 {
 483   this->CTest->StartXML(os);
 484   os << "<Build>\n"
 485      << "\t<StartDateTime>" << this->StartBuild << "</StartDateTime>\n"
 486      << "<BuildCommand>"
 487      << this->CTest->MakeXMLSafe(
 488        this->CTest->GetCTestConfiguration("MakeCommand"))
 489      << "</BuildCommand>" << std::endl;
 490
 491   std::vector<cmCTestBuildErrorWarning>::iterator it;
 492
 493   // only report the first 50 warnings and first 50 errors
 494   unsigned short numErrorsAllowed = this->MaxErrors;
 495   unsigned short numWarningsAllowed = this->MaxWarnings;
 496   std::string srcdir = this->CTest->GetCTestConfiguration("SourceDirectory");
 497   // make sure the source dir is in the correct case on windows
 498   // via a call to collapse full path.
 499   srcdir = cmSystemTools::CollapseFullPath(srcdir.c_str());
 500   srcdir += "/";
 501   for ( it = ew.begin();
 502         it != ew.end() && (numErrorsAllowed || numWarningsAllowed); it++ )
 503     {
 504     cmCTestBuildErrorWarning *cm = &(*it);
 505     if (cm->Error && numErrorsAllowed ||
 506         !cm->Error && numWarningsAllowed)
 507       {
 508       if (cm->Error)
 509         {
 510         numErrorsAllowed--;
 511         }
 512       else
 513         {
 514         numWarningsAllowed--;
 515         }
 516       os << "\t<" << (cm->Error ? "Error" : "Warning") << ">\n"
 517          << "\t\t<BuildLogLine>" << cm->LogLine << "</BuildLogLine>\n"
 518          << "\t\t<Text>" << this->CTest->MakeXMLSafe(cm->Text)
 519          << "\n</Text>" << std::endl;
 520       std::vector<cmCTestCompileErrorWarningRex>::iterator rit;
 521       for ( rit = this->ErrorWarningFileLineRegex.begin();
 522             rit != this->ErrorWarningFileLineRegex.end(); ++ rit )
 523         {
 524         cmsys::RegularExpression* re = &rit->RegularExpression;
 525         if ( re->find(cm->Text.c_str() ) )
 526           {
 527           cm->SourceFile = re->match(rit->FileIndex);
 528           // At this point we need to make this->SourceFile relative to
 529           // the source root of the project, so cvs links will work
 530           cmSystemTools::ConvertToUnixSlashes(cm->SourceFile);
 531           if(cm->SourceFile.find("/.../") != cm->SourceFile.npos)
 532             {
 533             cmSystemTools::ReplaceString(cm->SourceFile, "/.../", "");
 534             std::string::size_type p = cm->SourceFile.find("/");
 535             if(p != cm->SourceFile.npos)
 536               {
 537               cm->SourceFile = cm->SourceFile.substr(
 538                 p+1, cm->SourceFile.size()-p);
 539               }
 540             }
 541           else
 542             {
 543             // make sure it is a full path with the correct case
 544             cm->SourceFile = cmSystemTools::CollapseFullPath(
 545               cm->SourceFile.c_str());
 546             cmSystemTools::ReplaceString(
 547               cm->SourceFile, srcdir.c_str(), "");
 548             }
 549           cm->LineNumber = atoi(re->match(rit->LineIndex).c_str());
 550           break;
 551           }
 552         }
 553       if ( !cm->SourceFile.empty() && cm->LineNumber >= 0 )
 554         {
 555         if ( cm->SourceFile.size() > 0 )
 556           {
 557           os << "\t\t<SourceFile>" << cm->SourceFile << "</SourceFile>"
 558             << std::endl;
 559           }
 560         if ( cm->SourceFileTail.size() > 0 )
 561           {
 562           os << "\t\t<SourceFileTail>" << cm->SourceFileTail
 563             << "</SourceFileTail>" << std::endl;
 564           }
 565         if ( cm->LineNumber >= 0 )
 566           {
 567           os << "\t\t<SourceLineNumber>" << cm->LineNumber
 568             << "</SourceLineNumber>" << std::endl;
 569           }
 570         }
 571       os << "\t\t<PreContext>" << this->CTest->MakeXMLSafe(cm->PreContext)
 572          << "</PreContext>\n"
 573          << "\t\t<PostContext>" << this->CTest->MakeXMLSafe(cm->PostContext);
 574       // is this the last warning or error, if so notify
 575       if (cm->Error && !numErrorsAllowed ||
 576           !cm->Error && !numWarningsAllowed)
 577         {
 578         os << "\nThe maximum number of reported warnings or errors has been "
 579           "reached!!!\n";
 580         }
 581       os << "</PostContext>\n"
 582          << "\t\t<RepeatCount>0</RepeatCount>\n"
 583          << "</" << (cm->Error ? "Error" : "Warning") << ">\n\n"
 584          << std::endl;
 585       }
 586     }
 587   os << "\t<Log Encoding=\"base64\" Compression=\"/bin/gzip\">\n\t</Log>\n"
 588      << "\t<EndDateTime>" << this->EndBuild << "</EndDateTime>\n"
 589      << "<ElapsedMinutes>" << static_cast<int>(elapsed_build_time/6)/10.0
 590      << "</ElapsedMinutes>"
 591      << "</Build>" << std::endl;
 592   this->CTest->EndXML(os);
 593 }
 594
 595 //######################################################################
 596 //######################################################################
 597 //######################################################################
 598 //######################################################################
 599
 600 //----------------------------------------------------------------------
 601 int cmCTestBuildHandler::RunMakeCommand(const char* command,
 602   int* retVal, const char* dir, int timeout, std::ofstream& ofs)
 603 {
 604   // First generate the command and arguments
 605   std::vector<cmStdString> args = cmSystemTools::ParseArguments(command);
 606
 607   if(args.size() < 1)
 608     {
 609     return false;
 610     }
 611
 612   std::vector<const char*> argv;
 613   for(std::vector<cmStdString>::const_iterator a = args.begin();
 614     a != args.end(); ++a)
 615     {
 616     argv.push_back(a->c_str());
 617     }
 618   argv.push_back(0);
 619
 620   cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Run command:");
 621   std::vector<const char*>::iterator ait;
 622   for ( ait = argv.begin(); ait != argv.end() && *ait; ++ ait )
 623     {
 624     cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, " \"" << *ait << "\"");
 625     }
 626   cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl);
 627
 628   // Now create process object
 629   cmsysProcess* cp = cmsysProcess_New();
 630   cmsysProcess_SetCommand(cp, &*argv.begin());
 631   cmsysProcess_SetWorkingDirectory(cp, dir);
 632   cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
 633   cmsysProcess_SetTimeout(cp, timeout);
 634   cmsysProcess_Execute(cp);
 635
 636   // Initialize tick's
 637   std::string::size_type tick = 0;
 638   const std::string::size_type tick_len = 1024;
 639
 640   char* data;
 641   int length;
 642   cmCTestLog(this->CTest, HANDLER_OUTPUT,
 643     "   Each symbol represents " << tick_len << " bytes of output."
 644     << std::endl
 645     << "   '!' represents an error and '*' a warning." << std::endl
 646     << "    " << std::flush);
 647
 648   // Initialize building structures
 649   this->BuildProcessingQueue.clear();
 650   this->OutputLineCounter = 0;
 651   this->ErrorsAndWarnings.clear();
 652   this->TotalErrors = 0;
 653   this->TotalWarnings = 0;
 654   this->BuildOutputLogSize = 0;
 655   this->LastTickChar = '.';
 656   this->WarningQuotaReached = false;
 657   this->ErrorQuotaReached = false;
 658
 659   // For every chunk of data
 660   int res;
 661   while((res = cmsysProcess_WaitForData(cp, &data, &length, 0)))
 662     {
 663     // Replace '\0' with '\n', since '\0' does not really make sense. This is
 664     // for Visual Studio output
 665     for(int cc =0; cc < length; ++cc)
 666       {
 667       if(data[cc] == 0)
 668         {
 669         data[cc] = '\n';
 670         }
 671       }
 672
 673     // Process the chunk of data
 674     if ( res == cmsysProcess_Pipe_STDERR )
 675       {
 676       this->ProcessBuffer(data, length, tick, tick_len, ofs,
 677         &this->BuildProcessingErrorQueue);
 678       }
 679     else
 680       {
 681       this->ProcessBuffer(data, length, tick, tick_len, ofs,
 682         &this->BuildProcessingQueue);
 683       }
 684     }
 685
 686   this->ProcessBuffer(0, 0, tick, tick_len, ofs, &this->BuildProcessingQueue);
 687   this->ProcessBuffer(0, 0, tick, tick_len, ofs,
 688     &this->BuildProcessingErrorQueue);
 689   cmCTestLog(this->CTest, OUTPUT, " Size of output: "
 690     << int(this->BuildOutputLogSize / 1024.0) << "K" << std::endl);
 691
 692   // Properly handle output of the build command
 693   cmsysProcess_WaitForExit(cp, 0);
 694   int result = cmsysProcess_GetState(cp);
 695
 696   if(result == cmsysProcess_State_Exited)
 697     {
 698     if (retVal)
 699       {
 700       *retVal = cmsysProcess_GetExitValue(cp);
 701       cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
 702       "Command exited with the value: " << *retVal << std::endl);
 703       // if a non zero return value
 704       if (*retVal)
 705         {
 706         // If there was an error running command, report that on the
 707         // dashboard.
 708         cmCTestBuildErrorWarning errorwarning;
 709         errorwarning.LogLine     = 1;
 710         errorwarning.Text
 711           = "*** WARNING non-zero return value in ctest from: ";
 712         errorwarning.Text        += argv[0];
 713         errorwarning.PreContext  = "";
 714         errorwarning.PostContext = "";
 715         errorwarning.Error       = false;
 716         this->ErrorsAndWarnings.push_back(errorwarning);
 717         this->TotalWarnings ++;
 718         }
 719       }
 720     }
 721   else if(result == cmsysProcess_State_Exception)
 722     {
 723     if (retVal)
 724       {
 725       *retVal = cmsysProcess_GetExitException(cp);
 726       cmCTestLog(this->CTest, WARNING, "There was an exception: " << *retVal
 727                  << std::endl);
 728       }
 729     }
 730   else if(result == cmsysProcess_State_Expired)
 731     {
 732     cmCTestLog(this->CTest, WARNING, "There was a timeout" << std::endl);
 733     }
 734   else if(result == cmsysProcess_State_Error)
 735     {
 736     // If there was an error running command, report that on the dashboard.
 737     cmCTestBuildErrorWarning errorwarning;
 738     errorwarning.LogLine     = 1;
 739     errorwarning.Text        = "*** ERROR executing: ";
 740     errorwarning.Text        += cmsysProcess_GetErrorString(cp);
 741     errorwarning.PreContext  = "";
 742     errorwarning.PostContext = "";
 743     errorwarning.Error       = true;
 744     this->ErrorsAndWarnings.push_back(errorwarning);
 745     this->TotalErrors ++;
 746     cmCTestLog(this->CTest, ERROR_MESSAGE, "There was an error: "
 747       << cmsysProcess_GetErrorString(cp) << std::endl);
 748     }
 749
 750   cmsysProcess_Delete(cp);
 751
 752   return result;
 753 }
 754
 755 //######################################################################
 756 //######################################################################
 757 //######################################################################
 758 //######################################################################
 759
 760 //----------------------------------------------------------------------
 761 void cmCTestBuildHandler::ProcessBuffer(const char* data, int length,
 762   size_t& tick, size_t tick_len, std::ofstream& ofs,
 763   t_BuildProcessingQueueType* queue)
 764 {
 765   const std::string::size_type tick_line_len = 50;
 766   const char* ptr;
 767   for ( ptr = data; ptr < data+length; ptr ++ )
 768     {
 769     queue->push_back(*ptr);
 770     }
 771   this->BuildOutputLogSize += length;
 772
 773   // until there are any lines left in the buffer
 774   while ( 1 )
 775     {
 776     // Find the end of line
 777     t_BuildProcessingQueueType::iterator it;
 778     for ( it = queue->begin();
 779       it != queue->end();
 780       ++ it )
 781       {
 782       if ( *it == '\n' )
 783         {
 784         break;
 785         }
 786       }
 787
 788     // Once certain number of errors or warnings reached, ignore future errors
 789     // or warnings.
 790     if ( this->TotalWarnings >= this->MaxWarnings )
 791       {
 792       this->WarningQuotaReached = true;
 793       }
 794     if ( this->TotalErrors >= this->MaxErrors )
 795       {
 796       this->ErrorQuotaReached = true;
 797       }
 798
 799     // If the end of line was found
 800     if ( it != queue->end() )
 801       {
 802       // Create a contiguous array for the line
 803       this->CurrentProcessingLine.clear();
 804       t_BuildProcessingQueueType::iterator cit;
 805       for ( cit = queue->begin(); cit != it; ++cit )
 806         {
 807         this->CurrentProcessingLine.push_back(*cit);
 808         }
 809       this->CurrentProcessingLine.push_back(0);
 810       const char* line = &*this->CurrentProcessingLine.begin();
 811
 812       // Process the line
 813       int lineType = this->ProcessSingleLine(line);
 814
 815       // Erase the line from the queue
 816       queue->erase(queue->begin(), it+1);
 817
 818       // Depending on the line type, produce error or warning, or nothing
 819       cmCTestBuildErrorWarning errorwarning;
 820       bool found = false;
 821       switch ( lineType )
 822         {
 823       case b_WARNING_LINE:
 824         this->LastTickChar = '*';
 825         errorwarning.Error = false;
 826         found = true;
 827         this->TotalWarnings ++;
 828         break;
 829       case b_ERROR_LINE:
 830         this->LastTickChar = '!';
 831         errorwarning.Error = true;
 832         found = true;
 833         this->TotalErrors ++;
 834         break;
 835         }
 836       if ( found )
 837         {
 838         // This is an error or warning, so generate report
 839         errorwarning.LogLine   = static_cast<int>(this->OutputLineCounter+1);
 840         errorwarning.Text        = line;
 841         errorwarning.PreContext  = "";
 842         errorwarning.PostContext = "";
 843
 844         // Copy pre-context to report
 845         std::deque<cmStdString>::iterator pcit;
 846         for ( pcit = this->PreContext.begin();
 847           pcit != this->PreContext.end();
 848           ++pcit )
 849           {
 850           errorwarning.PreContext += *pcit + "\n";
 851           }
 852         this->PreContext.clear();
 853
 854         // Store report
 855         this->ErrorsAndWarnings.push_back(errorwarning);
 856         this->LastErrorOrWarning = this->ErrorsAndWarnings.end()-1;
 857         this->PostContextCount = 0;
 858         }
 859       else
 860         {
 861         // This is not an error or warning.
 862         // So, figure out if this is a post-context line
 863         if ( this->ErrorsAndWarnings.size() &&
 864              this->LastErrorOrWarning != this->ErrorsAndWarnings.end() &&
 865              this->PostContextCount < this->MaxPostContext )
 866           {
 867           this->PostContextCount ++;
 868           this->LastErrorOrWarning->PostContext += line;
 869           if ( this->PostContextCount < this->MaxPostContext )
 870             {
 871             this->LastErrorOrWarning->PostContext += "\n";
 872             }
 873           }
 874         else
 875           {
 876           // Otherwise store pre-context for the next error
 877           this->PreContext.push_back(line);
 878           if ( this->PreContext.size() > this->MaxPreContext )
 879             {
 880             this->PreContext.erase(this->PreContext.begin(),
 881               this->PreContext.end()-this->MaxPreContext);
 882             }
 883           }
 884         }
 885       this->OutputLineCounter ++;
 886       }
 887     else
 888       {
 889       break;
 890       }
 891     }
 892
 893   // Now that the buffer is processed, display missing ticks
 894   int tickDisplayed = false;
 895   while ( this->BuildOutputLogSize > (tick * tick_len) )
 896     {
 897     tick ++;
 898     cmCTestLog(this->CTest, HANDLER_OUTPUT, this->LastTickChar);
 899     tickDisplayed = true;
 900     if ( tick % tick_line_len == 0 && tick > 0 )
 901       {
 902       cmCTestLog(this->CTest, HANDLER_OUTPUT, "  Size: "
 903         << int((this->BuildOutputLogSize / 1024.0) + 1) << "K" << std::endl
 904         << "    ");
 905       }
 906     }
 907   if ( tickDisplayed )
 908     {
 909     this->LastTickChar = '.';
 910     }
 911
 912   // And if this is verbose output, display the content of the chunk
 913   cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
 914     cmCTestLogWrite(data, length));
 915
 916   // Always store the chunk to the file
 917   ofs << cmCTestLogWrite(data, length);
 918 }
 919
 920 //----------------------------------------------------------------------
 921 int cmCTestBuildHandler::ProcessSingleLine(const char* data)
 922 {
 923   cmCTestLog(this->CTest, DEBUG, "Line: [" << data << "]" << std::endl);
 924
 925   std::vector<cmsys::RegularExpression>::iterator it;
 926
 927   int warningLine = 0;
 928   int errorLine = 0;
 929
 930   // Check for regular expressions
 931
 932   if ( !this->ErrorQuotaReached )
 933     {
 934     // Errors
 935     int wrxCnt = 0;
 936     for ( it = this->ErrorMatchRegex.begin();
 937       it != this->ErrorMatchRegex.end();
 938       ++ it )
 939       {
 940       if ( it->find(data) )
 941         {
 942         errorLine = 1;
 943         cmCTestLog(this->CTest, DEBUG, "  Error Line: " << data
 944           << " (matches: " << this->CustomErrorMatches[wrxCnt] << ")"
 945           << std::endl);
 946         break;
 947         }
 948       wrxCnt ++;
 949       }
 950     // Error exceptions
 951     wrxCnt = 0;
 952     for ( it = this->ErrorExceptionRegex.begin();
 953       it != this->ErrorExceptionRegex.end();
 954       ++ it )
 955       {
 956       if ( it->find(data) )
 957         {
 958         errorLine = 0;
 959         cmCTestLog(this->CTest, DEBUG, "  Not an error Line: " << data
 960           << " (matches: " << this->CustomErrorExceptions[wrxCnt] << ")"
 961           << std::endl);
 962         break;
 963         }
 964       wrxCnt ++;
 965       }
 966     }
 967   if ( !this->WarningQuotaReached )
 968     {
 969     // Warnings
 970     int wrxCnt = 0;
 971     for ( it = this->WarningMatchRegex.begin();
 972       it != this->WarningMatchRegex.end();
 973       ++ it )
 974       {
 975       if ( it->find(data) )
 976         {
 977         warningLine = 1;
 978         cmCTestLog(this->CTest, DEBUG,
 979           "  Warning Line: " << data
 980           << " (matches: " << this->CustomWarningMatches[wrxCnt] << ")"
 981           << std::endl);
 982         break;
 983         }
 984       wrxCnt ++;
 985       }
 986
 987     wrxCnt = 0;
 988     // Warning exceptions
 989     for ( it = this->WarningExceptionRegex.begin();
 990       it != this->WarningExceptionRegex.end();
 991       ++ it )
 992       {
 993       if ( it->find(data) )
 994         {
 995         warningLine = 0;
 996         cmCTestLog(this->CTest, DEBUG, "  Not a warning Line: " << data
 997           << " (matches: " << this->CustomWarningExceptions[wrxCnt] << ")"
 998           << std::endl);
 999         break;
1000         }
1001       wrxCnt ++;
1002       }
1003     }
1004   if ( errorLine )
1005     {
1006     return b_ERROR_LINE;
1007     }
1008   if ( warningLine )
1009     {
1010     return b_WARNING_LINE;
1011     }
1012   return b_REGULAR_LINE;
1013 }
1014