The-Homebrew-Cloud/cemu-vcpkg
2
0
Fork 0
mirror of https://github.com/cemu-project/vcpkg.git synced 2025-02-23 19:17:10 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/Microsoft/vcpkg into qca

Browse Source
This commit is contained in:
Alexander Kaspar 2016-12-02 16:15:33 +01:00
commit 813e421490
6 changed files with 199 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
ports/icu/CONTROL Normal file
View File

@ -0,0 +1,3 @@
Source: icu
Version: 58.1
Description: Mature and widely used Unicode and localization library.

78
ports/icu/portfile.cmake Normal file
View File

@ -0,0 +1,78 @@
if (VCPKG_TARGET_ARCHITECTURE STREQUAL arm OR VCPKG_CMAKE_SYSTEM_NAME STREQUAL WindowsStore)
message(FATAL_ERROR "Error: ARM and/or UWP builds are currently not supported.")
endif()
if (VCPKG_LIBRARY_LINKAGE STREQUAL static)
message(STATUS "Warning: Static building not supported yet. Building dynamic.")
set(VCPKG_LIBRARY_LINKAGE dynamic)
endif()
include(vcpkg_common_functions)
set(SOURCE_PATH ${CURRENT_BUILDTREES_DIR}/src/icu)
vcpkg_download_distfile(ARCHIVE
URLS "http://download.icu-project.org/files/icu4c/58.1/icu4c-58_1-src.zip"
FILENAME "icu4c-58_1-src.zip"
SHA512 b13b1d8aa5e6a08a5cecaea85252354150064ef98ed7bb66b70d32eac5c80874c11f1fc9e3a667075b867fcc848c33ad90e6cada3a279f65b62cb9d46e25181d)
vcpkg_extract_source_archive(${ARCHIVE})
if (TRIPLET_SYSTEM_ARCH MATCHES "x86")
set(BUILD_ARCH "Win32")
else()
set(BUILD_ARCH ${TRIPLET_SYSTEM_ARCH})
endif()
vcpkg_build_msbuild(
PROJECT_PATH ${SOURCE_PATH}/source/allinone/allinone.sln
PLATFORM ${BUILD_ARCH})
set(ICU_VERSION 58)
if(TRIPLET_SYSTEM_ARCH MATCHES "x64")
set(ICU_BIN bin64)
set(ICU_LIB lib64)
else()
set(ICU_BIN bin)
set(ICU_LIB lib)
endif()
function(install_module MODULENAME)
if(${MODULENAME} STREQUAL icudt) # Database doesn't have debug mode
set(DEBUG_DLLNAME ${MODULENAME}${ICU_VERSION}.dll)
set(DEBUG_LIBNAME ${MODULENAME}.lib)
else()
set(DEBUG_DLLNAME ${MODULENAME}${ICU_VERSION}d.dll)
set(DEBUG_LIBNAME ${MODULENAME}d.lib)
endif()
set(RELEASE_DLLNAME ${MODULENAME}${ICU_VERSION}.dll)
set(RELEASE_LIBNAME ${MODULENAME}.lib)
file(INSTALL
${SOURCE_PATH}/${ICU_BIN}/${RELEASE_DLLNAME}
DESTINATION ${CURRENT_PACKAGES_DIR}/bin)
file(INSTALL
${SOURCE_PATH}/${ICU_BIN}/${DEBUG_DLLNAME}
DESTINATION ${CURRENT_PACKAGES_DIR}/debug/bin)
file(INSTALL
${SOURCE_PATH}/${ICU_LIB}/${RELEASE_LIBNAME}
DESTINATION ${CURRENT_PACKAGES_DIR}/lib)
file(INSTALL
${SOURCE_PATH}/${ICU_LIB}/${DEBUG_LIBNAME}
DESTINATION ${CURRENT_PACKAGES_DIR}/debug/lib)
endfunction()
install_module(icuuc) # Common library
install_module(icuio) # Unicode stdio
install_module(icutu) # Tool utility library
install_module(icuin) # I18n library
install_module(icudt) # Database
vcpkg_copy_pdbs()
file(INSTALL
${SOURCE_PATH}/include/
DESTINATION ${CURRENT_PACKAGES_DIR}/include)
file(COPY
${SOURCE_PATH}/LICENSE
DESTINATION ${CURRENT_PACKAGES_DIR}/share/icu)
file(RENAME
${CURRENT_PACKAGES_DIR}/share/icu/LICENSE
${CURRENT_PACKAGES_DIR}/share/icu/copyright)

