/*

* Cppcheck - A tool for static C/C++ code analysis

* Copyright (C) 2007-2025 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 "importproject.h"

#include "path.h"

#include "pathmatch.h"

#include "settings.h"

#include "standards.h"

#include "suppressions.h"

#include "token.h"

#include "tokenlist.h"

#include "utils.h"

#include <algorithm>

#include <cstdlib>

#include <cstring>

#include <fstream>

#include <iostream>

#include <iterator>

#include <stack>

#include <unordered_set>

#include <utility>

#include <vector>

#include "xml.h"

#include "json.h"

void ImportProject::ignorePaths(const std::vector<std::string> &ipaths, bool debug)

{

PathMatch matcher(ipaths, Path::getCurrentPath());

for (auto it = fileSettings.cbegin(); it != fileSettings.cend();) {

if (matcher.match(it->filename())) {

if (debug)

std::cout << "ignored path: " << it->filename() << std::endl;

it = fileSettings.erase(it);

}

else

++it;

}

}

void ImportProject::ignoreOtherConfigs(const std::string &cfg)

{

for (auto it = fileSettings.cbegin(); it != fileSettings.cend();) {

if (it->cfg != cfg)

it = fileSettings.erase(it);

else

++it;

}

}

void ImportProject::fsSetDefines(FileSettings& fs, std::string defs)

{

while (defs.find(";%(") != std::string::npos) {

const std::string::size_type pos1 = defs.find(";%(");

const std::string::size_type pos2 = defs.find(';', pos1+1);

defs.erase(pos1, pos2 == std::string::npos ? pos2 : (pos2-pos1));

}

while (defs.find(";;") != std::string::npos)

defs.erase(defs.find(";;"),1);

while (!defs.empty() && defs[0] == ';')

defs.erase(0, 1);

while (!defs.empty() && endsWith(defs,';'))

defs.pop_back();

bool eq = false;

for (std::size_t pos = 0; pos < defs.size(); ++pos) {

if (defs[pos] == '(' || defs[pos] == '=')

eq = true;

else if (defs[pos] == ';') {

if (!eq) {

defs.insert(pos,"=1");

pos += 3;

}

if (pos < defs.size())

eq = false;

}

}

if (!eq && !defs.empty())

defs += "=1";

fs.defines.swap(defs);

}

static bool simplifyPathWithVariables(std::string &s, std::map<std::string, std::string, cppcheck::stricmp> &variables)

{

std::set<std::string, cppcheck::stricmp> expanded;

std::string::size_type start = 0;

while ((start = s.find("$(")) != std::string::npos) {

const std::string::size_type end = s.find(')',start);

if (end == std::string::npos)

break;

const std::string var = s.substr(start+2,end-start-2);

if (expanded.find(var) != expanded.end())

break;

expanded.insert(var);

auto it1 = utils::as_const(variables).find(var);

// variable was not found within defined variables

if (it1 == variables.end()) {

const char *envValue = std::getenv(var.c_str());

if (!envValue) {

//! \todo generate a debug/info message about undefined variable

break;

}

variables[var] = std::string(envValue);

it1 = variables.find(var);

}

s.replace(start, end - start + 1, it1->second);

}

if (s.find("$(") != std::string::npos)

return false;

s = Path::simplifyPath(std::move(s));

return true;

}

void ImportProject::fsSetIncludePaths(FileSettings& fs, const std::string &basepath, const std::list<std::string> &in, std::map<std::string, std::string, cppcheck::stricmp> &variables)

{

std::set<std::string> found;

// NOLINTNEXTLINE(performance-unnecessary-copy-initialization)

const std::list<std::string> copyIn(in);

fs.includePaths.clear();

for (const std::string &ipath : copyIn) {

if (ipath.empty())

continue;

if (startsWith(ipath,"%("))

continue;

std::string s(Path::fromNativeSeparators(ipath));

if (!found.insert(s).second)

continue;

if (s[0] == '/' || (s.size() > 1U && s.compare(1,2,":/") == 0)) {

if (!endsWith(s,'/'))

s += '/';

fs.includePaths.push_back(std::move(s));

continue;

}

if (endsWith(s,'/')) // this is a temporary hack, simplifyPath can crash if path ends with '/'

s.pop_back();

if (s.find("$(") == std::string::npos) {

s = Path::simplifyPath(basepath + s);

} else {

if (!simplifyPathWithVariables(s, variables))

continue;

}

if (s.empty())

continue;

fs.includePaths.push_back(s.back() == '/' ? s : (s + '/'));

}

}

ImportProject::Type ImportProject::import(const std::string &filename, Settings *settings, Suppressions *supprs)

{

std::ifstream fin(filename);

if (!fin.is_open())

return ImportProject::Type::MISSING;

mPath = Path::getPathFromFilename(Path::fromNativeSeparators(filename));

if (!mPath.empty() && !endsWith(mPath,'/'))

mPath += '/';

const std::vector<std::string> fileFilters =

settings ? settings->fileFilters : std::vector<std::string>();

if (endsWith(filename, ".json")) {

if (importCompileCommands(fin)) {

setRelativePaths(filename);

return ImportProject::Type::COMPILE_DB;

}

} else if (endsWith(filename, ".sln")) {

if (importSln(fin, mPath, fileFilters)) {

setRelativePaths(filename);

return ImportProject::Type::VS_SLN;

}

} else if (endsWith(filename, ".vcxproj")) {

std::map<std::string, std::string, cppcheck::stricmp> variables;

std::vector<SharedItemsProject> sharedItemsProjects;

if (importVcxproj(filename, variables, "", fileFilters, sharedItemsProjects)) {

setRelativePaths(filename);

return ImportProject::Type::VS_VCXPROJ;

}

} else if (endsWith(filename, ".bpr")) {

if (importBcb6Prj(filename)) {

setRelativePaths(filename);

return ImportProject::Type::BORLAND;

}

} else if (settings && supprs && endsWith(filename, ".cppcheck")) {

if (importCppcheckGuiProject(fin, *settings, *supprs)) {

setRelativePaths(filename);

return ImportProject::Type::CPPCHECK_GUI;

}

} else {

return ImportProject::Type::UNKNOWN;

}

return ImportProject::Type::FAILURE;

}

static std::string readUntil(const std::string &command, std::string::size_type *pos, const char until[], bool str = false)

{

std::string ret;

bool escapedString = false;

bool escape = false;

for (; *pos < command.size() && (str || !std::strchr(until, command[*pos])); (*pos)++) {

if (escape)

escape = false;

else if (command[*pos] == '\\') {

if (str)

escape = true;

else if (command[*pos + 1] == '"') {

if (escapedString)

return ret + "\\\"";

escapedString = true;

ret += "\\\"";

(*pos)++;

continue;

}

} else if (command[*pos] == '\"')

str = !str;

ret += command[*pos];

}

return ret;

}

static std::string unescape(const std::string &in)

{

std::string out;

bool escape = false;

for (const char c: in) {

if (escape) {

escape = false;

if (!std::strchr("\\\"\'",c))

out += "\\";

out += c;

} else if (c == '\\')

escape = true;

else

out += c;

}

return out;

}

void ImportProject::fsParseCommand(FileSettings& fs, const std::string& command, bool doUnescape)

{

std::string defs;

// Parse command..

std::string::size_type pos = 0;

while (std::string::npos != (pos = command.find(' ',pos))) {

while (pos < command.size() && command[pos] == ' ')

pos++;

if (pos >= command.size())

break;

bool wholeArgQuoted = false;

if (command[pos] == '"') {

wholeArgQuoted = true;

pos++;

if (pos >= command.size())

break;

}

if (command[pos] != '/' && command[pos] != '-')

continue;

pos++;

if (pos >= command.size())

break;

const char F = command[pos++];

if (std::strchr("DUI", F)) {

while (pos < command.size() && command[pos] == ' ')

++pos;

}

std::string fval = readUntil(command, &pos, " =", wholeArgQuoted);

if (wholeArgQuoted && fval.back() == '\"')

fval.resize(fval.size() - 1);

if (F=='D') {

std::string defval = readUntil(command, &pos, " ");

defs += fval;

if (doUnescape) {

if (defval.size() >= 3 && startsWith(defval,"=\"") && defval.back()=='\"')

defval = "=" + unescape(defval.substr(2, defval.size() - 3));

else if (defval.size() >= 5 && startsWith(defval, "=\\\"") && endsWith(defval, "\\\""))

defval = "=\"" + unescape(defval.substr(3, defval.size() - 5)) + "\"";

}

if (!defval.empty())

defs += defval;

defs += ';';

} else if (F=='U')

fs.undefs.insert(std::move(fval));

else if (F=='I') {

std::string i = std::move(fval);

if (i.size() > 1 && i[0] == '\"' && i.back() == '\"')

i = unescape(i.substr(1, i.size() - 2));

if (std::find(fs.includePaths.cbegin(), fs.includePaths.cend(), i) == fs.includePaths.cend())

fs.includePaths.push_back(std::move(i));

} else if (F=='s' && startsWith(fval,"td")) {

++pos;

fs.standard = readUntil(command, &pos, " ");

} else if (F == 'i' && fval == "system") {

++pos;

std::string isystem = readUntil(command, &pos, " ");

fs.systemIncludePaths.push_back(std::move(isystem));

} else if (F=='m') {

if (fval == "unicode") {

defs += "UNICODE";

defs += ";";

}

} else if (F=='f') {

if (fval == "pic") {

defs += "__pic__";

defs += ";";

} else if (fval == "PIC") {

defs += "__PIC__";

defs += ";";

} else if (fval == "pie") {

defs += "__pie__";

defs += ";";

} else if (fval == "PIE") {

defs += "__PIE__";

defs += ";";

}

// TODO: support -fsigned-char and -funsigned-char?

// we can only set it globally but in this context it needs to be treated per file

}

}

fsSetDefines(fs, std::move(defs));

}

bool ImportProject::importCompileCommands(std::istream &istr)

{

picojson::value compileCommands;

istr >> compileCommands;

if (!compileCommands.is<picojson::array>()) {

errors.emplace_back("compilation database is not a JSON array");

return false;

}

std::map<std::string, int> fileIndex;

for (const picojson::value &fileInfo : compileCommands.get<picojson::array>()) {

picojson::object obj = fileInfo.get<picojson::object>();

if (obj.count("directory") == 0) {

errors.emplace_back("'directory' field in compilation database entry missing");

return false;

}

if (!obj["directory"].is<std::string>()) {

errors.emplace_back("'directory' field in compilation database entry is not a string");

return false;

}

std::string dirpath = Path::fromNativeSeparators(obj["directory"].get<std::string>());

/* CMAKE produces the directory without trailing / so add it if not

* there - it is needed by setIncludePaths() */

