/*
* Cppcheck - A tool for static C/C++ code analysis
* Copyright (C) 2007-2014 Daniel Marjamäki and Cppcheck team.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include "cppcheckexecutor.h"
#include "cmdlineparser.h"
#include "cppcheck.h"
#include "errorlogger.h"
#include "filelister.h"
#include "path.h"
#include "pathmatch.h"
#include "preprocessor.h"
#include "threadexecutor.h"
#include
#include
#include // EXIT_SUCCESS and EXIT_FAILURE
#include
#include
#include
#if defined(__GNUC__) && !defined(__MINGW32__) && !defined(__CYGWIN__)
#define USE_UNIX_SIGNAL_HANDLING
#include
#include
#endif
#ifdef USE_UNIX_SIGNAL_HANDLING
#include
#include
#endif
#if defined(_MSC_VER)
#define USE_WINDOWS_SEH
#include
#include
#endif
CppCheckExecutor::CppCheckExecutor()
: _settings(0), time1(0), errorlist(false)
{
}
CppCheckExecutor::~CppCheckExecutor()
{
}
bool CppCheckExecutor::parseFromArgs(CppCheck *cppcheck, int argc, const char* const argv[])
{
Settings& settings = cppcheck->settings();
CmdLineParser parser(&settings);
bool success = parser.ParseFromArgs(argc, argv);
if (success) {
if (parser.GetShowVersion() && !parser.GetShowErrorMessages()) {
const char * extraVersion = cppcheck->extraVersion();
if (*extraVersion != 0)
std::cout << "Cppcheck " << cppcheck->version() << " ("
<< extraVersion << ')' << std::endl;
else
std::cout << "Cppcheck " << cppcheck->version() << std::endl;
}
if (parser.GetShowErrorMessages()) {
errorlist = true;
std::cout << ErrorLogger::ErrorMessage::getXMLHeader(settings._xml_version);
cppcheck->getErrorMessages();
std::cout << ErrorLogger::ErrorMessage::getXMLFooter(settings._xml_version) << std::endl;
}
if (parser.ExitAfterPrinting())
std::exit(EXIT_SUCCESS);
} else {
std::exit(EXIT_FAILURE);
}
// Check that all include paths exist
{
std::list::iterator iter;
for (iter = settings._includePaths.begin();
iter != settings._includePaths.end();
) {
const std::string path(Path::toNativeSeparators(*iter));
if (FileLister::isDirectory(path))
++iter;
else {
// If the include path is not found, warn user (unless --quiet
// was used) and remove the non-existing path from the list.
if (!settings._errorsOnly)
std::cout << "cppcheck: warning: Couldn't find path given by -I '" << path << '\'' << std::endl;
iter = settings._includePaths.erase(iter);
}
}
}
const std::vector& pathnames = parser.GetPathNames();
if (!pathnames.empty()) {
// Execute recursiveAddFiles() to each given file parameter
std::vector::const_iterator iter;
for (iter = pathnames.begin(); iter != pathnames.end(); ++iter)
FileLister::recursiveAddFiles(_files, Path::toNativeSeparators(*iter), _settings->library.markupExtensions());
}
if (!_files.empty()) {
// Remove header files from the list of ignored files.
// Also output a warning for the user.
// TODO: Remove all unknown files? (use FileLister::acceptFile())
bool warn = false;
std::vector ignored = parser.GetIgnoredPaths();
for (std::vector::iterator i = ignored.begin(); i != ignored.end();) {
const std::string extension = Path::getFilenameExtension(*i);
if (extension == ".h" || extension == ".hpp") {
i = ignored.erase(i);
warn = true;
} else
++i;
}
if (warn) {
std::cout << "cppcheck: filename exclusion does not apply to header (.h and .hpp) files." << std::endl;
std::cout << "cppcheck: Please use --suppress for ignoring results from the header files." << std::endl;
}
#if defined(_WIN32)
// For Windows we want case-insensitive path matching
const bool caseSensitive = false;
#else
const bool caseSensitive = true;
#endif
PathMatch matcher(parser.GetIgnoredPaths(), caseSensitive);
for (std::map::iterator i = _files.begin(); i != _files.end();) {
if (matcher.Match(i->first))
_files.erase(i++);
else
++i;
}
} else {
std::cout << "cppcheck: error: could not find or open any of the paths given." << std::endl;
return false;
}
if (!_files.empty()) {
return true;
} else {
std::cout << "cppcheck: error: no files to check - all paths ignored." << std::endl;
return false;
}
}
int CppCheckExecutor::check(int argc, const char* const argv[])
{
Preprocessor::missingIncludeFlag = false;
CppCheck cppCheck(*this, true);
Settings& settings = cppCheck.settings();
_settings = &settings;
if (!parseFromArgs(&cppCheck, argc, argv)) {
return EXIT_FAILURE;
}
if (cppCheck.settings().exceptionHandling) {
return check_wrapper(cppCheck, argc, argv);
} else {
return check_internal(cppCheck, argc, argv);
}
}
#if defined(USE_UNIX_SIGNAL_HANDLING)
/* (declare this list here, so it may be used in signal handlers in addition to main())
* A list of signals available in ISO C
* Check out http://pubs.opengroup.org/onlinepubs/009695399/basedefs/signal.h.html
* For now we only want to detect abnormal behaviour for a few selected signals:
*/
struct Signaltype {
int signalnumber;
const char *signalname;
};
#define DECLARE_SIGNAL(x) {x, #x}
static const Signaltype listofsignals[] = {
// don't care: SIGABRT,
DECLARE_SIGNAL(SIGFPE),
DECLARE_SIGNAL(SIGILL),
DECLARE_SIGNAL(SIGINT),
DECLARE_SIGNAL(SIGSEGV),
// don't care: SIGTERM
};
/**
* Simple helper function:
* \return size of array
* */
template
int GetArrayLength(const T(&)[size])
{
return size;
}
// 32 vs. 64bit
#define ADDRESSDISPLAYLENGTH ((sizeof(long)==8)?12:8)
/*
* Try to print the callstack.
* That is very sensitive to the operating system, hardware, compiler and runtime!
*/
static void print_stacktrace(FILE* f, bool demangling)
{
#if defined(__GNUC__)
void *array[32]= {0}; // the less resources the better...
const int depth = backtrace(array, (int)GetArrayLength(array));
char **symbolstrings = backtrace_symbols(array, depth);
if (symbolstrings) {
fputs("Callstack:\n", f);
const int offset=3; // the first two entries are simply within our own exception handling code, third is within libc
for (int i = offset; i < depth; ++i) {
const char * const symbol = symbolstrings[i];
//fprintf(f, "\"%s\"\n", symbol);
char * realname = nullptr;
const char * const firstBracketName = strchr(symbol, '(');
const char * const firstBracketAddress = strchr(symbol, '[');
const char * const secondBracketAddress = strchr(firstBracketAddress, ']');
const char * const beginAddress = firstBracketAddress+3;
const int addressLen = int(secondBracketAddress-beginAddress);
const int padLen = int(ADDRESSDISPLAYLENGTH-addressLen);
//fprintf(f, "AddressDisplayLength=%d addressLen=%d padLen=%d\n", ADDRESSDISPLAYLENGTH, addressLen, padLen);
if (demangling && firstBracketName) {
const char * const plus = strchr(firstBracketName, '+');
if (plus && (plus>(firstBracketName+1))) {
char input_buffer[512]= {0};
strncpy(input_buffer, firstBracketName+1, plus-firstBracketName-1);
char output_buffer[1024]= {0};
size_t length = GetArrayLength(output_buffer);
int status=0;
realname = abi::__cxa_demangle(input_buffer, output_buffer, &length, &status); // non-NULL on success
}
}
fprintf(f, "#%d 0x",
i-offset);
if (padLen>0)
fprintf(f, "%0*d",
padLen, 0);
if (realname) {
fprintf(f, "%.*s in %s\n",
(int)(secondBracketAddress-firstBracketAddress-3), firstBracketAddress+3,
realname);
} else {
fprintf(f, "%.*s in %.*s\n",
(int)(secondBracketAddress-firstBracketAddress-3), firstBracketAddress+3,
(int)(firstBracketAddress-symbol), symbol);
}
}
free(symbolstrings);
} else {
fputs("Callstack could not be obtained\n", f);
}
#endif
}
/*
* Simple mapping
*/
static const char *signal_name(int signo)
{
for (size_t s=0; ssi_addr);
break;
case SIGFPE:
fprintf(f, "Internal error (caught signal %d=%s at 0x%p)\n",
signo, signame, info->si_addr);
break;
case SIGSEGV:
fprintf(f, "Internal error (caught signal %d=%s at 0x%p)\n",
signo, signame, info->si_addr);
break;
/*
case SIGBUS:
fprintf(f, "Internal error (caught signal %d=%s at 0x%p)\n",
signo, signame, info->si_addr);
break;
case SIGTRAP:
fprintf(f, "Internal error (caught signal %d=%s at 0x%p)\n",
signo, signame, info->si_addr);
break;
*/
case SIGINT:
bPrintCallstack=false;
break;
default:
fprintf(f, "Internal error (caught signal %d)\n",
signo);
break;
}
if (bPrintCallstack) {
print_stacktrace(f, true);
fputs("\nPlease report this to the cppcheck developers!\n", f);
}
abort();
}
#endif
#ifdef USE_WINDOWS_SEH
/*
* Any evaluation of the information about the exception needs to be done here!
*/
static int filterException(int code, PEXCEPTION_POINTERS ex)
{
// TODO we should try to extract more information here
// - address, read/write
switch (ex->ExceptionRecord->ExceptionCode) {
case EXCEPTION_ACCESS_VIOLATION:
fprintf(stderr, "Internal error (EXCEPTION_ACCESS_VIOLATION)\n");
break;
case EXCEPTION_IN_PAGE_ERROR:
fprintf(stderr, "Internal error (EXCEPTION_IN_PAGE_ERROR)\n");
break;
default:
fprintf(stderr, "Internal error (%d)\n",
code);
break;
}
fprintf(stderr, "Please report this to the cppcheck developers!\n");
return EXCEPTION_EXECUTE_HANDLER;
}
#endif
/**
* Signal/SEH handling
* Has to be clean for using with SEH on windows, i.e. no construction of C++ object instances is allowed!
* TODO Check for multi-threading issues!
*
*/
int CppCheckExecutor::check_wrapper(CppCheck& cppCheck, int argc, const char* const argv[])
{
#ifdef USE_WINDOWS_SEH
__try {
return check_internal(cppCheck, argc, argv);
} __except (filterException(GetExceptionCode(), GetExceptionInformation())) {
// reporting to stdout may not be helpful within a GUI application..
fprintf(stderr, "Internal error\n");
fprintf(stderr, "Please report this to the cppcheck developers!\n");
return -1;
}
#elif defined(USE_UNIX_SIGNAL_HANDLING)
struct sigaction act;
memset(&act, 0, sizeof(act));
act.sa_flags=SA_SIGINFO;
act.sa_sigaction=CppcheckSignalHandler;
for (std::size_t s=0; s callstack;
const std::string msg("Failed to load " + std::string(!std ? "std.cfg" : "posix.cfg") + ". Your Cppcheck installation is broken, please re-install.");
#ifdef CFGDIR
const std::string details("The Cppcheck binary was compiled with CFGDIR set to \"" +
std::string(CFGDIR) + "\" and will therefore search for "
"std.cfg in that path.");
#else
const std::string cfgfolder(Path::fromNativeSeparators(Path::getPathFromFilename(argv[0])) + "cfg");
const std::string details("The Cppcheck binary was compiled without CFGDIR set. Either the "
"std.cfg should be available in " + cfgfolder + " or the CFGDIR "
"should be configured.");
#endif
ErrorLogger::ErrorMessage errmsg(callstack, Severity::information, msg+" "+details, "failedToLoadCfg", false);
reportErr(errmsg);
return EXIT_FAILURE;
}
if (settings.reportProgress)
time1 = std::time(0);
if (settings._xml) {
reportErr(ErrorLogger::ErrorMessage::getXMLHeader(settings._xml_version));
}
unsigned int returnValue = 0;
if (settings._jobs == 1) {
// Single process
std::size_t totalfilesize = 0;
for (std::map::const_iterator i = _files.begin(); i != _files.end(); ++i) {
totalfilesize += i->second;
}
std::size_t processedsize = 0;
unsigned int c = 0;
for (std::map::const_iterator i = _files.begin(); i != _files.end(); ++i) {
if (!_settings->library.markupFile(i->first)
|| !_settings->library.processMarkupAfterCode(i->first)) {
returnValue += cppCheck.check(i->first);
processedsize += i->second;
if (!settings._errorsOnly)
reportStatus(c + 1, _files.size(), processedsize, totalfilesize);
c++;
}
}
// second loop to parse all markup files which may not work until all
// c/cpp files have been parsed and checked
for (std::map::const_iterator i = _files.begin(); i != _files.end(); ++i) {
if (_settings->library.markupFile(i->first) && _settings->library.processMarkupAfterCode(i->first)) {
returnValue += cppCheck.check(i->first);
processedsize += i->second;
if (!settings._errorsOnly)
reportStatus(c + 1, _files.size(), processedsize, totalfilesize);
c++;
}
}
cppCheck.checkFunctionUsage();
} else if (!ThreadExecutor::isEnabled()) {
std::cout << "No thread support yet implemented for this platform." << std::endl;
} else {
// Multiple processes
ThreadExecutor executor(_files, settings, *this);
returnValue = executor.check();
}
if (settings.isEnabled("information") || settings.checkConfiguration)
reportUnmatchedSuppressions(settings.nomsg.getUnmatchedGlobalSuppressions());
if (!settings.checkConfiguration) {
cppCheck.tooManyConfigsError("",0U);
if (settings.isEnabled("missingInclude") && Preprocessor::missingIncludeFlag) {
const std::list callStack;
ErrorLogger::ErrorMessage msg(callStack,
Severity::information,
"Cppcheck cannot find all the include files (use --check-config for details)\n"
"Cppcheck cannot find all the include files. Cppcheck can check the code without the "
"include files found. But the results will probably be more accurate if all the include "
"files are found. Please check your project's include directories and add all of them "
"as include directories for Cppcheck. To see what files Cppcheck cannot find use "
"--check-config.",
"missingInclude",
false);
reportInfo(msg);
}
}
if (settings._xml) {
reportErr(ErrorLogger::ErrorMessage::getXMLFooter(settings._xml_version));
}
_settings = 0;
if (returnValue)
return settings._exitCode;
else
return 0;
}
void CppCheckExecutor::reportErr(const std::string &errmsg)
{
// Alert only about unique errors
if (_errorList.find(errmsg) != _errorList.end())
return;
_errorList.insert(errmsg);
std::cerr << errmsg << std::endl;
}
void CppCheckExecutor::reportOut(const std::string &outmsg)
{
std::cout << outmsg << std::endl;
}
void CppCheckExecutor::reportProgress(const std::string &filename, const char stage[], const std::size_t value)
{
(void)filename;
if (!time1)
return;
// Report progress messages every 10 seconds
const std::time_t time2 = std::time(NULL);
if (time2 >= (time1 + 10)) {
time1 = time2;
// format a progress message
std::ostringstream ostr;
ostr << "progress: "
<< stage
<< ' ' << value << '%';
// Report progress message
reportOut(ostr.str());
}
}
void CppCheckExecutor::reportInfo(const ErrorLogger::ErrorMessage &msg)
{
reportErr(msg);
}
void CppCheckExecutor::reportStatus(std::size_t fileindex, std::size_t filecount, std::size_t sizedone, std::size_t sizetotal)
{
if (filecount > 1) {
std::ostringstream oss;
oss << fileindex << '/' << filecount
<< " files checked " <<
(sizetotal > 0 ? static_cast(static_cast(sizedone) / sizetotal*100) : 0)
<< "% done";
std::cout << oss.str() << std::endl;
}
}
void CppCheckExecutor::reportErr(const ErrorLogger::ErrorMessage &msg)
{
if (errorlist) {
reportOut(msg.toXML(false, _settings->_xml_version));
} else if (_settings->_xml) {
reportErr(msg.toXML(_settings->_verbose, _settings->_xml_version));
} else {
reportErr(msg.toString(_settings->_verbose, _settings->_outputFormat));
}
}