QString Path::osPath( const QString & path )
{
#ifdef Q_OS_WIN
return winPath( path );
#else
return unixPath( path );
#endif
}
std::string VSBuildableSolutionProject::getPath() const
{
// Return a path relative to the solution directory
std::string solutionDir = sb_dirname(m_parent.getPath());
std::string relativePath = getRelativePath(solutionDir, m_project->getPath());
relativePath = winPath(relativePath);
return relativePath;
}
VCProjectItem* addRelativeFilePathToVS(const String& itemName, const String& filePath, const String& filterPath, VCProject& proj, const BuildSettings& bs)
{
// Get relative path to file
String xcProjectDir = bs.getValue("PROJECT_DIR");
String vsProjectDir = sb_dirname(proj.getPath());
String absFilePath = joinPaths(xcProjectDir, bs.expand(filePath));
String relPath = getRelativePath(vsProjectDir, absFilePath);
relPath = winPath(relPath);
return proj.addItem(itemName, relPath, filterPath);
}
void WatcherData::updatePaths()
{
// printf("updating paths...\n");
{
std::lock_guard<std::mutex> updateLocker(updateMutex);
handleToPath.clear();
pathToHandle.clear();
pathData.clear();
}
for (HANDLE& h : changes) {
//printf("closing %d\n", h);
FindCloseChangeNotification(h);
}
changes.clear();
std::lock_guard<std::mutex> locker(changeMutex);
for(const Path& path : paths) {
#ifdef HAVE_CYGWIN
const ssize_t len = cygwin_conv_path(CCP_POSIX_TO_WIN_A | CCP_ABSOLUTE, path.constData(), 0, 0);
//printf("win path size %d\n", len);
String winPath(len, '\0');
cygwin_conv_path(CCP_POSIX_TO_WIN_A | CCP_ABSOLUTE, path.constData(), winPath.data(), winPath.size());
//printf("hello %s\n", winPath.constData());
const HANDLE h = FindFirstChangeNotification(winPath.constData(), TRUE,
FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_LAST_WRITE);
#else
const HANDLE h = FindFirstChangeNotification(path.constData(), TRUE,
FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_LAST_WRITE);
#endif
if (h == INVALID_HANDLE_VALUE) {
fprintf(stderr, "Unable to watch: %lu (%s)\n",
static_cast<unsigned long>(GetLastError()), path.constData());
} else {
changes.push_back(h);
std::lock_guard<std::mutex> updateLocker(updateMutex);
handleToPath[h] = path;
pathToHandle[path] = h;
PathData& data = pathData[path];
path.visit([&data](const Path &p) {
if (p.isFile()) {
data.modified[p] = p.lastModifiedMs();
return Path::Continue;
}
return Path::Recurse;
});
}
}
}
void VCProject::writeFilterItemDescriptions(pugi::xml_node& node) const
{
pugi::xml_node tempNode = node.parent().append_child("Temp");
for (auto item : m_items) {
std::string itemName = item->getItemName();
std::string includePath = item->getIncludePath();
std::string filterPath = item->getFilterPath();
pugi::xml_node fItem = tempNode.append_child(itemName.c_str());
fItem.append_attribute("Include") = includePath.c_str();
if (!filterPath.empty() && filterPath != ".") {
appendNodeWithText(fItem, "Filter", winPath(filterPath));
}
}
mergeNodes(node, tempNode);
}
void VCProject::writeFilterDescriptions(pugi::xml_node& node) const
{
StringSet filters;
for (auto item : m_items) {
recordFilterPath(item->getFilterPath(), filters);
}
pugi::xml_node tempNode = node.parent().append_child("Temp");
for (auto filter : filters) {
// Generate a unique id
std::string id = sole::uuid4().str();
// Fix up the filter path to be Windows-style
std::string winFilterPath = winPath(filter);
// Create a filter description node
pugi::xml_node filterDesc = tempNode.append_child("Filter");
filterDesc.append_attribute("Include") = winFilterPath.c_str();
appendNodeWithText(filterDesc, "UniqueIdentifier", formatVSGUID(id));
}
mergeNodes(node, tempNode);
}
void SBSourcesBuildPhase::writeVCProjectFiles(VCProject& proj) const
{
// We don't support source compilation when building bundles
TargetProductType productType = m_parentTarget.getProductType();
if (productType == TargetBundle)
{
if (!m_phase->getBuildFileList().empty()) {
SBLog::warning() << "Ignoring all source files in \"" << m_parentTarget.getName() << "\" bundle target." << std::endl;
}
return;
}
SBBuildPhase::writeVSFileDescriptions(proj, "Text");
String xcProjectDir = m_parentTarget.getProject().getProjectDir();
String vsProjectDir = sb_dirname(proj.getPath());
StringSet prefixHeaders;
for (auto bs : m_parentTarget.getBuildSettings()) {
VCProjectConfiguration* config = proj.addConfiguration(bs.first);
// Prefix header (recalculate relative path)
String prefixHeader = bs.second->getValue("GCC_PREFIX_HEADER");
if (!prefixHeader.empty()) {
String absHeaderPath = m_parentTarget.makeAbsolutePath(prefixHeader);
String relHeaderPath = m_parentTarget.makeRelativePath(prefixHeader, vsProjectDir);;
relHeaderPath = winPath(relHeaderPath);
config->setItemDefinition("ClangCompile", "PrefixHeader", relHeaderPath);
// Add plist file to project (only once)
if (prefixHeaders.find(absHeaderPath) == prefixHeaders.end()) {
addRelativeFilePathToVS("ClInclude", absHeaderPath, "", proj, *bs.second);
prefixHeaders.insert(absHeaderPath);
}
}
// Preprocessor definitions
StringVec preprocessorTokens;
bs.second->getValue("GCC_PREPROCESSOR_DEFINITIONS", preprocessorTokens);
String preprocessorDefs = joinStrings(preprocessorTokens, ";");
if (!preprocessorDefs.empty()) {
config->setItemDefinition("ClangCompile", "PreprocessorDefinitions", preprocessorDefs);
}
// Optimization level
String optimizationLevel = bs.second->getValue("GCC_OPTIMIZATION_LEVEL");
if (!optimizationLevel.empty()) {
String vsOptimizationLevel;
if (optimizationLevel == "s") {
vsOptimizationLevel = "MinSpace";
} else if (optimizationLevel == "0") {
vsOptimizationLevel = "Disabled";
} else {
vsOptimizationLevel = "MaxSpeed";
}
config->setItemDefinition("ClangCompile", "OptimizationLevel", vsOptimizationLevel);
}
// ARC
String enableARC = bs.second->getValue("CLANG_ENABLE_OBJC_ARC");
if (enableARC == "YES") {
config->setItemDefinition("ClangCompile", "ObjectiveCARC", "true");
}
// Modules
String enableModules = bs.second->getValue("CLANG_ENABLE_MODULES");
if (enableModules == "YES") {
config->setItemDefinition("ClangCompile", "ObjectiveCModules", "true");
}
// Header search paths (make them relative)
StringVec includePaths;
bs.second->getValue("HEADER_SEARCH_PATHS", includePaths);
for (auto &cur : includePaths) {
cur = m_parentTarget.makeRelativePath(cur, vsProjectDir);
cur = winPath(cur);
}
includePaths.insert(includePaths.begin(), "$(SolutionPublicHeadersDir)");
config->setItemDefinition("ClangCompile", "IncludePaths", joinStrings(includePaths, ";"));
// User header search paths (make them relative)
StringVec userIncludePaths;
bs.second->getValue("USER_HEADER_SEARCH_PATHS", userIncludePaths);
for (auto &cur : userIncludePaths) {
cur = m_parentTarget.makeRelativePath(cur, vsProjectDir);
cur = winPath(cur);
}
if (!userIncludePaths.empty()) {
config->setItemDefinition("ClangCompile", "UserIncludePaths", joinStrings(userIncludePaths, ";"));
}
// Exclude search path subdirectories
StringVec excludeSubDirectories;
bs.second->getValue("EXCLUDED_RECURSIVE_SEARCH_PATH_SUBDIRECTORIES", excludeSubDirectories);
if (!excludeSubDirectories.empty()) {
config->setItemDefinition("ClangCompile", "ExcludedSearchPathSubdirectories", joinStrings(excludeSubDirectories, ";"));
}
// Header map
if (bs.second->getValue("USE_HEADERMAP") == "YES") {
if (bs.second->getValue("ALWAYS_SEARCH_USER_PATHS") == "YES") {
config->setItemDefinition("ClangCompile", "HeaderMap", "Combined");
} else if (bs.second->getValue("HEADERMAP_INCLUDES_PROJECT_HEADERS") == "YES") {
config->setItemDefinition("ClangCompile", "HeaderMap", "Project");
}
}
// Other C flags
String otherCFlags = bs.second->getValue("OTHER_CFLAGS");
processClangFlags(otherCFlags, xcProjectDir, vsProjectDir);
if (!otherCFlags.empty()) {
config->setItemDefinition("ClangCompile", "OtherCFlags", otherCFlags);
}
// Other C++ flags
String otherCPlusPlusFlags = bs.second->getValue("OTHER_CPLUSPLUSFLAGS");
processClangFlags(otherCPlusPlusFlags, xcProjectDir, vsProjectDir);
if (!otherCPlusPlusFlags.empty()) {
config->setItemDefinition("ClangCompile", "OtherCPlusPlusFlags", otherCPlusPlusFlags);
}
// CRT
String configNameUpper = strToUpper(bs.first);
if (configNameUpper.find("DEBUG") != String::npos) {
config->setItemDefinition("ClangCompile", "RuntimeLibrary", "MultiThreadedDebugDLL");
}
}
}
QString Path::dbPath() const
{
return winPath( mPath );
}
QString Path::dbDirPath() const
{
return winPath( dirPath() );
}
static String makeRelativePath(const String& path, const String& oldProjDir, const String& newProjDir) {
String absPath = joinPaths(oldProjDir, path);
String relPath = getRelativePath(newProjDir, absPath);
return winPath(relPath);
}