if (!endsWith(dirpath, '/'))

dirpath += '/';

const std::string directory = std::move(dirpath);

bool doUnescape = false;

std::string command;

if (obj.count("arguments")) {

doUnescape = false;

if (obj["arguments"].is<picojson::array>()) {

for (const picojson::value& arg : obj["arguments"].get<picojson::array>()) {

if (arg.is<std::string>()) {

std::string str = arg.get<std::string>();

if (str.find(' ') != std::string::npos)

str = "\"" + str + "\"";

command += str + " ";

}

}

} else {

errors.emplace_back("'arguments' field in compilation database entry is not a JSON array");

return false;

}

} else if (obj.count("command")) {

doUnescape = true;

if (obj["command"].is<std::string>()) {

command = obj["command"].get<std::string>();

} else {

errors.emplace_back("'command' field in compilation database entry is not a string");

return false;

}

} else {

errors.emplace_back("no 'arguments' or 'command' field found in compilation database entry");

return false;

}

if (!obj.count("file") || !obj["file"].is<std::string>()) {

errors.emplace_back("skip compilation database entry because it does not have a proper 'file' field");

continue;

}

std::string file = Path::fromNativeSeparators(obj["file"].get<std::string>());

// Accept file?

if (!Path::acceptFile(file))

continue;

