1 files changed, 73 insertions, 27 deletions

diff --git a/toolsrc/src/vcpkg/build.cpp b/toolsrc/src/vcpkg/build.cpp
index 7bd6f467b..1975d3aaf 100644
--- a/toolsrc/src/vcpkg/build.cpp
+++ b/toolsrc/src/vcpkg/build.cpp
@@ -23,6 +23,7 @@
 #include <vcpkg/vcpkglib.h>

 

 using vcpkg::Build::BuildResult;

+using vcpkg::Dependencies::PathsPortFileProvider;

 using vcpkg::Parse::ParseControlErrorInfo;

 using vcpkg::Parse::ParseExpected;

 

@@ -34,34 +35,26 @@ namespace vcpkg::Build::Command
     static constexpr StringLiteral OPTION_CHECKS_ONLY = "--checks-only";

 

     void perform_and_exit_ex(const FullPackageSpec& full_spec,

-                             const fs::path& port_dir,

+                             const SourceControlFileLocation& scfl,

                              const ParsedArguments& options,

                              const VcpkgPaths& paths)

     {

         const PackageSpec& spec = full_spec.package_spec;

+        const auto& scf = *scfl.source_control_file;

         if (Util::Sets::contains(options.switches, OPTION_CHECKS_ONLY))

         {

             const auto pre_build_info = Build::PreBuildInfo::from_triplet_file(paths, spec.triplet());

             const auto build_info = Build::read_build_info(paths.get_filesystem(), paths.build_info_file_path(spec));

-            const size_t error_count = PostBuildLint::perform_all_checks(spec, paths, pre_build_info, build_info);

+            const size_t error_count =

+                PostBuildLint::perform_all_checks(spec, paths, pre_build_info, build_info, scfl.source_location);

             Checks::check_exit(VCPKG_LINE_INFO, error_count == 0);

             Checks::exit_success(VCPKG_LINE_INFO);

         }

 

-        const ParseExpected<SourceControlFile> source_control_file =

-            Paragraphs::try_load_port(paths.get_filesystem(), port_dir);

-

-        if (!source_control_file.has_value())

-        {

-            print_error_message(source_control_file.error());

-            Checks::exit_fail(VCPKG_LINE_INFO);

-        }

-

-        const auto& scf = source_control_file.value_or_exit(VCPKG_LINE_INFO);

         Checks::check_exit(VCPKG_LINE_INFO,

-                           spec.name() == scf->core_paragraph->name,

+                           spec.name() == scf.core_paragraph->name,

                            "The Source field inside the CONTROL file does not match the port directory: '%s' != '%s'",

-                           scf->core_paragraph->name,

+                           scf.core_paragraph->name,

                            spec.name());

 

         const StatusParagraphs status_db = database_load_check(paths);

@@ -80,7 +73,7 @@ namespace vcpkg::Build::Command
         features_as_set.emplace("core");

 

         const Build::BuildPackageConfig build_config{

-            *scf, spec.triplet(), fs::path{port_dir}, build_package_options, features_as_set};

+            scf, spec.triplet(), fs::path(scfl.source_location), build_package_options, features_as_set};

 

         const auto build_timer = Chrono::ElapsedTimer::create_started();

         const auto result = Build::build_package(paths, build_config, status_db);

@@ -128,10 +121,19 @@ namespace vcpkg::Build::Command
         // Build only takes a single package and all dependencies must already be installed

         const ParsedArguments options = args.parse_arguments(COMMAND_STRUCTURE);

         std::string first_arg = args.command_arguments.at(0);

+

         const FullPackageSpec spec = Input::check_and_get_full_package_spec(

             std::move(first_arg), default_triplet, COMMAND_STRUCTURE.example_text);

+

         Input::check_triplet(spec.package_spec.triplet(), paths);

-        perform_and_exit_ex(spec, paths.port_dir(spec.package_spec), options, paths);

+

+        PathsPortFileProvider provider(paths, args.overlay_ports.get());

+        const auto port_name = spec.package_spec.name();

+        const auto* scfl = provider.get_control_file(port_name).get();

+

+        Checks::check_exit(VCPKG_LINE_INFO, scfl != nullptr, "Error: Couldn't find port '%s'", port_name);