8
toolsrc/include/vcpkg.h
View File

@ -11,6 +11,14 @@ namespace vcpkg
void write_update(const vcpkg_paths& paths, const StatusParagraph& p);
struct StatusParagraph_and_associated_files
{
StatusParagraph pgh;
std::vector<std::string> files;
};
std::vector<StatusParagraph_and_associated_files> get_installed_files(const vcpkg_paths& paths, const StatusParagraphs& status_db);
expected<SourceParagraph> try_load_port(const fs::path& control_path);
inline expected<SourceParagraph> try_load_port(const vcpkg_paths& paths, const std::string& name)

76
toolsrc/src/commands_installation.cpp
View File

@ -128,53 +128,67 @@ namespace vcpkg
listfile.close();
}
static std::map<std::string, fs::path> remove_first_n_chars_and_map(const std::vector<fs::path> absolute_paths, const size_t n)
static void remove_first_n_chars(std::vector<std::string>* strings, const size_t n)
{
std::map<std::string, fs::path> output;
for (const fs::path& absolute_path : absolute_paths)
for (std::string& s : *strings)
{
std::string suffix = absolute_path.generic_string();
suffix.erase(0, n);
output.emplace(suffix, absolute_path);
s.erase(0, n);
}
};
static std::vector<std::string> extract_files_in_triplet(const std::vector<StatusParagraph_and_associated_files>& pgh_and_files, const triplet& triplet)
{
std::vector<std::string> output;
for (const StatusParagraph_and_associated_files& t : pgh_and_files)
{
if (t.pgh.package.spec.target_triplet() != triplet)
{
continue;
}
output.insert(output.end(), t.files.cbegin(), t.files.cend());
}
std::sort(output.begin(), output.end());
return output;
}
static void print_map_values(const std::vector<std::string> keys, const std::map<std::string, fs::path>& map)
{
System::println("");
for (const std::string& key : keys)
{
System::println(" %s", map.at(key).generic_string());
}
System::println("");
}
static void install_package(const vcpkg_paths& paths, const BinaryParagraph& binary_paragraph, StatusParagraphs& status_db)
void install_package(const vcpkg_paths& paths, const BinaryParagraph& binary_paragraph, StatusParagraphs& status_db)
{
const fs::path package_dir = paths.package_dir(binary_paragraph.spec);
const std::vector<fs::path> package_files = Files::recursive_find_all_files_in_dir(package_dir);
const std::vector<fs::path> package_file_paths = Files::recursive_find_all_files_in_dir(package_dir);
std::vector<std::string> package_files;
const size_t package_remove_char_count = package_dir.generic_string().size() + 1; // +1 for the slash
std::transform(package_file_paths.cbegin(), package_file_paths.cend(), std::back_inserter(package_files), [package_remove_char_count](const fs::path& path)
{
return path.generic_string().erase(0, package_remove_char_count);
});
std::sort(package_files.begin(), package_files.end());
const fs::path installed_dir = paths.installed / binary_paragraph.spec.target_triplet().canonical_name();
const std::vector<fs::path> installed_files = Files::recursive_find_all_files_in_dir(installed_dir);
const std::map<std::string, fs::path> package_files_relative_paths_to_absolute_paths = remove_first_n_chars_and_map(package_files, package_dir.generic_string().size() + 1);
const std::map<std::string, fs::path> installed_files_relative_paths_to_absolute_paths = remove_first_n_chars_and_map(installed_files, installed_dir.generic_string().size() + 1);
const std::vector<std::string> package_files_set = Maps::extract_keys(package_files_relative_paths_to_absolute_paths);
const std::vector<std::string> installed_files_set = Maps::extract_keys(installed_files_relative_paths_to_absolute_paths);
const std::vector<StatusParagraph_and_associated_files>& pgh_and_files = get_installed_files(paths, status_db);
const triplet& triplet = binary_paragraph.spec.target_triplet();
std::vector<std::string> installed_files = extract_files_in_triplet(pgh_and_files, triplet);
const size_t installed_remove_char_count = triplet.canonical_name().size() + 1; // +1 for the slash
remove_first_n_chars(&installed_files, installed_remove_char_count);
std::sort(installed_files.begin(), installed_files.end()); // Should already be sorted
std::vector<std::string> intersection;
std::set_intersection(package_files_set.cbegin(), package_files_set.cend(),
installed_files_set.cbegin(), installed_files_set.cend(),
std::set_intersection(package_files.cbegin(), package_files.cend(),
installed_files.cbegin(), installed_files.cend(),
std::back_inserter(intersection));
if (!intersection.empty())
{
System::println(System::color::error, "The following files are already installed and are in conflict with %s:", binary_paragraph.spec);
print_map_values(intersection, installed_files_relative_paths_to_absolute_paths);
const fs::path triplet_install_path = paths.installed / triplet.canonical_name();
System::println(System::color::error, "The following files are already installed in %s and are in conflict with %s",
triplet_install_path.generic_string(),
binary_paragraph.spec);
System::println("");
for (const std::string& s : intersection)
{
System::println(" %s", s);
}
System::println("");
exit(EXIT_FAILURE);
}

21
toolsrc/src/commands_owns.cpp
View File

@ -1,30 +1,21 @@
#include "vcpkg_Commands.h"
#include "vcpkg_System.h"
#include "vcpkg.h"
#include <fstream>
namespace vcpkg
{
static void search_file(const vcpkg_paths& paths, const std::string& file_substr, const StatusParagraphs& status_db)
{
std::string line;
for (auto&& pgh : status_db)
const std::vector<StatusParagraph_and_associated_files> installed_files = get_installed_files(paths, status_db);
for (const StatusParagraph_and_associated_files& pgh_and_file : installed_files)
{
if (pgh->state != install_state_t::installed)
continue;
const StatusParagraph& pgh = pgh_and_file.pgh;
std::fstream listfile(paths.listfile_path(pgh->package));
while (std::getline(listfile, line))
for (const std::string& file : pgh_and_file.files)
{
if (line.empty())
if (file.find(file_substr) != std::string::npos)
{
continue;
}
if (line.find(file_substr) != std::string::npos)
{
System::println("%s: %s", pgh->package.displayname(), line);
System::println("%s: %s", pgh.package.displayname(), file);
}
}
}

59
toolsrc/src/vcpkg.cpp
View File

@ -109,6 +109,65 @@ void vcpkg::write_update(const vcpkg_paths& paths, const StatusParagraph& p)
fs::rename(tmp_update_filename, update_filename);
}
std::vector<StatusParagraph_and_associated_files> vcpkg::get_installed_files(const vcpkg_paths& paths, const StatusParagraphs& status_db)
{
static const std::string MARK_FOR_REMOVAL = "";
std::vector<StatusParagraph_and_associated_files> installed_files;
std::string line;
for (const std::unique_ptr<StatusParagraph>& pgh : status_db)
{
if (pgh->state != install_state_t::installed)
{
continue;
}
std::fstream listfile(paths.listfile_path(pgh->package));
std::vector<std::string> installed_files_of_current_pgh;
while (std::getline(listfile, line))
{
if (line.empty())
{
continue;
}
installed_files_of_current_pgh.push_back(line);
}
// Should already be sorted
std::sort(installed_files_of_current_pgh.begin(), installed_files_of_current_pgh.end());
// Since the files are sorted, we can detect the entries that represent directories
// by comparing every element with the next one and checking if the next has a slash immediately after the current one's length
for (int i = 1; i < installed_files_of_current_pgh.size(); i++)
{
std::string& current_string = installed_files_of_current_pgh.at(i - 1);
const std::string& next_string = installed_files_of_current_pgh.at(i);
const size_t potential_slash_char_index = current_string.length();
// Make sure the index exists first
if (next_string.size() > potential_slash_char_index && next_string.at(potential_slash_char_index) == '/')
{
current_string = MARK_FOR_REMOVAL;
}
}
installed_files_of_current_pgh.erase(std::remove_if(installed_files_of_current_pgh.begin(), installed_files_of_current_pgh.end(), [](const std::string& file)
{
return file == MARK_FOR_REMOVAL;
}),
installed_files_of_current_pgh.end());
const StatusParagraph_and_associated_files pgh_and_files = {*pgh, std::move(installed_files_of_current_pgh)};
installed_files.push_back(pgh_and_files);
}
return installed_files;
}
expected<SourceParagraph> vcpkg::try_load_port(const fs::path& path)
{
try