std::string path;

if (Path::isAbsolute(file))

path = Path::simplifyPath(std::move(file));

#ifdef _WIN32

else if (file[0] == '/' && directory.size() > 2 && std::isalpha(directory[0]) && directory[1] == ':')

// directory: C:\foo\bar

// file: /xy/z.c

// => c:/xy/z.c

path = Path::simplifyPath(directory.substr(0,2) + file);

#endif

else

path = Path::simplifyPath(directory + file);

FileSettings fs{path, Standards::Language::None, 0}; // file will be identified later on

fsParseCommand(fs, command, doUnescape); // read settings; -D, -I, -U, -std, -m*, -f*

std::map<std::string, std::string, cppcheck::stricmp> variables;

fsSetIncludePaths(fs, directory, fs.includePaths, variables);

// Assign a unique index to each file path. If the file path already exists in the map,

// increment the index to handle duplicate file entries.

fs.fileIndex = fileIndex[path]++;

fileSettings.push_back(std::move(fs));

}

return true;

}

bool ImportProject::importSln(std::istream &istr, const std::string &path, const std::vector<std::string> &fileFilters)

{

std::string line;

if (!std::getline(istr,line)) {

errors.emplace_back("Visual Studio solution file is empty");

return false;

}

if (!startsWith(line, "Microsoft Visual Studio Solution File")) {

// Skip BOM

if (!std::getline(istr, line) || !startsWith(line, "Microsoft Visual Studio Solution File")) {

errors.emplace_back("Visual Studio solution file header not found");

return false;

}

}

std::map<std::string,std::string,cppcheck::stricmp> variables;

variables["SolutionDir"] = path;

bool found = false;

std::vector<SharedItemsProject> sharedItemsProjects;

while (std::getline(istr,line)) {

if (!startsWith(line,"Project("))

continue;

const std::string::size_type pos = line.find(".vcxproj");

if (pos == std::string::npos)

continue;

const std::string::size_type pos1 = line.rfind('\"',pos);

if (pos1 == std::string::npos)

continue;

std::string vcxproj(line.substr(pos1+1, pos-pos1+7));

vcxproj = Path::toNativeSeparators(std::move(vcxproj));

if (!Path::isAbsolute(vcxproj))

vcxproj = path + vcxproj;

vcxproj = Path::fromNativeSeparators(std::move(vcxproj));

if (!importVcxproj(vcxproj, variables, "", fileFilters, sharedItemsProjects)) {

errors.emplace_back("failed to load '" + vcxproj + "' from Visual Studio solution");

return false;

}

found = true;

}

if (!found) {

errors.emplace_back("no projects found in Visual Studio solution file");

return false;

}

return true;

}