+

+        perform_and_exit_ex(spec, *scfl, options, paths);

     }

 }

 

@@ -280,7 +282,7 @@ namespace vcpkg::Build
             start += "\n" + Strings::serialize(feature);

         }

         const fs::path binary_control_file = paths.packages / bcf.core_paragraph.dir() / "CONTROL";

-        paths.get_filesystem().write_contents(binary_control_file, start);

+        paths.get_filesystem().write_contents(binary_control_file, start, VCPKG_LINE_INFO);

     }

 

     static std::vector<FeatureSpec> compute_required_feature_specs(const BuildPackageConfig& config,

@@ -334,6 +336,23 @@ namespace vcpkg::Build
         return ret;

     }

 

+    static int get_concurrency()

+    {

+        static int concurrency = [] {

+            auto user_defined_concurrency = System::get_environment_variable("VCPKG_MAX_CONCURRENCY");

+            if (user_defined_concurrency)

+            {

+                return std::stoi(user_defined_concurrency.value_or_exit(VCPKG_LINE_INFO));

+            }

+            else

+            {

+                return System::get_num_logical_cores() + 1;

+            }

+        }();

+

+        return concurrency;

+    }

+

     static ExtendedBuildResult do_build_package(const VcpkgPaths& paths,

                                                 const PreBuildInfo& pre_build_info,

                                                 const PackageSpec& spec,

@@ -342,6 +361,18 @@ namespace vcpkg::Build
     {

         auto& fs = paths.get_filesystem();

         const Triplet& triplet = spec.triplet();

+        const auto& triplet_file_path = paths.get_triplet_file_path(spec.triplet()).u8string();

+

+        if (!Strings::case_insensitive_ascii_starts_with(triplet_file_path, 

+                                                         paths.triplets.u8string()))

+        {

+            System::printf("-- Loading triplet configuration from: %s\n", triplet_file_path);

+        }

+        if (!Strings::case_insensitive_ascii_starts_with(config.port_dir.u8string(),

+                                                         paths.ports.u8string()))

+        {

+            System::printf("-- Installing port from location: %s\n", config.port_dir.u8string());

+        }

 

 #if !defined(_WIN32)

         // TODO: remove when vcpkg.exe is in charge for acquiring tools. Change introduced in vcpkg v0.0.107.

@@ -365,6 +396,7 @@ namespace vcpkg::Build
             {"PORT", config.scf.core_paragraph->name},

             {"CURRENT_PORT_DIR", config.port_dir},

             {"TARGET_TRIPLET", spec.triplet().canonical_name()},

+            {"TARGET_TRIPLET_FILE", triplet_file_path},

             {"VCPKG_PLATFORM_TOOLSET", toolset.version.c_str()},

             {"VCPKG_USE_HEAD_VERSION", Util::Enum::to_bool(config.build_package_options.use_head_version) ? "1" : "0"},

             {"DOWNLOADS", paths.downloads},

@@ -372,6 +404,7 @@ namespace vcpkg::Build
             {"_VCPKG_DOWNLOAD_TOOL", to_string(config.build_package_options.download_tool)},

             {"FEATURES", Strings::join(";", config.feature_list)},

             {"ALL_FEATURES", all_features},

+            {"VCPKG_CONCURRENCY", std::to_string(get_concurrency())},

         };

 

         if (!System::get_environment_variable("VCPKG_FORCE_SYSTEM_BINARIES").has_value())

@@ -410,7 +443,8 @@ namespace vcpkg::Build
         }

 

         const BuildInfo build_info = read_build_info(fs, paths.build_info_file_path(spec));

-        const size_t error_count = PostBuildLint::perform_all_checks(spec, paths, pre_build_info, build_info);

+        const size_t error_count =

+            PostBuildLint::perform_all_checks(spec, paths, pre_build_info, build_info, config.port_dir);

 

         auto bcf = create_binary_control_file(*config.scf.core_paragraph, triplet, build_info, abi_tag);

 

@@ -547,7 +581,7 @@ namespace vcpkg::Build
             std::error_code ec;

             fs.create_directories(paths.buildtrees / name, ec);

             const auto abi_file_path = paths.buildtrees / name / (triplet.canonical_name() + ".vcpkg_abi_info.txt");

