Lubuntu
/
cmake
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '068560fedc'
${ noResults }
cmake/Source/CTest/cmCTestBuildHandler.cxx

1307 lines
40 KiB
Raw Blame History

/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
#include "cmCTestBuildHandler.h"
#include "cmCTest.h"
#include "cmake.h"
#include "cmMakefile.h"
#include "cmLocalGenerator.h"
#include "cmGlobalGenerator.h"
#include "cmGeneratedFileStream.h"
#include "cmXMLSafe.h"
#include "cmFileTimeComparison.h"
//#include <cmsys/RegularExpression.hxx>
#include <cmsys/Process.h>
#include <cmsys/Directory.hxx>
// used for sleep
#ifdef _WIN32
#include "windows.h"
#endif
#include <stdlib.h>
#include <time.h>
#include <math.h>
#include <float.h>
#if defined(__BORLANDC__)
# pragma warn -8060 /* possibly incorrect assignment */
#endif
static const char* cmCTestErrorMatches[] = {
"^[Bb]us [Ee]rror",
"^[Ss]egmentation [Vv]iolation",
"^[Ss]egmentation [Ff]ault",
"([^ :]+):([0-9]+): ([^ \\t])",
"([^:]+): error[ \\t]*[0-9]+[ \\t]*:",
"^Error ([0-9]+):",
"^Fatal",
"^Error: ",
"^Error ",
"[0-9] ERROR: ",
"^\"[^\"]+\", line [0-9]+: [^Ww]",
"^cc[^C]*CC: ERROR File = ([^,]+), Line = ([0-9]+)",
"^ld([^:])*:([ \\t])*ERROR([^:])*:",
"^ild:([ \\t])*\\(undefined symbol\\)",
"([^ :]+) : (error|fatal error|catastrophic error)",
"([^:]+): (Error:|error|undefined reference|multiply defined)",
"([^:]+)\\(([^\\)]+)\\) : (error|fatal error|catastrophic error)",
"^fatal error C[0-9]+:",
": syntax error ",
"^collect2: ld returned 1 exit status",
"ld terminated with signal",
"Unsatisfied symbols:",
"^Unresolved:",
"Undefined symbols:",
"^Undefined[ \\t]+first referenced",
"^CMake Error.*:",
":[ \\t]cannot find",
":[ \\t]can't find",
": \\*\\*\\* No rule to make target \\`.*\\'. Stop",
": \\*\\*\\* No targets specified and no makefile found",
": Invalid loader fixup for symbol",
": Invalid fixups exist",
": Can't find library for",
": internal link edit command failed",
": Unrecognized option \\`.*\\'",
"\", line [0-9]+\\.[0-9]+: [0-9]+-[0-9]+ \\([^WI]\\)",
"ld: 0706-006 Cannot find or open library file: -l ",
"ild: \\(argument error\\) can't find library argument ::",
"^could not be found and will not be loaded.",
"s:616 string too big",
"make: Fatal error: ",
"ld: 0711-993 Error occurred while writing to the output file:",
"ld: fatal: ",
"final link failed:",
"make: \\*\\*\\*.*Error",
"make\\[.*\\]: \\*\\*\\*.*Error",
"\\*\\*\\* Error code",
"nternal error:",
"Makefile:[0-9]+: \\*\\*\\* .* Stop\\.",
": No such file or directory",
": Invalid argument",
"^The project cannot be built\\.",
0
};
static const char* cmCTestErrorExceptions[] = {
"instantiated from ",
"candidates are:",
": warning",
": \\(Warning\\)",
": note",
"makefile:",
"Makefile:",
":[ \\t]+Where:",
"([^ :]+):([0-9]+): Warning",
"------ Build started: .* ------",
0
};
static const char* cmCTestWarningMatches[] = {
"([^ :]+):([0-9]+): warning:",
"([^ :]+):([0-9]+): note:",
"^cc[^C]*CC: WARNING File = ([^,]+), Line = ([0-9]+)",
"^ld([^:])*:([ \\t])*WARNING([^:])*:",
"([^:]+): warning ([0-9]+):",
"^\"[^\"]+\", line [0-9]+: [Ww](arning|arnung)",
"([^:]+): warning[ \\t]*[0-9]+[ \\t]*:",
"^(Warning|Warnung) ([0-9]+):",
"^(Warning|Warnung) ",
"WARNING: ",
"([^ :]+) : warning",
"([^:]+): warning",
"\", line [0-9]+\\.[0-9]+: [0-9]+-[0-9]+ \\([WI]\\)",
"^cxx: Warning:",
".*file: .* has no symbols",
"([^ :]+):([0-9]+): (Warning|Warnung)",
"\\([0-9]*\\): remark #[0-9]*",
"\".*\", line [0-9]+: remark\\([0-9]*\\):",
"cc-[0-9]* CC: REMARK File = .*, Line = [0-9]*",
"^CMake Warning.*:",
0
};
static const char* cmCTestWarningExceptions[] = {
"/usr/.*/X11/Xlib\\.h:[0-9]+: war.*: ANSI C\\+\\+ forbids declaration",
"/usr/.*/X11/Xutil\\.h:[0-9]+: war.*: ANSI C\\+\\+ forbids declaration",
"/usr/.*/X11/XResource\\.h:[0-9]+: war.*: ANSI C\\+\\+ forbids declaration",
"WARNING 84 :",
"WARNING 47 :",
"makefile:",
"Makefile:",
"warning: Clock skew detected. Your build may be incomplete.",
"/usr/openwin/include/GL/[^:]+:",
"bind_at_load",
"XrmQGetResource",
"IceFlush",
"warning LNK4089: all references to [^ \\t]+ discarded by .OPT:REF",
"ld32: WARNING 85: definition of dataKey in",
"cc: warning 422: Unknown option \"\\+b",
"_with_warning_C",
0
};
struct cmCTestBuildCompileErrorWarningRex
{
const char* RegularExpressionString;
int FileIndex;
int LineIndex;
};
static cmCTestBuildCompileErrorWarningRex
cmCTestWarningErrorFileLine[] = {
{ "^Warning W[0-9]+ ([a-zA-Z.\\:/0-9_+ ~-]+) ([0-9]+):", 1, 2 },
{ "^([a-zA-Z./0-9_+ ~-]+):([0-9]+):", 1, 2 },
{ "^([a-zA-Z.\\:/0-9_+ ~-]+)\\(([0-9]+)\\)", 1, 2 },
{ "^[0-9]+>([a-zA-Z.\\:/0-9_+ ~-]+)\\(([0-9]+)\\)", 1, 2 },
{ "^([a-zA-Z./0-9_+ ~-]+)\\(([0-9]+)\\)", 1, 2 },
{ "\"([a-zA-Z./0-9_+ ~-]+)\", line ([0-9]+)", 1, 2 },
{ "File = ([a-zA-Z./0-9_+ ~-]+), Line = ([0-9]+)", 1, 2 },
{ 0, 0, 0 }
};
//----------------------------------------------------------------------
cmCTestBuildHandler::cmCTestBuildHandler()
{
this->MaxPreContext = 10;
this->MaxPostContext = 10;
this->MaxErrors = 50;
this->MaxWarnings = 50;
this->LastErrorOrWarning = this->ErrorsAndWarnings.end();
this->UseCTestLaunch = false;
}
//----------------------------------------------------------------------
void cmCTestBuildHandler::Initialize()
{
this->Superclass::Initialize();
this->StartBuild = "";
this->EndBuild = "";
this->CustomErrorMatches.clear();
this->CustomErrorExceptions.clear();
this->CustomWarningMatches.clear();
this->CustomWarningExceptions.clear();
this->ReallyCustomWarningMatches.clear();
this->ReallyCustomWarningExceptions.clear();
this->ErrorWarningFileLineRegex.clear();
this->ErrorMatchRegex.clear();
this->ErrorExceptionRegex.clear();
this->WarningMatchRegex.clear();
this->WarningExceptionRegex.clear();
this->BuildProcessingQueue.clear();
this->BuildProcessingErrorQueue.clear();
this->BuildOutputLogSize = 0;
this->CurrentProcessingLine.clear();
this->SimplifySourceDir = "";
this->SimplifyBuildDir = "";
this->OutputLineCounter = 0;
this->ErrorsAndWarnings.clear();
this->LastErrorOrWarning = this->ErrorsAndWarnings.end();
this->PostContextCount = 0;
this->MaxPreContext = 10;
this->MaxPostContext = 10;
this->PreContext.clear();
this->TotalErrors = 0;
this->TotalWarnings = 0;
this->LastTickChar = 0;
this->ErrorQuotaReached = false;
this->WarningQuotaReached = false;
this->MaxErrors = 50;
this->MaxWarnings = 50;
this->UseCTestLaunch = false;
}
//----------------------------------------------------------------------
void cmCTestBuildHandler::PopulateCustomVectors(cmMakefile *mf)
{
this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_ERROR_MATCH",
this->CustomErrorMatches);
this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_ERROR_EXCEPTION",
this->CustomErrorExceptions);
this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_WARNING_MATCH",
this->CustomWarningMatches);
this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_WARNING_EXCEPTION",
this->CustomWarningExceptions);
this->CTest->PopulateCustomInteger(mf,
"CTEST_CUSTOM_MAXIMUM_NUMBER_OF_ERRORS",
this->MaxErrors);
this->CTest->PopulateCustomInteger(mf,
"CTEST_CUSTOM_MAXIMUM_NUMBER_OF_WARNINGS",
this->MaxWarnings);
int n = -1;
this->CTest->PopulateCustomInteger(mf, "CTEST_CUSTOM_ERROR_PRE_CONTEXT", n);
if (n != -1)
{
this->MaxPreContext = static_cast<size_t>(n);
}
n = -1;
this->CTest->PopulateCustomInteger(mf, "CTEST_CUSTOM_ERROR_POST_CONTEXT", n);
if (n != -1)
{
this->MaxPostContext = static_cast<size_t>(n);
}
// Record the user-specified custom warning rules.
if(const char* customWarningMatchers =
mf->GetDefinition("CTEST_CUSTOM_WARNING_MATCH"))
{
cmSystemTools::ExpandListArgument(customWarningMatchers,
this->ReallyCustomWarningMatches);
}
if(const char* customWarningExceptions =
mf->GetDefinition("CTEST_CUSTOM_WARNING_EXCEPTION"))
{
cmSystemTools::ExpandListArgument(customWarningExceptions,
this->ReallyCustomWarningExceptions);
}
}
//----------------------------------------------------------------------
std::string cmCTestBuildHandler::GetMakeCommand()
{
std::string makeCommand
= this->CTest->GetCTestConfiguration("MakeCommand");
cmCTestLog(this->CTest,
HANDLER_VERBOSE_OUTPUT, "MakeCommand:" << makeCommand <<
"\n");
std::string configType = this->CTest->GetConfigType();
if (configType == "")
{
configType
= this->CTest->GetCTestConfiguration("DefaultCTestConfigurationType");
}
if (configType == "")
{
configType = "Release";
}
cmSystemTools::ReplaceString(makeCommand,
"${CTEST_CONFIGURATION_TYPE}", configType.c_str());
return makeCommand;
}
//----------------------------------------------------------------------
//clearly it would be nice if this were broken up into a few smaller
//functions and commented...
int cmCTestBuildHandler::ProcessHandler()
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, "Build project" << std::endl);
// do we have time for this
if (this->CTest->GetRemainingTimeAllowed() < 120)
{
return 0;
}
int entry;
for ( entry = 0;
cmCTestWarningErrorFileLine[entry].RegularExpressionString;
++ entry )
{
cmCTestBuildHandler::cmCTestCompileErrorWarningRex r;
if ( r.RegularExpression.compile(
cmCTestWarningErrorFileLine[entry].RegularExpressionString) )
{
r.FileIndex = cmCTestWarningErrorFileLine[entry].FileIndex;
r.LineIndex = cmCTestWarningErrorFileLine[entry].LineIndex;
this->ErrorWarningFileLineRegex.push_back(r);
}
else
{
cmCTestLog(this->CTest, ERROR_MESSAGE,
"Problem Compiling regular expression: "
<< cmCTestWarningErrorFileLine[entry].RegularExpressionString
<< std::endl);
}
}
// Determine build command and build directory
std::string makeCommand = this->GetMakeCommand();
if ( makeCommand.size() == 0 )
{
cmCTestLog(this->CTest, ERROR_MESSAGE,
"Cannot find MakeCommand key in the DartConfiguration.tcl"
<< std::endl);
return -1;
}
const std::string &buildDirectory
= this->CTest->GetCTestConfiguration("BuildDirectory");
if ( buildDirectory.size() == 0 )
{
cmCTestLog(this->CTest, ERROR_MESSAGE,
"Cannot find BuildDirectory key in the DartConfiguration.tcl"
<< std::endl);
return -1;
}
std::string const& useLaunchers =
this->CTest->GetCTestConfiguration("UseLaunchers");
this->UseCTestLaunch = cmSystemTools::IsOn(useLaunchers.c_str());
// Create a last build log
cmGeneratedFileStream ofs;
double elapsed_time_start = cmSystemTools::GetTime();
if ( !this->StartLogFile("Build", ofs) )
{
cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot create build log file"
<< std::endl);
}
// Create lists of regular expression strings for errors, error exceptions,
// warnings and warning exceptions.
std::vector<cmStdString>::size_type cc;
for ( cc = 0; cmCTestErrorMatches[cc]; cc ++ )
{
this->CustomErrorMatches.push_back(cmCTestErrorMatches[cc]);
}
for ( cc = 0; cmCTestErrorExceptions[cc]; cc ++ )
{
this->CustomErrorExceptions.push_back(cmCTestErrorExceptions[cc]);
}
for ( cc = 0; cmCTestWarningMatches[cc]; cc ++ )
{
this->CustomWarningMatches.push_back(cmCTestWarningMatches[cc]);
}
for ( cc = 0; cmCTestWarningExceptions[cc]; cc ++ )
{
this->CustomWarningExceptions.push_back(cmCTestWarningExceptions[cc]);
}
// Pre-compile regular expressions objects for all regular expressions
std::vector<cmStdString>::iterator it;
#define cmCTestBuildHandlerPopulateRegexVector(strings, regexes) \
regexes.clear(); \
cmCTestLog(this->CTest, DEBUG, this << "Add " #regexes \
<< std::endl); \
for ( it = strings.begin(); it != strings.end(); ++it ) \
{ \
cmCTestLog(this->CTest, DEBUG, "Add " #strings ": " \
<< it->c_str() << std::endl); \
regexes.push_back(it->c_str()); \
}
cmCTestBuildHandlerPopulateRegexVector(
this->CustomErrorMatches, this->ErrorMatchRegex);
cmCTestBuildHandlerPopulateRegexVector(
this->CustomErrorExceptions, this->ErrorExceptionRegex);
cmCTestBuildHandlerPopulateRegexVector(
this->CustomWarningMatches, this->WarningMatchRegex);
cmCTestBuildHandlerPopulateRegexVector(
this->CustomWarningExceptions, this->WarningExceptionRegex);
// Determine source and binary tree substitutions to simplify the output.
this->SimplifySourceDir = "";
this->SimplifyBuildDir = "";
if ( this->CTest->GetCTestConfiguration("SourceDirectory").size() > 20 )
{
std::string srcdir
= this->CTest->GetCTestConfiguration("SourceDirectory") + "/";
std::string srcdirrep;
for ( cc = srcdir.size()-2; cc > 0; cc -- )
{
if ( srcdir[cc] == '/' )
{
srcdirrep = srcdir.c_str() + cc;
srcdirrep = "/..." + srcdirrep;
srcdir = srcdir.substr(0, cc+1);
break;
}
}
this->SimplifySourceDir = srcdir;
}
if ( this->CTest->GetCTestConfiguration("BuildDirectory").size() > 20 )
{
std::string bindir
= this->CTest->GetCTestConfiguration("BuildDirectory") + "/";
std::string bindirrep;
for ( cc = bindir.size()-2; cc > 0; cc -- )
{
if ( bindir[cc] == '/' )
{
bindirrep = bindir.c_str() + cc;
bindirrep = "/..." + bindirrep;
bindir = bindir.substr(0, cc+1);
break;
}
}
this->SimplifyBuildDir = bindir;
}
// Ok, let's do the build
// Remember start build time
this->StartBuild = this->CTest->CurrentTime();
this->StartBuildTime = cmSystemTools::GetTime();
int retVal = 0;
int res = cmsysProcess_State_Exited;
if ( !this->CTest->GetShowOnly() )
{
res = this->RunMakeCommand(makeCommand.c_str(), &retVal,
buildDirectory.c_str(), 0, ofs);
}
else
{
cmCTestLog(this->CTest, DEBUG, "Build with command: " << makeCommand
<< std::endl);
}
// Remember end build time and calculate elapsed time
this->EndBuild = this->CTest->CurrentTime();
this->EndBuildTime = cmSystemTools::GetTime();
double elapsed_build_time = cmSystemTools::GetTime() - elapsed_time_start;
// Cleanups strings in the errors and warnings list.
t_ErrorsAndWarningsVector::iterator evit;
if ( !this->SimplifySourceDir.empty() )
{
for ( evit = this->ErrorsAndWarnings.begin();
evit != this->ErrorsAndWarnings.end();
++ evit )
{
cmSystemTools::ReplaceString(
evit->Text, this->SimplifySourceDir.c_str(), "/.../");
cmSystemTools::ReplaceString(
evit->PreContext, this->SimplifySourceDir.c_str(), "/.../");
cmSystemTools::ReplaceString(
evit->PostContext, this->SimplifySourceDir.c_str(), "/.../");
}
}
if ( !this->SimplifyBuildDir.empty() )
{
for ( evit = this->ErrorsAndWarnings.begin();
evit != this->ErrorsAndWarnings.end();
++ evit )
{
cmSystemTools::ReplaceString(
evit->Text, this->SimplifyBuildDir.c_str(), "/.../");
cmSystemTools::ReplaceString(
evit->PreContext, this->SimplifyBuildDir.c_str(), "/.../");
cmSystemTools::ReplaceString(
evit->PostContext, this->SimplifyBuildDir.c_str(), "/.../");
}
}
// Generate XML output
cmGeneratedFileStream xofs;
if(!this->StartResultingXML(cmCTest::PartBuild, "Build", xofs))
{
cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot create build XML file"
<< std::endl);
return -1;
}
this->GenerateXMLHeader(xofs);
if(this->UseCTestLaunch)
{
this->GenerateXMLLaunched(xofs);
}
else
{
this->GenerateXMLLogScraped(xofs);
}
this->GenerateXMLFooter(xofs, elapsed_build_time);
if (res != cmsysProcess_State_Exited || retVal || this->TotalErrors > 0)
{
cmCTestLog(this->CTest, ERROR_MESSAGE, "Error(s) when building project"
<< std::endl);
}
// Display message about number of errors and warnings
cmCTestLog(this->CTest, HANDLER_OUTPUT, " " << this->TotalErrors
<< (this->TotalErrors >= this->MaxErrors ? " or more" : "")
<< " Compiler errors" << std::endl);
cmCTestLog(this->CTest, HANDLER_OUTPUT, " " << this->TotalWarnings
<< (this->TotalWarnings >= this->MaxWarnings ? " or more" : "")
<< " Compiler warnings" << std::endl);
return retVal;
}
//----------------------------------------------------------------------------
void cmCTestBuildHandler::GenerateXMLHeader(std::ostream& os)
{
this->CTest->StartXML(os, this->AppendXML);
os << "<Build>\n"
<< "\t<StartDateTime>" << this->StartBuild << "</StartDateTime>\n"
<< "\t<StartBuildTime>" <<
static_cast<unsigned int>(this->StartBuildTime)
<< "</StartBuildTime>\n"
<< "<BuildCommand>"
<< cmXMLSafe(this->GetMakeCommand())
<< "</BuildCommand>" << std::endl;
}
//----------------------------------------------------------------------------
class cmCTestBuildHandler::FragmentCompare
{
public:
FragmentCompare(cmFileTimeComparison* ftc): FTC(ftc) {}
FragmentCompare(): FTC(0) {}
bool operator()(std::string const& l, std::string const& r)
{
// Order files by modification time. Use lexicographic order
// among files with the same time.
int result;
if(this->FTC->FileTimeCompare(l.c_str(), r.c_str(), &result) &&
result != 0)
{
return result < 0;
}
else
{
return l < r;
}
}
private:
cmFileTimeComparison* FTC;
};
//----------------------------------------------------------------------------
void cmCTestBuildHandler::GenerateXMLLaunched(std::ostream& os)
{
if(this->CTestLaunchDir.empty())
{
return;
}
// Sort XML fragments in chronological order.
cmFileTimeComparison ftc;
FragmentCompare fragmentCompare(&ftc);
typedef std::set<cmStdString, FragmentCompare> Fragments;
Fragments fragments(fragmentCompare);
// Identify fragments on disk.
cmsys::Directory launchDir;
launchDir.Load(this->CTestLaunchDir.c_str());
unsigned long n = launchDir.GetNumberOfFiles();
for(unsigned long i=0; i < n; ++i)
{
const char* fname = launchDir.GetFile(i);
if(this->IsLaunchedErrorFile(fname))
{
fragments.insert(this->CTestLaunchDir + "/" + fname);
++this->TotalErrors;
}
else if(this->IsLaunchedWarningFile(fname))
{
fragments.insert(this->CTestLaunchDir + "/" + fname);
++this->TotalWarnings;
}
}
// Copy the fragments into the final XML file.
for(Fragments::const_iterator fi = fragments.begin();
fi != fragments.end(); ++fi)
{
this->GenerateXMLLaunchedFragment(os, fi->c_str());
}
}
//----------------------------------------------------------------------------
void cmCTestBuildHandler::GenerateXMLLogScraped(std::ostream& os)
{
std::vector<cmCTestBuildErrorWarning>& ew = this->ErrorsAndWarnings;
std::vector<cmCTestBuildErrorWarning>::iterator it;
// only report the first 50 warnings and first 50 errors
int numErrorsAllowed = this->MaxErrors;
int numWarningsAllowed = this->MaxWarnings;
std::string srcdir = this->CTest->GetCTestConfiguration("SourceDirectory");
// make sure the source dir is in the correct case on windows
// via a call to collapse full path.
srcdir = cmSystemTools::CollapseFullPath(srcdir.c_str());
srcdir += "/";
for ( it = ew.begin();
it != ew.end() && (numErrorsAllowed || numWarningsAllowed); it++ )
{
cmCTestBuildErrorWarning *cm = &(*it);
if ((cm->Error && numErrorsAllowed) ||
(!cm->Error && numWarningsAllowed))
{
if (cm->Error)
{
numErrorsAllowed--;
}
else
{
numWarningsAllowed--;
}
os << "\t<" << (cm->Error ? "Error" : "Warning") << ">\n"
<< "\t\t<BuildLogLine>" << cm->LogLine << "</BuildLogLine>\n"
<< "\t\t<Text>" << cmXMLSafe(cm->Text).Quotes(false)
<< "\n</Text>" << std::endl;
std::vector<cmCTestCompileErrorWarningRex>::iterator rit;
for ( rit = this->ErrorWarningFileLineRegex.begin();
rit != this->ErrorWarningFileLineRegex.end(); ++ rit )
{
cmsys::RegularExpression* re = &rit->RegularExpression;
if ( re->find(cm->Text.c_str() ) )
{
cm->SourceFile = re->match(rit->FileIndex);
// At this point we need to make this->SourceFile relative to
// the source root of the project, so cvs links will work
cmSystemTools::ConvertToUnixSlashes(cm->SourceFile);
if(cm->SourceFile.find("/.../") != cm->SourceFile.npos)
{
cmSystemTools::ReplaceString(cm->SourceFile, "/.../", "");
std::string::size_type p = cm->SourceFile.find("/");
if(p != cm->SourceFile.npos)
{
cm->SourceFile = cm->SourceFile.substr(
p+1, cm->SourceFile.size()-p);
}
}
else
{
// make sure it is a full path with the correct case
cm->SourceFile = cmSystemTools::CollapseFullPath(
cm->SourceFile.c_str());
cmSystemTools::ReplaceString(
cm->SourceFile, srcdir.c_str(), "");
}
cm->LineNumber = atoi(re->match(rit->LineIndex).c_str());
break;
}
}
if ( !cm->SourceFile.empty() && cm->LineNumber >= 0 )
{
if ( cm->SourceFile.size() > 0 )
{
os << "\t\t<SourceFile>" << cm->SourceFile << "</SourceFile>"
<< std::endl;
}
if ( cm->SourceFileTail.size() > 0 )
{
os << "\t\t<SourceFileTail>" << cm->SourceFileTail
<< "</SourceFileTail>" << std::endl;
}
if ( cm->LineNumber >= 0 )
{
os << "\t\t<SourceLineNumber>" << cm->LineNumber
<< "</SourceLineNumber>" << std::endl;
}
}
os << "\t\t<PreContext>" << cmXMLSafe(cm->PreContext).Quotes(false)
<< "</PreContext>\n"
<< "\t\t<PostContext>" << cmXMLSafe(cm->PostContext).Quotes(false);
// is this the last warning or error, if so notify
if ((cm->Error && !numErrorsAllowed) ||
(!cm->Error && !numWarningsAllowed))
{
os << "\nThe maximum number of reported warnings or errors has been "
"reached!!!\n";
}
os << "</PostContext>\n"
<< "\t\t<RepeatCount>0</RepeatCount>\n"
<< "</" << (cm->Error ? "Error" : "Warning") << ">\n\n"
<< std::endl;
}
}
}
//----------------------------------------------------------------------------
void cmCTestBuildHandler::GenerateXMLFooter(std::ostream& os,
double elapsed_build_time)
{
os << "\t<Log Encoding=\"base64\" Compression=\"/bin/gzip\">\n\t</Log>\n"
<< "\t<EndDateTime>" << this->EndBuild << "</EndDateTime>\n"
<< "\t<EndBuildTime>" << static_cast<unsigned int>(this->EndBuildTime)
<< "</EndBuildTime>\n"
<< "<ElapsedMinutes>" << static_cast<int>(elapsed_build_time/6)/10.0
<< "</ElapsedMinutes>"
<< "</Build>" << std::endl;
this->CTest->EndXML(os);
}
//----------------------------------------------------------------------------
void cmCTestBuildHandler::GenerateXMLLaunchedFragment(std::ostream& os,
const char* fname)
{
std::ifstream fin(fname, std::ios::in | std::ios::binary);
std::string line;
while(cmSystemTools::GetLineFromStream(fin, line))
{
os << line << "\n";
}
}
//----------------------------------------------------------------------------
bool cmCTestBuildHandler::IsLaunchedErrorFile(const char* fname)
{
// error-{hash}.xml
return (strncmp(fname, "error-", 6) == 0 &&
strcmp(fname+strlen(fname)-4, ".xml") == 0);
}
//----------------------------------------------------------------------------
bool cmCTestBuildHandler::IsLaunchedWarningFile(const char* fname)
{
// warning-{hash}.xml
return (strncmp(fname, "warning-", 8) == 0 &&
strcmp(fname+strlen(fname)-4, ".xml") == 0);
}
//######################################################################
//######################################################################
//######################################################################
//######################################################################
//----------------------------------------------------------------------------
class cmCTestBuildHandler::LaunchHelper
{
public:
LaunchHelper(cmCTestBuildHandler* handler);
~LaunchHelper();
private:
cmCTestBuildHandler* Handler;
cmCTest* CTest;
void WriteLauncherConfig();
void WriteScrapeMatchers(const char* purpose,
std::vector<std::string> const& matchers);
};
//----------------------------------------------------------------------------
cmCTestBuildHandler::LaunchHelper::LaunchHelper(cmCTestBuildHandler* handler):
Handler(handler), CTest(handler->CTest)
{
std::string tag = this->CTest->GetCurrentTag();
if(tag.empty())
{
// This is not for a dashboard submission, so there is no XML.
// Skip enabling the launchers.
this->Handler->UseCTestLaunch = false;
}
else
{
// Compute a directory in which to store launcher fragments.
std::string& launchDir = this->Handler->CTestLaunchDir;
launchDir = this->CTest->GetBinaryDir();
launchDir += "/Testing/";
launchDir += tag;
launchDir += "/Build";
// Clean out any existing launcher fragments.
cmSystemTools::RemoveADirectory(launchDir.c_str());
if(this->Handler->UseCTestLaunch)
{
// Enable launcher fragments.
cmSystemTools::MakeDirectory(launchDir.c_str());
this->WriteLauncherConfig();
std::string launchEnv = "CTEST_LAUNCH_LOGS=";
launchEnv += launchDir;
cmSystemTools::PutEnv(launchEnv.c_str());
}
}
// If not using launchers, make sure they passthru.
if(!this->Handler->UseCTestLaunch)
{
cmSystemTools::UnsetEnv("CTEST_LAUNCH_LOGS");
}
}
//----------------------------------------------------------------------------
cmCTestBuildHandler::LaunchHelper::~LaunchHelper()
{
if(this->Handler->UseCTestLaunch)
{
cmSystemTools::UnsetEnv("CTEST_LAUNCH_LOGS");
}
}
//----------------------------------------------------------------------------
void cmCTestBuildHandler::LaunchHelper::WriteLauncherConfig()
{
this->WriteScrapeMatchers("Warning",
this->Handler->ReallyCustomWarningMatches);
this->WriteScrapeMatchers("WarningSuppress",
this->Handler->ReallyCustomWarningExceptions);
// Give some testing configuration information to the launcher.
std::string fname = this->Handler->CTestLaunchDir;
fname += "/CTestLaunchConfig.cmake";
cmGeneratedFileStream fout(fname.c_str());
std::string srcdir = this->CTest->GetCTestConfiguration("SourceDirectory");
fout << "set(CTEST_SOURCE_DIRECTORY \"" << srcdir << "\")\n";
}
//----------------------------------------------------------------------------
void
cmCTestBuildHandler::LaunchHelper
::WriteScrapeMatchers(const char* purpose,
std::vector<std::string> const& matchers)
{
if(matchers.empty())
{
return;
}
std::string fname = this->Handler->CTestLaunchDir;
fname += "/Custom";
fname += purpose;
fname += ".txt";
cmGeneratedFileStream fout(fname.c_str());
for(std::vector<std::string>::const_iterator mi = matchers.begin();
mi != matchers.end(); ++mi)
{
fout << *mi << "\n";
}
}
//----------------------------------------------------------------------
int cmCTestBuildHandler::RunMakeCommand(const char* command,
int* retVal, const char* dir, int timeout, std::ofstream& ofs)
{
// First generate the command and arguments
std::vector<cmStdString> args = cmSystemTools::ParseArguments(command);
if(args.size() < 1)
{
return false;
}
std::vector<const char*> argv;
for(std::vector<cmStdString>::const_iterator a = args.begin();
a != args.end(); ++a)
{
argv.push_back(a->c_str());
}
argv.push_back(0);
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Run command:");
std::vector<const char*>::iterator ait;
for ( ait = argv.begin(); ait != argv.end() && *ait; ++ ait )
{
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, " \"" << *ait << "\"");
}
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl);
// Optionally use make rule launchers to record errors and warnings.
LaunchHelper launchHelper(this);
static_cast<void>(launchHelper);
// Now create process object
cmsysProcess* cp = cmsysProcess_New();
cmsysProcess_SetCommand(cp, &*argv.begin());
cmsysProcess_SetWorkingDirectory(cp, dir);
cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
cmsysProcess_SetTimeout(cp, timeout);
cmsysProcess_Execute(cp);
// Initialize tick's
std::string::size_type tick = 0;
const std::string::size_type tick_len = 1024;
char* data;
int length;
cmCTestLog(this->CTest, HANDLER_OUTPUT,
" Each symbol represents " << tick_len << " bytes of output."
<< std::endl
<< (this->UseCTestLaunch? "" :
" '!' represents an error and '*' a warning.\n")
<< " " << std::flush);
// Initialize building structures
this->BuildProcessingQueue.clear();
this->OutputLineCounter = 0;
this->ErrorsAndWarnings.clear();
this->TotalErrors = 0;
this->TotalWarnings = 0;
this->BuildOutputLogSize = 0;
this->LastTickChar = '.';
this->WarningQuotaReached = false;
this->ErrorQuotaReached = false;
// For every chunk of data
int res;
while((res = cmsysProcess_WaitForData(cp, &data, &length, 0)))
{
// Replace '\0' with '\n', since '\0' does not really make sense. This is
// for Visual Studio output
for(int cc =0; cc < length; ++cc)
{
if(data[cc] == 0)
{
data[cc] = '\n';
}
}
// Process the chunk of data
if ( res == cmsysProcess_Pipe_STDERR )
{
this->ProcessBuffer(data, length, tick, tick_len, ofs,
&this->BuildProcessingErrorQueue);
}
else
{
this->ProcessBuffer(data, length, tick, tick_len, ofs,
&this->BuildProcessingQueue);
}
}
this->ProcessBuffer(0, 0, tick, tick_len, ofs, &this->BuildProcessingQueue);
this->ProcessBuffer(0, 0, tick, tick_len, ofs,
&this->BuildProcessingErrorQueue);
cmCTestLog(this->CTest, OUTPUT, " Size of output: "
<< ((this->BuildOutputLogSize + 512) / 1024) << "K" << std::endl);
// Properly handle output of the build command
cmsysProcess_WaitForExit(cp, 0);
int result = cmsysProcess_GetState(cp);
if(result == cmsysProcess_State_Exited)
{
if (retVal)
{
*retVal = cmsysProcess_GetExitValue(cp);
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
"Command exited with the value: " << *retVal << std::endl);
// if a non zero return value
if (*retVal)
{
// If there was an error running command, report that on the
// dashboard.
cmCTestBuildErrorWarning errorwarning;
errorwarning.LogLine = 1;
errorwarning.Text
= "*** WARNING non-zero return value in ctest from: ";
errorwarning.Text += argv[0];
errorwarning.PreContext = "";
errorwarning.PostContext = "";
errorwarning.Error = false;
this->ErrorsAndWarnings.push_back(errorwarning);
this->TotalWarnings ++;
}
}
}
else if(result == cmsysProcess_State_Exception)
{
if (retVal)
{
*retVal = cmsysProcess_GetExitException(cp);
cmCTestLog(this->CTest, WARNING, "There was an exception: " << *retVal
<< std::endl);
}
}
else if(result == cmsysProcess_State_Expired)
{
cmCTestLog(this->CTest, WARNING, "There was a timeout" << std::endl);
}
else if(result == cmsysProcess_State_Error)
{
// If there was an error running command, report that on the dashboard.
cmCTestBuildErrorWarning errorwarning;
errorwarning.LogLine = 1;
errorwarning.Text = "*** ERROR executing: ";
errorwarning.Text += cmsysProcess_GetErrorString(cp);
errorwarning.PreContext = "";
errorwarning.PostContext = "";
errorwarning.Error = true;
this->ErrorsAndWarnings.push_back(errorwarning);
this->TotalErrors ++;
cmCTestLog(this->CTest, ERROR_MESSAGE, "There was an error: "
<< cmsysProcess_GetErrorString(cp) << std::endl);
}
cmsysProcess_Delete(cp);
return result;
}
//######################################################################
//######################################################################
//######################################################################
//######################################################################
//----------------------------------------------------------------------
void cmCTestBuildHandler::ProcessBuffer(const char* data, int length,
size_t& tick, size_t tick_len, std::ofstream& ofs,
t_BuildProcessingQueueType* queue)
{
const std::string::size_type tick_line_len = 50;
const char* ptr;
for ( ptr = data; ptr < data+length; ptr ++ )
{
queue->push_back(*ptr);
}
this->BuildOutputLogSize += length;
// until there are any lines left in the buffer
while ( 1 )
{
// Find the end of line
t_BuildProcessingQueueType::iterator it;
for ( it = queue->begin();
it != queue->end();
++ it )
{
if ( *it == '\n' )
{
break;
}
}
// Once certain number of errors or warnings reached, ignore future errors
// or warnings.
if ( this->TotalWarnings >= this->MaxWarnings )
{
this->WarningQuotaReached = true;
}
if ( this->TotalErrors >= this->MaxErrors )
{
this->ErrorQuotaReached = true;
}
// If the end of line was found
if ( it != queue->end() )
{
// Create a contiguous array for the line
this->CurrentProcessingLine.clear();
t_BuildProcessingQueueType::iterator cit;
for ( cit = queue->begin(); cit != it; ++cit )
{
this->CurrentProcessingLine.push_back(*cit);
}
this->CurrentProcessingLine.push_back(0);
const char* line = &*this->CurrentProcessingLine.begin();
// Process the line
int lineType = this->ProcessSingleLine(line);
// Erase the line from the queue
queue->erase(queue->begin(), it+1);
// Depending on the line type, produce error or warning, or nothing
cmCTestBuildErrorWarning errorwarning;
bool found = false;
switch ( lineType )
{
case b_WARNING_LINE:
this->LastTickChar = '*';
errorwarning.Error = false;
found = true;
this->TotalWarnings ++;
break;
case b_ERROR_LINE:
this->LastTickChar = '!';
errorwarning.Error = true;
found = true;
this->TotalErrors ++;
break;
}
if ( found )
{
// This is an error or warning, so generate report
errorwarning.LogLine = static_cast<int>(this->OutputLineCounter+1);
errorwarning.Text = line;
errorwarning.PreContext = "";
errorwarning.PostContext = "";
// Copy pre-context to report
std::deque<cmStdString>::iterator pcit;
for ( pcit = this->PreContext.begin();
pcit != this->PreContext.end();
++pcit )
{
errorwarning.PreContext += *pcit + "\n";
}
this->PreContext.clear();
// Store report
this->ErrorsAndWarnings.push_back(errorwarning);
this->LastErrorOrWarning = this->ErrorsAndWarnings.end()-1;
this->PostContextCount = 0;
}
else
{
// This is not an error or warning.
// So, figure out if this is a post-context line
if ( this->ErrorsAndWarnings.size() &&
this->LastErrorOrWarning != this->ErrorsAndWarnings.end() &&
this->PostContextCount < this->MaxPostContext )
{
this->PostContextCount ++;
this->LastErrorOrWarning->PostContext += line;
if ( this->PostContextCount < this->MaxPostContext )
{
this->LastErrorOrWarning->PostContext += "\n";
}
}
else
{
// Otherwise store pre-context for the next error
this->PreContext.push_back(line);
if ( this->PreContext.size() > this->MaxPreContext )
{
this->PreContext.erase(this->PreContext.begin(),
this->PreContext.end()-this->MaxPreContext);
}
}
}
this->OutputLineCounter ++;
}
else
{
break;
}
}
// Now that the buffer is processed, display missing ticks
int tickDisplayed = false;
while ( this->BuildOutputLogSize > (tick * tick_len) )
{
tick ++;
cmCTestLog(this->CTest, HANDLER_OUTPUT, this->LastTickChar);
tickDisplayed = true;
if ( tick % tick_line_len == 0 && tick > 0 )
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, " Size: "
<< ((this->BuildOutputLogSize + 512) / 1024) << "K" << std::endl
<< " ");
}
}
if ( tickDisplayed )
{
this->LastTickChar = '.';
}
// And if this is verbose output, display the content of the chunk
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
cmCTestLogWrite(data, length));
// Always store the chunk to the file
ofs << cmCTestLogWrite(data, length);
}
//----------------------------------------------------------------------
int cmCTestBuildHandler::ProcessSingleLine(const char* data)
{
if(this->UseCTestLaunch)
{
// No log scraping when using launchers.
return b_REGULAR_LINE;
}
cmCTestLog(this->CTest, DEBUG, "Line: [" << data << "]" << std::endl);
std::vector<cmsys::RegularExpression>::iterator it;
int warningLine = 0;
int errorLine = 0;
// Check for regular expressions
if ( !this->ErrorQuotaReached )
{
// Errors
int wrxCnt = 0;
for ( it = this->ErrorMatchRegex.begin();
it != this->ErrorMatchRegex.end();
++ it )
{
if ( it->find(data) )
{
errorLine = 1;
cmCTestLog(this->CTest, DEBUG, " Error Line: " << data
<< " (matches: " << this->CustomErrorMatches[wrxCnt] << ")"
<< std::endl);
break;
}
wrxCnt ++;
}
// Error exceptions
wrxCnt = 0;
for ( it = this->ErrorExceptionRegex.begin();
it != this->ErrorExceptionRegex.end();
++ it )
{
if ( it->find(data) )
{
errorLine = 0;
cmCTestLog(this->CTest, DEBUG, " Not an error Line: " << data
<< " (matches: " << this->CustomErrorExceptions[wrxCnt] << ")"
<< std::endl);
break;
}
wrxCnt ++;
}
}
if ( !this->WarningQuotaReached )
{
// Warnings
int wrxCnt = 0;
for ( it = this->WarningMatchRegex.begin();
it != this->WarningMatchRegex.end();
++ it )
{
if ( it->find(data) )
{
warningLine = 1;
cmCTestLog(this->CTest, DEBUG,
" Warning Line: " << data
<< " (matches: " << this->CustomWarningMatches[wrxCnt] << ")"
<< std::endl);
break;
}
wrxCnt ++;
}
wrxCnt = 0;
// Warning exceptions
for ( it = this->WarningExceptionRegex.begin();
it != this->WarningExceptionRegex.end();
++ it )
{
if ( it->find(data) )
{
warningLine = 0;
cmCTestLog(this->CTest, DEBUG, " Not a warning Line: " << data
<< " (matches: " << this->CustomWarningExceptions[wrxCnt] << ")"
<< std::endl);
break;
}
wrxCnt ++;
}
}
if ( errorLine )
{
return b_ERROR_LINE;
}
if ( warningLine )
{
return b_WARNING_LINE;
}
return b_REGULAR_LINE;
}
Reference in new issue View Git Blame Copy Permalink