namespace {

struct ProjectConfiguration {

explicit ProjectConfiguration(const tinyxml2::XMLElement *cfg) {

const char *a = cfg->Attribute("Include");

if (a)

name = a;

for (const tinyxml2::XMLElement *e = cfg->FirstChildElement(); e; e = e->NextSiblingElement()) {

const char * const text = e->GetText();

if (!text)

continue;

const char * ename = e->Name();

if (std::strcmp(ename,"Configuration")==0)

configuration = text;

else if (std::strcmp(ename,"Platform")==0) {

platformStr = text;

if (platformStr == "Win32")

platform = Win32;

else if (platformStr == "x64")

platform = x64;

else

platform = Unknown;

}

}

}

std::string name;

std::string configuration;

enum : std::uint8_t { Win32, x64, Unknown } platform = Unknown;

std::string platformStr;

};

struct ConditionalGroup {

explicit ConditionalGroup(const tinyxml2::XMLElement *idg){

const char *condAttr = idg->Attribute("Condition");

if (condAttr)

mCondition = condAttr;

}

static void replaceAll(std::string &c, const std::string &from, const std::string &to) {

std::string::size_type pos;

while ((pos = c.find(from)) != std::string::npos) {

c.erase(pos,from.size());

c.insert(pos,to);

}

}

// see https://learn.microsoft.com/en-us/visualstudio/msbuild/msbuild-conditions

// properties are .NET String objects and you can call any of its members on them

bool conditionIsTrue(const ProjectConfiguration &p) const {

if (mCondition.empty())

return true;

std::string c = '(' + mCondition + ");";

replaceAll(c, "$(Configuration)", p.configuration);

replaceAll(c, "$(Platform)", p.platformStr);

// TODO: improve evaluation

const Settings s;

TokenList tokenlist(s, Standards::Language::C);

tokenlist.createTokensFromBuffer(c.data(), c.size()); // TODO: check result

// TODO: put in a helper

// generate links

{

std::stack<Token*> lpar;

for (Token* tok2 = tokenlist.front(); tok2; tok2 = tok2->next()) {

if (tok2->str() == "(")

lpar.push(tok2);

else if (tok2->str() == ")") {

if (lpar.empty())

break;

Token::createMutualLinks(lpar.top(), tok2);

lpar.pop();

}

}

}

tokenlist.createAst();

for (const Token *tok = tokenlist.front(); tok; tok = tok->next()) {

if (tok->str() == "(" && tok->astOperand1() && tok->astOperand2()) {

// TODO: this is wrong - it is Contains() not Equals()

if (tok->astOperand1()->expressionString() == "Configuration.Contains")

return ('\'' + p.configuration + '\'') == tok->astOperand2()->str();

}

if (tok->str() == "==" && tok->astOperand1() && tok->astOperand2() && tok->astOperand1()->str() == tok->astOperand2()->str())

return true;

}

return false;

}

private:

std::string mCondition;

};

struct ItemDefinitionGroup : ConditionalGroup {

explicit ItemDefinitionGroup(const tinyxml2::XMLElement *idg, std::string includePaths) : ConditionalGroup(idg), additionalIncludePaths(std::move(includePaths)) {

for (const tinyxml2::XMLElement *e1 = idg->FirstChildElement(); e1; e1 = e1->NextSiblingElement()) {

const char* name = e1->Name();

if (std::strcmp(name, "ClCompile") == 0) {

enhancedInstructionSet = "StreamingSIMDExtensions2";

for (const tinyxml2::XMLElement *e = e1->FirstChildElement(); e; e = e->NextSiblingElement()) {

const char * const text = e->GetText();

if (!text)

continue;

const char * const ename = e->Name();

if (std::strcmp(ename, "PreprocessorDefinitions") == 0)

preprocessorDefinitions = text;

else if (std::strcmp(ename, "AdditionalIncludeDirectories") == 0) {

if (!additionalIncludePaths.empty())

additionalIncludePaths += ';';

additionalIncludePaths += text;

} else if (std::strcmp(ename, "LanguageStandard") == 0) {

if (std::strcmp(text, "stdcpp14") == 0)

cppstd = Standards::CPP14;

else if (std::strcmp(text, "stdcpp17") == 0)

cppstd = Standards::CPP17;

else if (std::strcmp(text, "stdcpp20") == 0)

cppstd = Standards::CPP20;

else if (std::strcmp(text, "stdcpplatest") == 0)

cppstd = Standards::CPPLatest;

} else if (std::strcmp(ename, "EnableEnhancedInstructionSet") == 0) {

enhancedInstructionSet = text;

}

}

}

else if (std::strcmp(name, "Link") == 0) {

for (const tinyxml2::XMLElement *e = e1->FirstChildElement(); e; e = e->NextSiblingElement()) {

const char * const text = e->GetText();

if (!text)

continue;

if (std::strcmp(e->Name(), "EntryPointSymbol") == 0) {

entryPointSymbol = text;

}

}

}

}

}

std::string enhancedInstructionSet;

std::string preprocessorDefinitions;

std::string additionalIncludePaths;

std::string entryPointSymbol; // TODO: use this

Standards::cppstd_t cppstd = Standards::CPPLatest;

};

struct ConfigurationPropertyGroup : ConditionalGroup {

explicit ConfigurationPropertyGroup(const tinyxml2::XMLElement *idg) : ConditionalGroup(idg) {

for (const tinyxml2::XMLElement *e = idg->FirstChildElement(); e; e = e->NextSiblingElement()) {

if (std::strcmp(e->Name(), "UseOfMfc") == 0) {

useOfMfc = true;

} else if (std::strcmp(e->Name(), "CharacterSet") == 0) {

useUnicode = std::strcmp(e->GetText(), "Unicode") == 0;

}

}

}

bool useOfMfc = false;

bool useUnicode = false;

};

}

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;

}