-            fs.write_contents(abi_file_path, full_abi_info);

+            fs.write_contents(abi_file_path, full_abi_info, VCPKG_LINE_INFO);

 

             return AbiTagAndFile{Hash::get_file_hash(fs, abi_file_path, "SHA1"), abi_file_path};

         }

@@ -560,7 +594,7 @@ namespace vcpkg::Build
         return nullopt;

     }

 

-    static void decompress_archive(const VcpkgPaths& paths, const PackageSpec& spec, const fs::path& archive_path)

+    static int decompress_archive(const VcpkgPaths& paths, const PackageSpec& spec, const fs::path& archive_path)

     {

         auto& fs = paths.get_filesystem();

 

@@ -574,12 +608,13 @@ namespace vcpkg::Build
 #if defined(_WIN32)

         auto&& seven_zip_exe = paths.get_tool_exe(Tools::SEVEN_ZIP);

 

-        System::cmd_execute_clean(Strings::format(

+        int result = System::cmd_execute_clean(Strings::format(

             R"("%s" x "%s" -o"%s" -y >nul)", seven_zip_exe.u8string(), archive_path.u8string(), pkg_path.u8string()));

 #else

-        System::cmd_execute_clean(

+        int result = System::cmd_execute_clean(

             Strings::format(R"(unzip -qq "%s" "-d%s")", archive_path.u8string(), pkg_path.u8string()));

 #endif

+        return result;

     }

 

     // Compress the source directory into the destination file.

@@ -665,11 +700,16 @@ namespace vcpkg::Build
             {

                 System::print2("Using cached binary package: ", archive_path.u8string(), "\n");

 

-                decompress_archive(paths, spec, archive_path);

+                auto archive_result = decompress_archive(paths, spec, archive_path);

+

+                if (archive_result != 0)

+                {

+                    System::print2("Failed to decompress archive package\n");

+                    return BuildResult::BUILD_FAILED;

+                }

 

                 auto maybe_bcf = Paragraphs::try_load_cached_package(paths, spec);

-                std::unique_ptr<BinaryControlFile> bcf =

-                    std::make_unique<BinaryControlFile>(std::move(maybe_bcf).value_or_exit(VCPKG_LINE_INFO));

+                auto bcf = std::make_unique<BinaryControlFile>(std::move(maybe_bcf).value_or_exit(VCPKG_LINE_INFO));

                 return {BuildResult::SUCCEEDED, std::move(bcf)};

             }

 

@@ -687,7 +727,7 @@ namespace vcpkg::Build
                 }

             }

 

-            System::print2("Could not locate cached archive: ", archive_path.u8string(), "\n");

+            System::printf("Could not locate cached archive: %s\n", archive_path.u8string());

 

             ExtendedBuildResult result = do_build_package_and_clean_buildtrees(

                 paths, pre_build_info, spec, maybe_abi_tag_and_file.value_or(AbiTagAndFile{}).tag, config);

@@ -863,7 +903,7 @@ namespace vcpkg::Build
 

         const fs::path& cmake_exe_path = paths.get_tool_exe(Tools::CMAKE);

         const fs::path ports_cmake_script_path = paths.scripts / "get_triplet_environment.cmake";

-        const fs::path triplet_file_path = paths.triplets / (triplet.canonical_name() + ".cmake");

+        const fs::path triplet_file_path = paths.get_triplet_file_path(triplet);

 

         const auto cmd_launch_cmake = System::make_cmake_cmd(cmake_exe_path,

                                                              ports_cmake_script_path,

@@ -967,6 +1007,12 @@ namespace vcpkg::Build
                 hash += "-";

                 hash += Hash::get_file_hash(fs, *p, "SHA1");

             }

+            else if (pre_build_info.cmake_system_name.empty() || 

+                     pre_build_info.cmake_system_name == "WindowsStore")

+            {

+                hash += "-";

+                hash += Hash::get_file_hash(fs, paths.scripts / "toolchains" / "windows.cmake", "SHA1");

+            }

             else if (pre_build_info.cmake_system_name == "Linux")

             {

                 hash += "-";