walkero
/
cppcheck
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

Revert 'project' - it is not ready yet

This commit is contained in:
Daniel Marjamäki 2016-08-07 17:10:37 +02:00
parent 09a83f2cc8
commit c586ae8cbe
14 changed files with 278 additions and 661 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
cli/cmdlineparser.cpp
View File

@ -480,10 +480,6 @@ bool CmdLineParser::ParseFromArgs(int argc, const char* const argv[])
if (!CppCheckExecutor::tryLoadLibrary(_settings->library, argv[0], argv[i]+10))
return false;
}
// experimental --project
else if (std::strncmp(argv[i], "--project=", 10) == 0) {
_settings->project.load(argv[i]+10);
}
// Report progress
else if (std::strcmp(argv[i], "--report-progress") == 0) {
@ -770,7 +766,7 @@ bool CmdLineParser::ParseFromArgs(int argc, const char* const argv[])
}
// Print error only if we have "real" command and expect files
if (!_exitAfterPrint && _pathnames.empty() && _settings->project.fileSettings.empty()) {
if (!_exitAfterPrint && _pathnames.empty()) {
PrintMessage("cppcheck: No C or C++ source files found.");
return false;
}

11
cli/cppcheckexecutor.cpp
View File

@ -154,7 +154,7 @@ bool CppCheckExecutor::parseFromArgs(CppCheck *cppcheck, int argc, const char* c
FileLister::recursiveAddFiles(_files, Path::toNativeSeparators(*iter), _settings->library.markupExtensions(), matcher);
}
if (_files.empty() && settings.project.fileSettings.empty()) {
if (_files.empty()) {
std::cout << "cppcheck: error: could not find or open any of the paths given." << std::endl;
if (!ignored.empty())
std::cout << "cppcheck: Maybe all paths were ignored?" << std::endl;
@ -825,15 +825,6 @@ int CppCheckExecutor::check_internal(CppCheck& cppcheck, int /*argc*/, const cha
}
}
// filesettings
c = 0;
for (std::list<Project::FileSettings>::const_iterator fs = settings.project.fileSettings.begin(); fs != settings.project.fileSettings.end(); ++fs) {
returnValue += cppcheck.check((Project::FileSettings)*fs);
++c;
if (!settings.quiet)
reportStatus(c, settings.project.fileSettings.size(), c, settings.project.fileSettings.size());
}
// second loop to parse all markup files which may not work until all
// c/cpp files have been parsed and checked
for (std::map<std::string, std::size_t>::const_iterator i = _files.begin(); i != _files.end(); ++i) {

24
cli/threadexecutor.cpp
View File

@ -352,11 +352,10 @@ unsigned int ThreadExecutor::check()
HANDLE *threadHandles = new HANDLE[_settings.jobs];
_itNextFile = _files.begin();
_itNextFileSettings = _settings.project.fileSettings.begin();
_processedFiles = 0;
_processedSize = 0;
_totalFiles = _files.size() + _settings.project.fileSettings.size();
_totalFiles = _files.size();
_totalFileSize = 0;
for (std::map<std::string, std::size_t>::const_iterator i = _files.begin(); i != _files.end(); ++i) {
_totalFileSize += i->second;
@ -416,8 +415,7 @@ unsigned int __stdcall ThreadExecutor::threadProc(void *args)
unsigned int result = 0;
ThreadExecutor *threadExecutor = static_cast<ThreadExecutor*>(args);
std::map<std::string, std::size_t>::const_iterator &itFile = threadExecutor->_itNextFile;
std::list<Project::FileSettings>::const_iterator &itFileSettings = threadExecutor->_itNextFileSettings;
std::map<std::string, std::size_t>::const_iterator &it = threadExecutor->_itNextFile;
// guard static members of CppCheck against concurrent access
EnterCriticalSection(&threadExecutor->_fileSync);
@ -426,16 +424,14 @@ unsigned int __stdcall ThreadExecutor::threadProc(void *args)
fileChecker.settings() = threadExecutor->_settings;
for (;;) {
if (itFile == threadExecutor->_files.end() && itFileSettings == threadExecutor->_settings.project.fileSettings.end()) {
if (it == threadExecutor->_files.end()) {
LeaveCriticalSection(&threadExecutor->_fileSync);
break;
}
std::size_t fileSize = 0;
if (itFile != threadExecutor->_files.end()) {
const std::string &file = itFile->first;
fileSize = itFile->second;
++itFile;
}
const std::string &file = it->first;
const std::size_t fileSize = it->second;
++it;
LeaveCriticalSection(&threadExecutor->_fileSync);
@ -447,12 +443,6 @@ unsigned int __stdcall ThreadExecutor::threadProc(void *args)
// Read file from a file
result += fileChecker.check(file);
}
} else { // file settings..
const Project::FileSettings &fs = *itFileSettings;
++itFileSettings;
LeaveCriticalSection(&threadExecutor->_fileSync);
result += fileChecker.check(fs);
}
EnterCriticalSection(&threadExecutor->_fileSync);

2
cli/threadexecutor.h
View File

@ -23,7 +23,6 @@
#include <string>
#include <list>
#include "errorlogger.h"
#include "project.h"
#if (defined(__GNUC__) || defined(__sun)) && !defined(__MINGW32__)
#define THREADING_MODEL_FORK
@ -110,7 +109,6 @@ private:
std::map<std::string, std::string> _fileContents;
std::map<std::string, std::size_t>::const_iterator _itNextFile;
std::list<Project::FileSettings>::const_iterator _itNextFileSettings;
std::size_t _processedFiles;
std::size_t _totalFiles;
std::size_t _processedSize;

12
lib/cppcheck.cpp
View File

@ -80,18 +80,6 @@ unsigned int CppCheck::check(const std::string &path, const std::string &content
return processFile(path, iss);
}
unsigned int CppCheck::check(const Project::FileSettings &fs)
{
CppCheck temp(*this, _useGlobalSuppressions);
temp._settings.userDefines = fs.defines;
temp._settings.userIncludes = fs.includePaths;
// TODO: temp._settings.userUndefs = fs.undefs;
if (fs.platformType != Settings::Unspecified) {
temp._settings.platformType = fs.platformType;
}
return temp.check(fs.filename);
}
unsigned int CppCheck::processFile(const std::string& filename, std::istream& fileStream)
{
exitcode = 0;

1
lib/cppcheck.h
View File

@ -68,7 +68,6 @@ public:
* settings()).
*/
unsigned int check(const std::string &path);
unsigned int check(const Project::FileSettings &fs);
/**
* @brief Check the file.

4
lib/cppcheck.vcxproj
View File

@ -78,9 +78,7 @@
<ClCompile Include="library.cpp" />
<ClCompile Include="mathlib.cpp" />
<ClCompile Include="path.cpp" />
<ClCompile Include="platform.cpp" />
<ClCompile Include="preprocessor.cpp" />
<ClCompile Include="project.cpp" />
<ClCompile Include="settings.cpp" />
<ClCompile Include="suppressions.cpp" />
<ClCompile Include="symboldatabase.cpp" />
@ -127,9 +125,7 @@
<ClInclude Include="library.h" />
<ClInclude Include="mathlib.h" />
<ClInclude Include="path.h" />
<ClInclude Include="platform.h" />
<ClInclude Include="preprocessor.h" />
<ClInclude Include="project.h" />
<ClInclude Include="settings.h" />
<ClInclude Include="suppressions.h" />
<ClInclude Include="symboldatabase.h" />

12
lib/cppcheck.vcxproj.filters
View File

@ -143,12 +143,6 @@
<ClCompile Include="..\externals\simplecpp\simplecpp.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="project.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="platform.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="checkbufferoverrun.h">
@ -292,12 +286,6 @@
<ClInclude Include="..\externals\simplecpp\simplecpp.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="project.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="platform.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="version.rc" />

217
lib/platform.cpp
View File

@ -1,217 +0,0 @@
/*
* Cppcheck - A tool for static C/C++ code analysis
* Copyright (C) 2007-2016 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 <http://www.gnu.org/licenses/>.
*/
#include "tinyxml2.h"
Platform::Platform()
{
// This assumes the code you are checking is for the same architecture this is compiled on.
#if defined(_WIN64)
platform(Win64);
#elif defined(_WIN32)
platform(Win32A);
#else
platform(Native);
#endif
}
bool Platform::platform(Platform::PlatformType type)
{
switch (type) {
case Unspecified:
platformType = type;
sizeof_bool = sizeof(bool);
sizeof_short = sizeof(short);
sizeof_int = sizeof(int);
sizeof_long = sizeof(long);
sizeof_long_long = sizeof(long long);
sizeof_float = sizeof(float);
sizeof_double = sizeof(double);
sizeof_long_double = sizeof(long double);
sizeof_wchar_t = sizeof(wchar_t);
sizeof_size_t = sizeof(std::size_t);
sizeof_pointer = sizeof(void *);
defaultSign = '\0';
char_bit = 8;
short_bit = char_bit * sizeof_short;
int_bit = char_bit * sizeof_int;
long_bit = char_bit * sizeof_long;
long_long_bit = char_bit * sizeof_long_long;
return true;
case Native: // same as system this code was compile on
platformType = type;
sizeof_bool = sizeof(bool);
sizeof_short = sizeof(short);
sizeof_int = sizeof(int);
sizeof_long = sizeof(long);
sizeof_long_long = sizeof(long long);
sizeof_float = sizeof(float);
sizeof_double = sizeof(double);
sizeof_long_double = sizeof(long double);
sizeof_wchar_t = sizeof(wchar_t);
sizeof_size_t = sizeof(std::size_t);
sizeof_pointer = sizeof(void *);
{
char x = -1;
defaultSign = (x < 0) ? 's' : 'u';
}
char_bit = 8;
short_bit = char_bit * sizeof_short;
int_bit = char_bit * sizeof_int;
long_bit = char_bit * sizeof_long;
long_long_bit = char_bit * sizeof_long_long;
return true;
case Win32W:
case Win32A:
platformType = type;
sizeof_bool = 1; // 4 in Visual C++ 4.2
sizeof_short = 2;
sizeof_int = 4;
sizeof_long = 4;
sizeof_long_long = 8;
sizeof_float = 4;
sizeof_double = 8;
sizeof_long_double = 8;
sizeof_wchar_t = 2;
sizeof_size_t = 4;
sizeof_pointer = 4;
defaultSign = '\0';
char_bit = 8;
short_bit = char_bit * sizeof_short;
int_bit = char_bit * sizeof_int;
long_bit = char_bit * sizeof_long;
long_long_bit = char_bit * sizeof_long_long;
return true;
case Win64:
platformType = type;
sizeof_bool = 1;
sizeof_short = 2;
sizeof_int = 4;
sizeof_long = 4;
sizeof_long_long = 8;
sizeof_float = 4;
sizeof_double = 8;
sizeof_long_double = 8;
sizeof_wchar_t = 2;
sizeof_size_t = 8;
sizeof_pointer = 8;
defaultSign = '\0';
char_bit = 8;
short_bit = char_bit * sizeof_short;
int_bit = char_bit * sizeof_int;
long_bit = char_bit * sizeof_long;
long_long_bit = char_bit * sizeof_long_long;
return true;
case Unix32:
platformType = type;
sizeof_bool = 1;
sizeof_short = 2;
sizeof_int = 4;
sizeof_long = 4;
sizeof_long_long = 8;
sizeof_float = 4;
sizeof_double = 8;
sizeof_long_double = 12;
sizeof_wchar_t = 4;
sizeof_size_t = 4;
sizeof_pointer = 4;
defaultSign = '\0';
char_bit = 8;
short_bit = char_bit * sizeof_short;
int_bit = char_bit * sizeof_int;
long_bit = char_bit * sizeof_long;
long_long_bit = char_bit * sizeof_long_long;
return true;
case Unix64:
platformType = type;
sizeof_bool = 1;
sizeof_short = 2;
sizeof_int = 4;
sizeof_long = 8;
sizeof_long_long = 8;
sizeof_float = 4;
sizeof_double = 8;
sizeof_long_double = 16;
sizeof_wchar_t = 4;
sizeof_size_t = 8;
sizeof_pointer = 8;
defaultSign = '\0';
char_bit = 8;
short_bit = char_bit * sizeof_short;
int_bit = char_bit * sizeof_int;
long_bit = char_bit * sizeof_long;
long_long_bit = char_bit * sizeof_long_long;
return true;
}
// unsupported platform
return false;
}
bool Platform::platformFile(const std::string &filename)
{
// open file..
tinyxml2::XMLDocument doc;
if (doc.LoadFile(filename.c_str()) != tinyxml2::XML_SUCCESS)
return false;
const tinyxml2::XMLElement * const rootnode = doc.FirstChildElement();
if (!rootnode || std::strcmp(rootnode->Name(), "platform") != 0)
return false;
for (const tinyxml2::XMLElement *node = rootnode->FirstChildElement(); node; node = node->NextSiblingElement()) {
if (std::strcmp(node->Name(), "default-sign") == 0)
defaultSign = *node->GetText();
else if (std::strcmp(node->Name(), "char_bit") == 0)
char_bit = std::atoi(node->GetText());
else if (std::strcmp(node->Name(), "sizeof") == 0) {
for (const tinyxml2::XMLElement *sz = node->FirstChildElement(); sz; sz = sz->NextSiblingElement()) {
if (std::strcmp(node->Name(), "short") == 0)
sizeof_short = std::atoi(node->GetText());
else if (std::strcmp(node->Name(), "int") == 0)
sizeof_int = std::atoi(node->GetText());
else if (std::strcmp(node->Name(), "long") == 0)
sizeof_long = std::atoi(node->GetText());
else if (std::strcmp(node->Name(), "long-long") == 0)
sizeof_long_long = std::atoi(node->GetText());
else if (std::strcmp(node->Name(), "float") == 0)
sizeof_float = std::atoi(node->GetText());
else if (std::strcmp(node->Name(), "double") == 0)
sizeof_double = std::atoi(node->GetText());
else if (std::strcmp(node->Name(), "long-double") == 0)
sizeof_long_double = std::atoi(node->GetText());
else if (std::strcmp(node->Name(), "pointer") == 0)
sizeof_pointer = std::atoi(node->GetText());
else if (std::strcmp(node->Name(), "size_t") == 0)
sizeof_size_t = std::atoi(node->GetText());
else if (std::strcmp(node->Name(), "wchar_t") == 0)
sizeof_wchar_t = std::atoi(node->GetText());
}
}
}
short_bit = char_bit * sizeof_short;
int_bit = char_bit * sizeof_int;
long_bit = char_bit * sizeof_long;
long_long_bit = char_bit * sizeof_long_long;
return true;
}

107
lib/platform.h
View File

@ -1,107 +0,0 @@
/*
* Cppcheck - A tool for static C/C++ code analysis
* Copyright (C) 2007-2016 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 <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
#ifndef platformH
#define platformH
//---------------------------------------------------------------------------
#include <string>
/// @addtogroup Core
/// @{
/**
* @brief Platform settings
*/
struct CPPCHECKLIB Platform {
public:
Platform();
virtual ~Platform(){}
unsigned int char_bit; /// bits in char
unsigned int short_bit; /// bits in short
unsigned int int_bit; /// bits in int
unsigned int long_bit; /// bits in long
unsigned int long_long_bit; /// bits in long long
/** size of standard types */
unsigned int sizeof_bool;
unsigned int sizeof_short;
unsigned int sizeof_int;
unsigned int sizeof_long;
unsigned int sizeof_long_long;
unsigned int sizeof_float;
unsigned int sizeof_double;
unsigned int sizeof_long_double;
unsigned int sizeof_wchar_t;
unsigned int sizeof_size_t;
unsigned int sizeof_pointer;
char defaultSign; // unsigned:'u', signed:'s', unknown:'\0'
enum PlatformType {
Unspecified, // No platform specified
Native, // whatever system this code was compiled on
Win32A,
Win32W,
Win64,
Unix32,
Unix64
};
/** platform type */
PlatformType platformType;
/** set the platform type for predefined platforms */
bool platform(PlatformType type);
/** set the platform type for user specified platforms */
bool platformFile(const std::string &filename);
/**
* @brief Returns true if platform type is Windows
* @return true if Windows platform type.
*/
bool isWindowsPlatform() const {
return platformType == Win32A ||
platformType == Win32W ||
platformType == Win64;
}
const char *platformString() const {
switch (platformType) {
case Unix32:
return "unix32";
case Unix64:
return "unix64";
case Win32A:
return "win32A";
case Win32W:
return "win32W";
case Win64:
return "win64";
default:
return "unknown";
}
}
};
/// @}
//---------------------------------------------------------------------------
#endif // platformH

204
lib/project.cpp
View File

@ -1,204 +0,0 @@
/*
* Cppcheck - A tool for static C/C++ code analysis
* Copyright (C) 2007-2016 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 <http://www.gnu.org/licenses/>.
*/
#include "project.h"
#include "path.h"
#include "tokenlist.h"
#include "tinyxml2.h"
#include <fstream>
void Project::load(const std::string &filename) {
std::ifstream fin(filename);
if (!fin.is_open())
return;
if (filename == "compile_commands.json") {
loadCompileCommands(fin);
} else if (filename.find(".vcxproj") != std::string::npos) {
loadVcxproj(filename);
}
}
void Project::loadCompileCommands(std::istream &istr) {
std::map<std::string, std::string> values;
Settings settings;
TokenList tokenList(&settings);
tokenList.createTokens(istr);
for (const Token *tok = tokenList.front(); tok; tok = tok->next()) {
if (Token::Match(tok, "%str% : %str% [,}]")) {
std::string key = tok->str();
std::string value = tok->strAt(2);
values[key.substr(1, key.size() - 2U)] = value.substr(1, value.size() - 2U);
}
else if (tok->str() == "}") {
if (!values["file"].empty() && !values["command"].empty()) {
struct FileSettings fs;
fs.filename = Path::fromNativeSeparators(values["file"]);
std::string command = values["command"];
std::string::size_type pos = 0;
while (std::string::npos != (pos = command.find(" ",pos))) {
pos++;
if (pos >= command.size())
break;
if (command[pos] != '/' && command[pos] != '-')
continue;
pos++;
if (pos >= command.size())
break;
char F = command[pos++];
std::string fval;
while (pos < command.size() && command[pos] != ' ')
fval += command[pos++];
if (F=='D')
fs.defines += fval + ";";
else if (F=='U')
fs.undefs.insert(fval);
else if (F=='I')
fs.includePaths.push_back(fval);
}
fileSettings.push_back(fs);
}
values.clear();
}
}
}
namespace {
struct ProjectConfiguration {
ProjectConfiguration(const tinyxml2::XMLElement *cfg) {
for (const tinyxml2::XMLElement *e = cfg->FirstChildElement(); e; e = e->NextSiblingElement()) {
if (std::strcmp(e->Name(),"Configuration")==0)
configuration = e->GetText();
else if (std::strcmp(e->Name(),"Platform")==0)
platform = e->GetText();
}
}
std::string configuration;
std::string platform;
};
struct ItemDefinitionGroup {
ItemDefinitionGroup(const tinyxml2::XMLElement *idg) {
const char *condAttr = idg->Attribute("Condition");
if (condAttr)
condition = condAttr;
for (const tinyxml2::XMLElement *e1 = idg->FirstChildElement(); e1; e1 = e1->NextSiblingElement()) {
if (std::strcmp(e1->Name(), "ClCompile") != 0)
continue;
for (const tinyxml2::XMLElement *e = e1->FirstChildElement(); e; e = e->NextSiblingElement()) {
if (std::strcmp(e->Name(), "PreprocessorDefinitions") == 0)
preprocessorDefinitions = e->GetText();
else if (std::strcmp(e->Name(), "AdditionalIncludeDirectories") == 0)
additionalIncludePaths = e->GetText();
}
}
}
bool conditionIsTrue(const ProjectConfiguration &p) const {
std::string c = condition;
std::string::size_type pos = 0;
while ((pos = c.find("$(Configuration)")) != std::string::npos) {
c.erase(pos,16);
c.insert(pos,p.configuration);
}
while ((pos = c.find("$(Platform)")) != std::string::npos) {
c.erase(pos, 11);
c.insert(pos, p.platform);
}
// TODO : Better evaluation
Settings s;
std::istringstream istr(c);
TokenList tokens(&s);
tokens.createTokens(istr);
tokens.createAst();
for (const Token *tok = tokens.front(); tok; tok = tok->next()) {
if (tok->str() == "==" && tok->astOperand1() && tok->astOperand2() && tok->astOperand1()->str() == tok->astOperand2()->str())
return true;
}
return false;
}
std::string condition;
std::string preprocessorDefinitions;
std::string additionalIncludePaths;
};
};
static std::list<std::string> toStringList(const std::string &s) {
std::list<std::string> ret;
std::string::size_type pos1 = 0;
std::string::size_type pos2;
while ((pos2 = s.find(";",pos1)) != std::string::npos) {
ret.push_back(s.substr(pos1, pos2-pos1));
pos1 = pos2 + 1;
if (pos1 >= s.size())
break;
}
if (pos1 < s.size())
ret.push_back(s.substr(pos1));
return ret;
}
void Project::loadVcxproj(const std::string &filename)
{
std::list<ProjectConfiguration> projectConfigurationList;
std::list<std::string> compileList;
std::list<ItemDefinitionGroup> itemDefinitionGroupList;
tinyxml2::XMLDocument doc;
tinyxml2::XMLError error = doc.LoadFile(filename.c_str());
if (error != tinyxml2::XML_SUCCESS)
return;
const tinyxml2::XMLElement * const rootnode = doc.FirstChildElement();
if (rootnode == nullptr)
return;
for (const tinyxml2::XMLElement *node = rootnode->FirstChildElement(); node; node = node->NextSiblingElement()) {
if (std::strcmp(node->Name(), "ItemGroup") == 0) {
if (node->Attribute("Label") && std::strcmp(node->Attribute("Label"), "ProjectConfigurations") == 0) {
for (const tinyxml2::XMLElement *cfg = node->FirstChildElement(); cfg; cfg = cfg->NextSiblingElement()) {
if (std::strcmp(cfg->Name(), "ProjectConfiguration") == 0)
projectConfigurationList.push_back(ProjectConfiguration(cfg));
}
} else {
for (const tinyxml2::XMLElement *e = node->FirstChildElement(); e; e = e->NextSiblingElement()) {
if (std::strcmp(e->Name(), "ClCompile") == 0)
compileList.push_back(e->Attribute("Include"));
}
}
} else if (std::strcmp(node->Name(), "ItemDefinitionGroup") == 0) {
itemDefinitionGroupList.push_back(ItemDefinitionGroup(node));
}
}
for (std::list<std::string>::const_iterator c = compileList.begin(); c != compileList.end(); ++c) {
for (std::list<ProjectConfiguration>::const_iterator p = projectConfigurationList.begin(); p != projectConfigurationList.end(); ++p) {
for (std::list<ItemDefinitionGroup>::const_iterator i = itemDefinitionGroupList.begin(); i != itemDefinitionGroupList.end(); ++i) {
if (!i->conditionIsTrue(*p))
continue;
FileSettings fs;
fs.filename = Path::simplifyPath(Path::getPathFromFilename(filename) + *c);
fs.defines = i->preprocessorDefinitions;
fs.includePaths = toStringList(i->additionalIncludePaths);
if (p->platform == "Win32")
fs.platformType = Settings::Win32W;
else if (p->platform == "x64")
fs.platformType = Settings::Win64;
fileSettings.push_back(fs);
}
}
}
}

58
lib/project.h
View File

@ -1,58 +0,0 @@
/*
* Cppcheck - A tool for static C/C++ code analysis
* Copyright (C) 2007-2016 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 <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
#ifndef projectH
#define projectH
//---------------------------------------------------------------------------
#include <list>
#include <string>
#include <set>
#include "config.h"
#include "platform.h"
/// @addtogroup Core
/// @{
/**
* @brief Project settings.
*/
class CPPCHECKLIB Project {
public:
/** File settings. Multiple configurations for a file is allowed. */
struct FileSettings {
FileSettings() : platformType(Platform::Unspecified) {}
std::string filename;
std::string defines;
std::set<std::string> undefs;
std::list<std::string> includePaths;
Platform::PlatformType platformType;
};
std::list<FileSettings> fileSettings;
void load(const std::string &filename);
private:
void loadCompileCommands(std::istream &istr);
void loadVcxproj(const std::string &filename);
};
/// @}
//---------------------------------------------------------------------------
#endif // projectH

193
lib/settings.cpp
View File

@ -19,6 +19,7 @@
#include "settings.h"
#include "preprocessor.h" // Preprocessor
#include "utils.h"
#include "tinyxml2.h"
#include <fstream>
#include <set>
@ -50,6 +51,14 @@ Settings::Settings()
checkConfiguration(false),
checkLibrary(false)
{
// This assumes the code you are checking is for the same architecture this is compiled on.
#if defined(_WIN64)
platform(Win64);
#elif defined(_WIN32)
platform(Win32A);
#else
platform(Native);
#endif
}
namespace {
@ -128,3 +137,187 @@ const std::string &Settings::append() const
{
return _append;
}
bool Settings::platform(PlatformType type)
{
switch (type) {
case Unspecified:
platformType = type;
sizeof_bool = sizeof(bool);
sizeof_short = sizeof(short);
sizeof_int = sizeof(int);
sizeof_long = sizeof(long);
sizeof_long_long = sizeof(long long);
sizeof_float = sizeof(float);
sizeof_double = sizeof(double);
sizeof_long_double = sizeof(long double);
sizeof_wchar_t = sizeof(wchar_t);
sizeof_size_t = sizeof(std::size_t);
sizeof_pointer = sizeof(void *);
defaultSign = '\0';
char_bit = 8;
short_bit = char_bit * sizeof_short;
int_bit = char_bit * sizeof_int;
long_bit = char_bit * sizeof_long;
long_long_bit = char_bit * sizeof_long_long;
return true;
case Native: // same as system this code was compile on
platformType = type;
sizeof_bool = sizeof(bool);
sizeof_short = sizeof(short);
sizeof_int = sizeof(int);
sizeof_long = sizeof(long);
sizeof_long_long = sizeof(long long);
sizeof_float = sizeof(float);
sizeof_double = sizeof(double);
sizeof_long_double = sizeof(long double);
sizeof_wchar_t = sizeof(wchar_t);
sizeof_size_t = sizeof(std::size_t);
sizeof_pointer = sizeof(void *);
{
char x = -1;
defaultSign = (x < 0) ? 's' : 'u';
}
char_bit = 8;
short_bit = char_bit * sizeof_short;
int_bit = char_bit * sizeof_int;
long_bit = char_bit * sizeof_long;
long_long_bit = char_bit * sizeof_long_long;
return true;
case Win32W:
case Win32A:
platformType = type;
sizeof_bool = 1; // 4 in Visual C++ 4.2
sizeof_short = 2;
sizeof_int = 4;
sizeof_long = 4;
sizeof_long_long = 8;
sizeof_float = 4;
sizeof_double = 8;
sizeof_long_double = 8;
sizeof_wchar_t = 2;
sizeof_size_t = 4;
sizeof_pointer = 4;
defaultSign = '\0';
char_bit = 8;
short_bit = char_bit * sizeof_short;
int_bit = char_bit * sizeof_int;
long_bit = char_bit * sizeof_long;
long_long_bit = char_bit * sizeof_long_long;
return true;
case Win64:
platformType = type;
sizeof_bool = 1;
sizeof_short = 2;
sizeof_int = 4;
sizeof_long = 4;
sizeof_long_long = 8;
sizeof_float = 4;
sizeof_double = 8;
sizeof_long_double = 8;
sizeof_wchar_t = 2;
sizeof_size_t = 8;
sizeof_pointer = 8;
defaultSign = '\0';
char_bit = 8;
short_bit = char_bit * sizeof_short;
int_bit = char_bit * sizeof_int;
long_bit = char_bit * sizeof_long;
long_long_bit = char_bit * sizeof_long_long;
return true;
case Unix32:
platformType = type;
sizeof_bool = 1;
sizeof_short = 2;
sizeof_int = 4;
sizeof_long = 4;
sizeof_long_long = 8;
sizeof_float = 4;
sizeof_double = 8;
sizeof_long_double = 12;
sizeof_wchar_t = 4;
sizeof_size_t = 4;
sizeof_pointer = 4;
defaultSign = '\0';
char_bit = 8;
short_bit = char_bit * sizeof_short;
int_bit = char_bit * sizeof_int;
long_bit = char_bit * sizeof_long;
long_long_bit = char_bit * sizeof_long_long;
return true;
case Unix64:
platformType = type;
sizeof_bool = 1;
sizeof_short = 2;
sizeof_int = 4;
sizeof_long = 8;
sizeof_long_long = 8;
sizeof_float = 4;
sizeof_double = 8;
sizeof_long_double = 16;
sizeof_wchar_t = 4;
sizeof_size_t = 8;
sizeof_pointer = 8;
defaultSign = '\0';
char_bit = 8;
short_bit = char_bit * sizeof_short;
int_bit = char_bit * sizeof_int;
long_bit = char_bit * sizeof_long;
long_long_bit = char_bit * sizeof_long_long;
return true;
}
// unsupported platform
return false;
}
bool Settings::platformFile(const std::string &filename)
{
// open file..
tinyxml2::XMLDocument doc;
if (doc.LoadFile(filename.c_str()) != tinyxml2::XML_SUCCESS)
return false;
const tinyxml2::XMLElement * const rootnode = doc.FirstChildElement();
if (!rootnode || std::strcmp(rootnode->Name(),"platform") != 0)
return false;
for (const tinyxml2::XMLElement *node = rootnode->FirstChildElement(); node; node = node->NextSiblingElement()) {
if (std::strcmp(node->Name(), "default-sign") == 0)
defaultSign = *node->GetText();
else if (std::strcmp(node->Name(), "char_bit") == 0)
char_bit = std::atoi(node->GetText());
else if (std::strcmp(node->Name(), "sizeof") == 0) {
for (const tinyxml2::XMLElement *sz = node->FirstChildElement(); sz; sz = sz->NextSiblingElement()) {
if (std::strcmp(node->Name(), "short") == 0)
sizeof_short = std::atoi(node->GetText());
else if (std::strcmp(node->Name(), "int") == 0)
sizeof_int = std::atoi(node->GetText());
else if (std::strcmp(node->Name(), "long") == 0)
sizeof_long = std::atoi(node->GetText());
else if (std::strcmp(node->Name(), "long-long") == 0)
sizeof_long_long = std::atoi(node->GetText());
else if (std::strcmp(node->Name(), "float") == 0)
sizeof_float = std::atoi(node->GetText());
else if (std::strcmp(node->Name(), "double") == 0)
sizeof_double = std::atoi(node->GetText());
else if (std::strcmp(node->Name(), "long-double") == 0)
sizeof_long_double = std::atoi(node->GetText());
else if (std::strcmp(node->Name(), "pointer") == 0)
sizeof_pointer = std::atoi(node->GetText());
else if (std::strcmp(node->Name(), "size_t") == 0)
sizeof_size_t = std::atoi(node->GetText());
else if (std::strcmp(node->Name(), "wchar_t") == 0)
sizeof_wchar_t = std::atoi(node->GetText());
}
}
}
short_bit = char_bit * sizeof_short;
int_bit = char_bit * sizeof_int;
long_bit = char_bit * sizeof_long;
long_long_bit = char_bit * sizeof_long_long;
return true;
}

72
lib/settings.h
View File

@ -27,8 +27,6 @@
#include <set>
#include "config.h"
#include "library.h"
#include "platform.h"
#include "project.h"
#include "suppressions.h"
#include "standards.h"
#include "errorlogger.h"
@ -37,12 +35,13 @@
/// @addtogroup Core
/// @{
/**
* @brief This is just a container for general settings so that we don't need
* to pass individual values to functions or constructors now or in the
* future when we might have even more detailed settings.
*/
class CPPCHECKLIB Settings : public Platform {
class CPPCHECKLIB Settings {
private:
/** @brief Code to append in the checks */
std::string _append;
@ -244,7 +243,72 @@ public:
/** Struct contains standards settings */
Standards standards;
Project project;
unsigned int char_bit; /// bits in char
unsigned int short_bit; /// bits in short
unsigned int int_bit; /// bits in int
unsigned int long_bit; /// bits in long
unsigned int long_long_bit; /// bits in long long
/** size of standard types */
unsigned int sizeof_bool;
unsigned int sizeof_short;
unsigned int sizeof_int;
unsigned int sizeof_long;
unsigned int sizeof_long_long;
unsigned int sizeof_float;
unsigned int sizeof_double;
unsigned int sizeof_long_double;
unsigned int sizeof_wchar_t;
unsigned int sizeof_size_t;
unsigned int sizeof_pointer;
char defaultSign; // unsigned:'u', signed:'s', unknown:'\0'
enum PlatformType {
Unspecified, // No platform specified
Native, // whatever system this code was compiled on
Win32A,
Win32W,
Win64,
Unix32,
Unix64
};
/** platform type */
PlatformType platformType;
/** set the platform type for predefined platforms */
bool platform(PlatformType type);
/** set the platform type for user specified platforms */
bool platformFile(const std::string &filename);
/**
* @brief Returns true if platform type is Windows
* @return true if Windows platform type.
*/
bool isWindowsPlatform() const {
return platformType == Win32A ||
platformType == Win32W ||
platformType == Win64;
}
const char *platformString() const {
switch (platformType) {
case Unix32:
return "unix32";
case Unix64:
return "unix64";
case Win32A:
return "win32A";
case Win32W:
return "win32W";
case Win64:
return "win64";
default:
return "unknown";
}
}
/**
* @brief return true if a file is to be excluded from configuration checking