static void importPropertyGroup(const tinyxml2::XMLElement *node, std::map<std::string, std::string, cppcheck::stricmp> &variables, std::string &includePath)

{

const char* labelAttribute = node->Attribute("Label");

if (labelAttribute && std::strcmp(labelAttribute, "UserMacros") == 0) {

for (const tinyxml2::XMLElement *propertyGroup = node->FirstChildElement(); propertyGroup; propertyGroup = propertyGroup->NextSiblingElement()) {

const char* name = propertyGroup->Name();

const char *text = empty_if_null(propertyGroup->GetText());

variables[name] = text;

}

} else if (!labelAttribute) {

for (const tinyxml2::XMLElement *propertyGroup = node->FirstChildElement(); propertyGroup; propertyGroup = propertyGroup->NextSiblingElement()) {

if (std::strcmp(propertyGroup->Name(), "IncludePath") != 0)

continue;

const char *text = propertyGroup->GetText();

if (!text)

continue;

std::string path(text);

const std::string::size_type pos = path.find("$(IncludePath)");

if (pos != std::string::npos)

path.replace(pos, 14U, includePath);

includePath = std::move(path);

}

}

}

static void loadVisualStudioProperties(const std::string &props, std::map<std::string,std::string,cppcheck::stricmp> &variables, std::string &includePath, const std::string &additionalIncludeDirectories, std::list<ItemDefinitionGroup> &itemDefinitionGroupList)

