{

time1 = 0;

errorlist = false;

{

CmdLineParser parser(&_settings);

bool success = parser.ParseFromArgs(argc, argv);

cppcheck->settings(_settings); // copy the settings

if (success)

{

if (parser.GetShowVersion() && !parser.GetShowErrorMessages())

{

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(0);

}

// Check that all include paths exist

{

std::list<std::string>::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 and remove the

// non-existing path from the list.

std::cout << "cppcheck: warning: Couldn't find path given by -I '" + path + "'" << std::endl;

iter = _settings._includePaths.erase(iter);

}

}

}

std::vector<std::string> pathnames = parser.GetPathNames();

std::vector<std::string> filenames;

std::map<std::string, long> filesizes;

if (!pathnames.empty())

{

// Execute recursiveAddFiles() to each given file parameter

std::vector<std::string>::const_iterator iter;

for (iter = pathnames.begin(); iter != pathnames.end(); ++iter)

FileLister::recursiveAddFiles(filenames, filesizes, Path::toNativeSeparators(*iter));

}

if (!filenames.empty())

{

PathMatch matcher(parser.GetIgnoredPaths());

std::vector<std::string>::iterator iterBegin = filenames.begin();

for (int i = (int)filenames.size() - 1; i >= 0; i--)

{

if (matcher.Match(filenames[(unsigned int)i]))

filenames.erase(iterBegin + i);

}

}

else

{

std::cout << "cppcheck: error: could not find or open any of the paths given." << std::endl;

return false;

}

if (!filenames.empty())

{

std::vector<std::string>::iterator iter;

for (iter = filenames.begin(); iter != filenames.end(); ++iter)

{

_filenames.push_back(*iter);

_filesizes[*iter] = filesizes[*iter];

}

return true;

}

else

{

std::cout << "cppcheck: error: no files to check - all paths ignored." << std::endl;

return false;

}

{

Preprocessor::missingIncludeFlag = false;

CppCheck cppCheck(*this, true);

if (!parseFromArgs(&cppCheck, argc, argv))

{

return EXIT_FAILURE;

}

if (cppCheck.settings().reportProgress)

time1 = std::time(0);

_settings = cppCheck.settings();

if (_settings._xml)

{

reportErr(ErrorLogger::ErrorMessage::getXMLHeader(_settings._xml_version));

}

unsigned int returnValue = 0;

if (_settings._jobs == 1)

{

// Single process

long totalfilesize = 0;

for (std::map<std::string, long>::const_iterator i = _filesizes.begin(); i != _filesizes.end(); ++i)

{

totalfilesize += i->second;

}

long processedsize = 0;

for (unsigned int c = 0; c < _filenames.size(); c++)

{

returnValue += cppCheck.check(_filenames[c]);

if (_filesizes.find(_filenames[c]) != _filesizes.end())

{

processedsize += _filesizes[_filenames[c]];

}

if (!_settings._errorsOnly)

reportStatus(c + 1, _filenames.size(), processedsize, totalfilesize);

}

}

else if (!ThreadExecutor::isEnabled())

{

std::cout << "No thread support yet implemented for this platform." << std::endl;

}

else

{

// Multiple processes

Settings &settings = cppCheck.settings();

ThreadExecutor executor(_filenames, _filesizes, settings, *this);

returnValue = executor.check();

}

if (!cppCheck.settings().checkConfiguration)

{

reportUnmatchedSuppressions(cppCheck.settings().nomsg.getUnmatchedGlobalSuppressions());

if (Preprocessor::missingIncludeFlag)

{

const std::list<ErrorLogger::ErrorMessage::FileLocation> 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. Cpppcheck 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);

reportErr(msg);

}

}

if (_settings._xml)

{

reportErr(ErrorLogger::ErrorMessage::getXMLFooter(_settings._xml_version));

}

if (returnValue)

return _settings._exitCode;

else

return 0;

{

(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;

// current time in the format "Www Mmm dd hh:mm:ss yyyy"

const std::string str(std::ctime(&time2));

// format a progress message

std::ostringstream ostr;

ostr << "progress: "

<< stage

<< " " << int(value) << "%";

if (_settings._verbose)

ostr << " time=" << str.substr(11, 8);

// Report progress message

reportOut(ostr.str());

}

{

if (filecount > 1)

{

std::ostringstream oss;

oss << fileindex << "/" << filecount

<< " files checked " <<

(sizetotal > 0 ? static_cast<long>(static_cast<double>(sizedone) / sizetotal*100) : 0)

<< "% done";

std::cout << oss.str() << std::endl;

}

{

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));

}