{

std::string filename(props);

// variables can't be resolved

if (!simplifyPathWithVariables(filename, variables))

return;

// prepend project dir (if it exists) to transform relative paths into absolute ones

if (!Path::isAbsolute(filename) && variables.count("ProjectDir") > 0)

filename = Path::getAbsoluteFilePath(variables.at("ProjectDir") + filename);

tinyxml2::XMLDocument doc;

if (doc.LoadFile(filename.c_str()) != 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()) {

const char* name = node->Name();

if (std::strcmp(name, "ImportGroup") == 0) {

const char *labelAttribute = node->Attribute("Label");

if (labelAttribute == nullptr || std::strcmp(labelAttribute, "PropertySheets") != 0)

continue;

for (const tinyxml2::XMLElement *importGroup = node->FirstChildElement(); importGroup; importGroup = importGroup->NextSiblingElement()) {

if (std::strcmp(importGroup->Name(), "Import") == 0) {

const char *projectAttribute = importGroup->Attribute("Project");

if (projectAttribute == nullptr)

continue;

std::string loadprj(projectAttribute);

if (loadprj.find('$') == std::string::npos) {

loadprj = Path::getPathFromFilename(filename) + loadprj;

}

loadVisualStudioProperties(loadprj, variables, includePath, additionalIncludeDirectories, itemDefinitionGroupList);

}

}

} else if (std::strcmp(name,"PropertyGroup")==0) {

importPropertyGroup(node, variables, includePath);

} else if (std::strcmp(name,"ItemDefinitionGroup")==0) {

itemDefinitionGroupList.emplace_back(node, additionalIncludeDirectories);

}

}

}

bool ImportProject::importVcxproj(const std::string &filename,

std::map<std::string, std::string, cppcheck::stricmp> &variables,

const std::string &additionalIncludeDirectories,

const std::vector<std::string> &fileFilters,

std::vector<SharedItemsProject> &cache)

{

tinyxml2::XMLDocument doc;

const tinyxml2::XMLError error = doc.LoadFile(filename.c_str());

if (error != tinyxml2::XML_SUCCESS) {

errors.emplace_back(std::string("Visual Studio project file is not a valid XML - ") + tinyxml2::XMLDocument::ErrorIDToName(error));

return false;

}

return importVcxproj(filename, doc, variables, additionalIncludeDirectories, fileFilters, cache);

}

bool ImportProject::importVcxproj(const std::string &filename, const tinyxml2::XMLDocument &doc, std::map<std::string, std::string, cppcheck::stricmp> &variables, const std::string &additionalIncludeDirectories, const std::vector<std::string> &fileFilters, std::vector<SharedItemsProject> &cache)

{

variables["ProjectDir"] = Path::simplifyPath(Path::getPathFromFilename(filename));

std::list<ProjectConfiguration> projectConfigurationList;

std::list<std::string> compileList;

std::list<ItemDefinitionGroup> itemDefinitionGroupList;

std::vector<ConfigurationPropertyGroup> configurationPropertyGroups;

std::string includePath;

std::vector<SharedItemsProject> sharedItemsProjects;

const tinyxml2::XMLElement * const rootnode = doc.FirstChildElement();

if (rootnode == nullptr) {

errors.emplace_back("Visual Studio project file has no XML root node");

return false;

}

for (const tinyxml2::XMLElement *node = rootnode->FirstChildElement(); node; node = node->NextSiblingElement()) {

const char* name = node->Name();

if (std::strcmp(name, "ItemGroup") == 0) {

const char *labelAttribute = node->Attribute("Label");

if (labelAttribute && std::strcmp(labelAttribute, "ProjectConfigurations") == 0) {

for (const tinyxml2::XMLElement *cfg = node->FirstChildElement(); cfg; cfg = cfg->NextSiblingElement()) {

if (std::strcmp(cfg->Name(), "ProjectConfiguration") == 0) {

const ProjectConfiguration p(cfg);

if (p.platform != ProjectConfiguration::Unknown) {

projectConfigurationList.emplace_back(cfg);

mAllVSConfigs.insert(p.configuration);

}

}

}

} else {

for (const tinyxml2::XMLElement *e = node->FirstChildElement(); e; e = e->NextSiblingElement()) {

if (std::strcmp(e->Name(), "ClCompile") == 0) {

const char *include = e->Attribute("Include");

if (include && Path::acceptFile(include)) {

std::string toInclude = Path::simplifyPath(Path::isAbsolute(include) ? include : Path::getPathFromFilename(filename) + include);

compileList.emplace_back(toInclude);

}

}

}

}

} else if (std::strcmp(name, "ItemDefinitionGroup") == 0) {

itemDefinitionGroupList.emplace_back(node, additionalIncludeDirectories);

} else if (std::strcmp(name, "PropertyGroup") == 0) {

const char* labelAttribute = node->Attribute("Label");

if (labelAttribute && std::strcmp(labelAttribute, "Configuration") == 0) {

configurationPropertyGroups.emplace_back(node);

} else {

importPropertyGroup(node, variables, includePath);

}

} else if (std::strcmp(name, "ImportGroup") == 0) {

const char *labelAttribute = node->Attribute("Label");

if (labelAttribute && std::strcmp(labelAttribute, "PropertySheets") == 0) {

for (const tinyxml2::XMLElement *e = node->FirstChildElement(); e; e = e->NextSiblingElement()) {

if (std::strcmp(e->Name(), "Import") == 0) {

const char *projectAttribute = e->Attribute("Project");

if (projectAttribute)

loadVisualStudioProperties(projectAttribute, variables, includePath, additionalIncludeDirectories, itemDefinitionGroupList);

}

}

} else if (labelAttribute && std::strcmp(labelAttribute, "Shared") == 0) {

for (const tinyxml2::XMLElement *e = node->FirstChildElement(); e; e = e->NextSiblingElement()) {

if (std::strcmp(e->Name(), "Import") == 0) {

const char *projectAttribute = e->Attribute("Project");

if (projectAttribute) {

// Path to shared items project is relative to current project directory,

// unless the string starts with $(SolutionDir)

std::string pathToSharedItemsFile;

if (std::string(projectAttribute).rfind("$(SolutionDir)", 0) == 0) {

pathToSharedItemsFile = projectAttribute;

} else {

pathToSharedItemsFile = variables["ProjectDir"] + projectAttribute;

}

if (!simplifyPathWithVariables(pathToSharedItemsFile, variables)) {

errors.emplace_back("Could not simplify path to referenced shared items project");

return false;

}

SharedItemsProject toAdd = importVcxitems(pathToSharedItemsFile, fileFilters, cache);

if (!toAdd.successful) {

errors.emplace_back("Could not load shared items project \"" + pathToSharedItemsFile + "\" from original path \"" + std::string(projectAttribute) + "\".");

return false;

}

sharedItemsProjects.emplace_back(toAdd);

}

}

}

}

}

}

// # TODO: support signedness of char via /J (and potential XML option for it)?

// we can only set it globally but in this context it needs to be treated per file

// Include shared items project files

std::vector<std::string> sharedItemsIncludePaths;

for (const auto& sharedProject : sharedItemsProjects) {

for (const auto &file : sharedProject.sourceFiles) {

std::string pathToFile = Path::simplifyPath(Path::getPathFromFilename(sharedProject.pathToProjectFile) + file);

compileList.emplace_back(std::move(pathToFile));

}

for (const auto &p : sharedProject.includePaths) {

std::string path = Path::simplifyPath(Path::getPathFromFilename(sharedProject.pathToProjectFile) + p);

sharedItemsIncludePaths.emplace_back(std::move(path));

}

}

// Project files

PathMatch filtermatcher(fileFilters, Path::getCurrentPath());

for (const std::string &cfilename : compileList) {

if (!fileFilters.empty() && !filtermatcher.match(cfilename))

continue;

for (const ProjectConfiguration &p : projectConfigurationList) {

if (!guiProject.checkVsConfigs.empty()) {

const bool doChecking = std::any_of(guiProject.checkVsConfigs.cbegin(), guiProject.checkVsConfigs.cend(), [&](const std::string& c) {

return c == p.configuration;

});

if (!doChecking)

continue;

}

FileSettings fs{cfilename, Standards::Language::None, 0}; // file will be identified later on

fs.cfg = p.name;

// TODO: detect actual MSC version

fs.msc = true;

fs.defines = "_WIN32=1";

if (p.platform == ProjectConfiguration::Win32)

fs.platformType = Platform::Type::Win32W;

else if (p.platform == ProjectConfiguration::x64) {

fs.platformType = Platform::Type::Win64;

fs.defines += ";_WIN64=1";

}

std::string additionalIncludePaths;

for (const ItemDefinitionGroup &i : itemDefinitionGroupList) {

if (!i.conditionIsTrue(p))

continue;

fs.standard = Standards::getCPP(i.cppstd);

fs.defines += ';' + i.preprocessorDefinitions;

if (i.enhancedInstructionSet == "StreamingSIMDExtensions")

fs.defines += ";__SSE__";

else if (i.enhancedInstructionSet == "StreamingSIMDExtensions2")

fs.defines += ";__SSE2__";

else if (i.enhancedInstructionSet == "AdvancedVectorExtensions")

fs.defines += ";__AVX__";

else if (i.enhancedInstructionSet == "AdvancedVectorExtensions2")

fs.defines += ";__AVX2__";

else if (i.enhancedInstructionSet == "AdvancedVectorExtensions512")

fs.defines += ";__AVX512__";

additionalIncludePaths += ';' + i.additionalIncludePaths;

}

bool useUnicode = false;

for (const ConfigurationPropertyGroup &c : configurationPropertyGroups) {

if (!c.conditionIsTrue(p))

continue;

// in msbuild the last definition wins

useUnicode = c.useUnicode;

fs.useMfc = c.useOfMfc;

}

if (useUnicode) {

fs.defines += ";UNICODE=1;_UNICODE=1";

}

fsSetDefines(fs, fs.defines);

fsSetIncludePaths(fs, Path::getPathFromFilename(filename), toStringList(includePath + ';' + additionalIncludePaths), variables);

for (const auto &path : sharedItemsIncludePaths) {

fs.includePaths.emplace_back(path);

}

fileSettings.push_back(std::move(fs));

}

}

return true;

}

ImportProject::SharedItemsProject ImportProject::importVcxitems(const std::string& filename, const std::vector<std::string>& fileFilters, std::vector<SharedItemsProject> &cache)

{

auto isInCacheCheck = [filename](const ImportProject::SharedItemsProject& e) -> bool {

return filename == e.pathToProjectFile;

};

const auto iterator = std::find_if(cache.begin(), cache.end(), isInCacheCheck);

if (iterator != std::end(cache)) {

return *iterator;

}

SharedItemsProject result;

result.pathToProjectFile = filename;

PathMatch filtermatcher(fileFilters, Path::getCurrentPath());

tinyxml2::XMLDocument doc;

const tinyxml2::XMLError error = doc.LoadFile(filename.c_str());

if (error != tinyxml2::XML_SUCCESS) {

errors.emplace_back(std::string("Visual Studio project file is not a valid XML - ") + tinyxml2::XMLDocument::ErrorIDToName(error));

return result;

}

const tinyxml2::XMLElement * const rootnode = doc.FirstChildElement();

if (rootnode == nullptr) {

errors.emplace_back("Visual Studio project file has no XML root node");

return result;

}

for (const tinyxml2::XMLElement *node = rootnode->FirstChildElement(); node; node = node->NextSiblingElement()) {

if (std::strcmp(node->Name(), "ItemGroup") == 0) {

for (const tinyxml2::XMLElement *e = node->FirstChildElement(); e; e = e->NextSiblingElement()) {

if (std::strcmp(e->Name(), "ClCompile") == 0) {

const char* include = e->Attribute("Include");

if (include && Path::acceptFile(include)) {

std::string file(include);

findAndReplace(file, "$(MSBuildThisFileDirectory)", "./");

// Skip file if it doesn't match the filter

if (!fileFilters.empty() && !filtermatcher.match(file))

continue;

result.sourceFiles.emplace_back(file);

} else {

errors.emplace_back("Could not find shared items source file");

return result;

}

}

}

} else if (std::strcmp(node->Name(), "ItemDefinitionGroup") == 0) {

ItemDefinitionGroup temp(node, "");

for (const auto& includePath : toStringList(temp.additionalIncludePaths)) {

if (includePath == "%(AdditionalIncludeDirectories)")

continue;

std::string toAdd(includePath);

findAndReplace(toAdd, "$(MSBuildThisFileDirectory)", "./");

result.includePaths.emplace_back(toAdd);

}

}

}

result.successful = true;

cache.emplace_back(result);

return result;

}

bool ImportProject::importBcb6Prj(const std::string &projectFilename)

{

tinyxml2::XMLDocument doc;

const tinyxml2::XMLError error = doc.LoadFile(projectFilename.c_str());

if (error != tinyxml2::XML_SUCCESS) {

errors.emplace_back(std::string("Borland project file is not a valid XML - ") + tinyxml2::XMLDocument::ErrorIDToName(error));

return false;

}

const tinyxml2::XMLElement * const rootnode = doc.FirstChildElement();

if (rootnode == nullptr) {

errors.emplace_back("Borland project file has no XML root node");

return false;

}

const std::string& projectDir = Path::simplifyPath(Path::getPathFromFilename(projectFilename));