Merge branch 'master' of https://github.com/microsoft/vcpkg

20 files changed, 138 insertions, 106 deletions

diff --git a/toolsrc/include/vcpkg_Commands.h b/toolsrc/include/vcpkg_Commands.h
index c706c131c..c3da552f2 100644
--- a/toolsrc/include/vcpkg_Commands.h
+++ b/toolsrc/include/vcpkg_Commands.h
@@ -9,6 +9,7 @@ namespace vcpkg
 
     void print_usage();
     void print_example(const char* command_and_arguments);
+    std::string create_example_string(const char* command_and_arguments);
     void update_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths);
 
     void build_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths, const triplet& default_target_triplet);
diff --git a/toolsrc/include/vcpkg_Strings.h b/toolsrc/include/vcpkg_Strings.h
index 93e1389f8..dc17f35d2 100644
--- a/toolsrc/include/vcpkg_Strings.h
+++ b/toolsrc/include/vcpkg_Strings.h
@@ -19,6 +19,11 @@ namespace vcpkg {namespace Strings {namespace details
         return s;
     }
 
+    inline size_t to_printf_arg(const size_t s)
+    {
+        return s;
+    }
+
     std::string format_internal(const char* fmtstr, ...);
 
     inline const wchar_t* to_wprintf_arg(const std::wstring& s)
diff --git a/toolsrc/include/vcpkg_cmd_arguments.h b/toolsrc/include/vcpkg_cmd_arguments.h
index 7df3d64b1..54b97cde1 100644
--- a/toolsrc/include/vcpkg_cmd_arguments.h
+++ b/toolsrc/include/vcpkg_cmd_arguments.h
@@ -13,9 +13,11 @@ namespace vcpkg
     struct vcpkg_cmd_arguments
     {
         static vcpkg_cmd_arguments create_from_command_line(const int argc, const wchar_t* const* const argv);
-
         static vcpkg_cmd_arguments create_from_arg_sequence(const std::string* arg_begin, const std::string* arg_end);
 
+        static package_spec check_and_get_package_spec(const std::string& package_spec_as_string, const triplet& default_target_triplet, const char* example_text);
+        static std::vector<package_spec> check_and_get_package_specs(const std::vector<std::string>& package_specs_as_strings, const triplet& default_target_triplet, const char* example_text);
+
         std::unique_ptr<std::string> vcpkg_root_dir;
         std::unique_ptr<std::string> target_triplet;
         opt_bool debug = opt_bool::unspecified;
@@ -26,8 +28,12 @@ namespace vcpkg
         std::vector<std::string> command_arguments;
         std::unordered_set<std::string> check_and_get_optional_command_arguments(const std::vector<std::string>& valid_options) const;
 
-        void check_max_args(size_t arg_count, const char* example_text = nullptr) const;
-        std::vector<package_spec> parse_all_arguments_as_package_specs(const triplet& default_target_triplet, const char* example_text = nullptr) const;
+        void check_max_arg_count(const size_t expected_arg_count) const;
+        void check_max_arg_count(const size_t expected_arg_count, const char* example_text) const;
+        void check_min_arg_count(const size_t expected_arg_count) const;
+        void check_min_arg_count(const size_t expected_arg_count, const char* example_text) const;
+        void check_exact_arg_count(const size_t expected_arg_count) const;
+        void check_exact_arg_count(const size_t expected_arg_count, const char* example_text) const;
 
     private:
         std::unordered_set<std::string> optional_command_arguments;
diff --git a/toolsrc/include/vcpkg_paths.h b/toolsrc/include/vcpkg_paths.h
index d13c73b0b..046b6836c 100644
--- a/toolsrc/include/vcpkg_paths.h
+++ b/toolsrc/include/vcpkg_paths.h
@@ -9,28 +9,28 @@ namespace vcpkg
 
     struct vcpkg_paths
     {
-        static expected<vcpkg_paths> create(const std::tr2::sys::path& vcpkg_root_dir);
+        static expected<vcpkg_paths> create(const fs::path& vcpkg_root_dir);
 
         fs::path package_dir(const package_spec& spec) const;
         fs::path port_dir(const package_spec& spec) const;
         bool is_valid_triplet(const triplet& t) const;
 
-        std::tr2::sys::path root;
-        std::tr2::sys::path packages;
-        std::tr2::sys::path buildtrees;
-        std::tr2::sys::path downloads;
-        std::tr2::sys::path ports;
-        std::tr2::sys::path installed;
-        std::tr2::sys::path triplets;
+        fs::path root;
+        fs::path packages;
+        fs::path buildtrees;
+        fs::path downloads;
+        fs::path ports;
+        fs::path installed;
+        fs::path triplets;
 
-        std::tr2::sys::path buildsystems;
-        std::tr2::sys::path buildsystems_msbuild_targets;
+        fs::path buildsystems;
+        fs::path buildsystems_msbuild_targets;
 
-        std::tr2::sys::path vcpkg_dir;
-        std::tr2::sys::path vcpkg_dir_status_file;
-        std::tr2::sys::path vcpkg_dir_info;
-        std::tr2::sys::path vcpkg_dir_updates;
+        fs::path vcpkg_dir;
+        fs::path vcpkg_dir_status_file;
+        fs::path vcpkg_dir_info;
+        fs::path vcpkg_dir_updates;
 
-        std::tr2::sys::path ports_cmake;
+        fs::path ports_cmake;
     };
 }
diff --git a/toolsrc/src/commands_cache.cpp b/toolsrc/src/commands_cache.cpp
index 3a08c4a64..0d70f0f29 100644
--- a/toolsrc/src/commands_cache.cpp
+++ b/toolsrc/src/commands_cache.cpp
@@ -7,7 +7,7 @@ namespace vcpkg
 {
     void cache_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths)
     {
-        args.check_max_args(0);
+        args.check_exact_arg_count(0);
 
         auto begin_it = fs::directory_iterator(paths.packages);
         auto end_it = fs::directory_iterator();
diff --git a/toolsrc/src/commands_create.cpp b/toolsrc/src/commands_create.cpp
index 85b98d667..d365dac70 100644
--- a/toolsrc/src/commands_create.cpp
+++ b/toolsrc/src/commands_create.cpp
@@ -7,13 +7,9 @@ namespace vcpkg
 {
     void create_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths, const triplet& default_target_triplet)
     {
-        args.check_max_args(3);
-        if (args.command_arguments.size() < 2)
-        {
-            System::println(System::color::error, "Error: create requires the archive's URL as the second argument.");
-            print_usage();
-            exit(EXIT_FAILURE);
-        }
+        static const std::string example = create_example_string(R"###(create zlib2 http://zlib.net/zlib128.zip "zlib128-2.zip")###");
+        args.check_max_arg_count(3, example.c_str());
+        args.check_min_arg_count(2, example.c_str());
 
         expected<package_spec> current_spec = package_spec::from_string(args.command_arguments[0], default_target_triplet);
         if (const package_spec* spec = current_spec.get())
diff --git a/toolsrc/src/commands_edit.cpp b/toolsrc/src/commands_edit.cpp
index fe02bfa26..4973d6ef2 100644
--- a/toolsrc/src/commands_edit.cpp
+++ b/toolsrc/src/commands_edit.cpp
@@ -5,16 +5,16 @@ namespace vcpkg
 {
     void edit_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths, const triplet& default_target_triplet)
     {
-        static auto example = "edit zlib";
-        args.check_max_args(1, example);
-        package_spec spec = args.parse_all_arguments_as_package_specs(default_target_triplet, example).at(0);
+        static const std::string example = create_example_string("edit zlib");
+        args.check_exact_arg_count(1, example.c_str());
+        const package_spec spec = vcpkg_cmd_arguments::check_and_get_package_spec(args.command_arguments.at(0), default_target_triplet, example.c_str());
 
         // Find editor
         std::wstring env_EDITOR = System::wdupenv_str(L"EDITOR");
         if (env_EDITOR.empty())
             env_EDITOR = LR"(C:\Program Files (x86)\Microsoft VS Code\Code.exe)";
 
-        auto portpath = paths.ports / spec.name;
+        const fs::path portpath = paths.ports / spec.name;
         std::wstring cmdLine = Strings::wformat(LR"("%s" "%s" "%s")", env_EDITOR, portpath.native(), (portpath / "portfile.cmake").native());
         exit(System::cmd_execute(cmdLine));
     }
diff --git a/toolsrc/src/commands_help.cpp b/toolsrc/src/commands_help.cpp
index 4e1ae9c49..27dc168a4 100644
--- a/toolsrc/src/commands_help.cpp
+++ b/toolsrc/src/commands_help.cpp
@@ -6,7 +6,7 @@ namespace vcpkg
 {
     void version_command(const vcpkg_cmd_arguments& args)
     {
-        args.check_max_args(0);
+        args.check_exact_arg_count(0);
         System::println("Vcpkg package management program version %s\n"
                         "\n"
                         "Vcpkg is provided \"as-is\" without warranty of any kind, express or implied.\n"
@@ -17,7 +17,7 @@ namespace vcpkg
 
     void help_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths)
     {
-        args.check_max_args(1);
+        args.check_max_arg_count(1);
         if (args.command_arguments.empty())
         {
             print_usage();
@@ -37,8 +37,9 @@ namespace vcpkg
         exit(EXIT_SUCCESS);
     }
 
-    void contact_command(const vcpkg_cmd_arguments& /*args*/)
+    void contact_command(const vcpkg_cmd_arguments& args)
     {
+        args.check_exact_arg_count(0);
         System::println("Send an email to vcpkg@microsoft.com with any feedback.");
         exit(EXIT_SUCCESS);
     }
diff --git a/toolsrc/src/commands_import.cpp b/toolsrc/src/commands_import.cpp
index b1eae277c..9cfc53d6c 100644
--- a/toolsrc/src/commands_import.cpp
+++ b/toolsrc/src/commands_import.cpp
@@ -1,17 +1,12 @@
 #include "vcpkg_Commands.h"
 #include "vcpkg.h"
-#include "vcpkg_System.h"
 
 namespace vcpkg
 {
     void import_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths)
     {
-        if (args.command_arguments.size() != 3)
-        {
-            System::println(System::color::error, "Error: %s requires 3 parameters", args.command);
-            print_example(Strings::format(R"(%s C:\path\to\CONTROLfile C:\path\to\includedir C:\path\to\projectdir)", args.command).c_str());
-            exit(EXIT_FAILURE);
-        }
+        static const std::string example = create_example_string(R"(import C:\path\to\CONTROLfile C:\path\to\includedir C:\path\to\projectdir)");
+        args.check_exact_arg_count(3, example.c_str());
 
         const fs::path control_file_path(args.command_arguments[0]);
         const fs::path include_directory(args.command_arguments[1]);
diff --git a/toolsrc/src/commands_installation.cpp b/toolsrc/src/commands_installation.cpp
index 2890184fb..9eacfedcc 100644
--- a/toolsrc/src/commands_installation.cpp
+++ b/toolsrc/src/commands_installation.cpp
@@ -65,9 +65,11 @@ namespace vcpkg
 
     void install_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths, const triplet& default_target_triplet)
     {
+        static const std::string example = create_example_string("install zlib zlib:x64-windows curl boost");
+        args.check_min_arg_count(1, example.c_str());
         StatusParagraphs status_db = database_load_check(paths);
 
-        std::vector<package_spec> specs = args.parse_all_arguments_as_package_specs(default_target_triplet);
+        std::vector<package_spec> specs = vcpkg_cmd_arguments::check_and_get_package_specs(args.command_arguments, default_target_triplet, example.c_str());
         std::vector<package_spec> install_plan = Dependencies::create_dependency_ordered_install_plan(paths, specs, status_db);
         Checks::check_exit(!install_plan.empty(), "Install plan cannot be empty");
         std::string specs_string = to_string(install_plan[0]);
@@ -120,13 +122,15 @@ namespace vcpkg
 
     void build_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths, const triplet& default_target_triplet)
     {
+        static const std::string example = create_example_string("build zlib:x64-windows");
+
         // Installing multiple packages leads to unintuitive behavior if one of them depends on another.
-        // Allowing only 1 package for now. 
-        args.check_max_args(1);
+        // Allowing only 1 package for now.
 
+        args.check_exact_arg_count(1, example.c_str());
         StatusParagraphs status_db = database_load_check(paths);
 
-        const package_spec spec = args.parse_all_arguments_as_package_specs(default_target_triplet).at(0);
+        const package_spec spec = vcpkg_cmd_arguments::check_and_get_package_spec(args.command_arguments.at(0), default_target_triplet, example.c_str());
         std::unordered_set<package_spec> unmet_dependencies = Dependencies::find_unmet_dependencies(paths, spec, status_db);
         if (!unmet_dependencies.empty())
         {
@@ -148,12 +152,8 @@ namespace vcpkg
 
     void build_external_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths, const triplet& default_target_triplet)
     {
-        if (args.command_arguments.size() != 2)
-        {
-            System::println(System::color::error, "Error: buildexternal requires the package name and the directory containing the CONTROL file");
-            print_example(R"(buildexternal mylib C:\path\to\mylib\)");
-            exit(EXIT_FAILURE);
-        }
+        static const std::string example = create_example_string(R"(build_external zlib2 C:\path\to\dir\with\controlfile\)");
+        args.check_exact_arg_count(2, example.c_str());
 
         expected<package_spec> current_spec = package_spec::from_string(args.command_arguments[0], default_target_triplet);
         if (auto spec = current_spec.get())
diff --git a/toolsrc/src/commands_integration.cpp b/toolsrc/src/commands_integration.cpp
index 743a57a70..6a11d6ec4 100644
--- a/toolsrc/src/commands_integration.cpp
+++ b/toolsrc/src/commands_integration.cpp
@@ -297,13 +297,9 @@ With a project open, go to Tools->NuGet Package Manager->Package Manager Console
 
     void integrate_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths)
     {
-        if (args.command_arguments.size() != 1)
-        {
-            std::cout << "Commands:\n" <<
-                INTEGRATE_COMMAND_HELPSTRING <<
-                "\n";
-            exit(EXIT_FAILURE);
-        }
+        static const std::string example = Strings::format("Commands:\n"
+                                                           "%s", INTEGRATE_COMMAND_HELPSTRING);
+        args.check_exact_arg_count(1, example.c_str());
 
         if (args.command_arguments[0] == "install")
         {
diff --git a/toolsrc/src/commands_list.cpp b/toolsrc/src/commands_list.cpp
index 2969ea953..194e4b435 100644
--- a/toolsrc/src/commands_list.cpp
+++ b/toolsrc/src/commands_list.cpp
@@ -6,7 +6,7 @@ namespace vcpkg
 {
     void list_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths)
     {
-        args.check_max_args(0);
+        args.check_exact_arg_count(0);
 
         std::vector<std::string> packages_output;
         for (auto&& pgh : database_load_check(paths))
diff --git a/toolsrc/src/commands_other.cpp b/toolsrc/src/commands_other.cpp
index f4fad6690..4ba4112d4 100644
--- a/toolsrc/src/commands_other.cpp
+++ b/toolsrc/src/commands_other.cpp
@@ -41,10 +41,16 @@ namespace vcpkg
             , INTEGRATE_COMMAND_HELPSTRING);
     }
 
+    std::string create_example_string(const char* command_and_arguments)
+    {
+        std::string cs = Strings::format("Example:\n"
+                                         "  vcpkg %s", command_and_arguments);
+        return cs;
+    }
+
     void print_example(const char* command_and_arguments)
     {
-        System::println("Example:\n"
-                        "  vcpkg %s", command_and_arguments);
+        System::println(create_example_string(command_and_arguments).c_str());
     }
 
     void internal_test_command(const vcpkg_cmd_arguments& /*args*/, const vcpkg_paths& /*paths*/)
diff --git a/toolsrc/src/commands_owns.cpp b/toolsrc/src/commands_owns.cpp
index 19c0a8dc6..b3dab2e44 100644
--- a/toolsrc/src/commands_owns.cpp
+++ b/toolsrc/src/commands_owns.cpp
@@ -6,13 +6,9 @@ namespace vcpkg
 {
     void owns_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths)
     {
-        args.check_max_args(1);
-        if (args.command_arguments.size() == 0)
-        {
-            System::println(System::color::error, "Error: owns requires a pattern to search for as the first argument.");
-            print_example("owns .dll");
-            exit(EXIT_FAILURE);
-        }
+        static const std::string example = Strings::format("The argument should be a pattern to search for. %s", create_example_string("owns zlib.dll"));
+        args.check_exact_arg_count(1, example.c_str());
+
         StatusParagraphs status_db = database_load_check(paths);
         search_file(paths, args.command_arguments[0], status_db);
         exit(EXIT_SUCCESS);
diff --git a/toolsrc/src/commands_remove.cpp b/toolsrc/src/commands_remove.cpp
index f5315ccb1..fd0c43de5 100644
--- a/toolsrc/src/commands_remove.cpp
+++ b/toolsrc/src/commands_remove.cpp
@@ -22,10 +22,13 @@ namespace vcpkg
 
     void remove_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths, const triplet& default_target_triplet)
     {
+        static const std::string example = create_example_string("remove zlib zlib:x64-windows curl boost");
+        args.check_min_arg_count(1, example.c_str());
+
         const std::unordered_set<std::string> options = args.check_and_get_optional_command_arguments({OPTION_PURGE});
         auto status_db = database_load_check(paths);
 
-        std::vector<package_spec> specs = args.parse_all_arguments_as_package_specs(default_target_triplet);
+        std::vector<package_spec> specs = vcpkg_cmd_arguments::check_and_get_package_specs(args.command_arguments, default_target_triplet, example.c_str());
         bool alsoRemoveFolderFromPackages = options.find(OPTION_PURGE) != options.end();
 
         for (const package_spec& spec : specs)
diff --git a/toolsrc/src/commands_search.cpp b/toolsrc/src/commands_search.cpp
index ce02e9c3b..36926764b 100644
--- a/toolsrc/src/commands_search.cpp
+++ b/toolsrc/src/commands_search.cpp
@@ -38,7 +38,9 @@ namespace vcpkg
 
     void search_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths)
     {
-        args.check_max_args(1);
+        static const std::string example = Strings::format("The argument should be a substring to search for, or no argument to display all libraries.\n%s", create_example_string("search png"));
+        args.check_max_arg_count(1, example.c_str());
+
         if (args.command_arguments.size() == 0)
         {
             do_print(paths, [](std::string&) -> bool
diff --git a/toolsrc/src/commands_update.cpp b/toolsrc/src/commands_update.cpp
index 3cd7af027..b34530f40 100644
--- a/toolsrc/src/commands_update.cpp
+++ b/toolsrc/src/commands_update.cpp
@@ -5,8 +5,9 @@
 
 namespace vcpkg
 {
-    void update_command(const vcpkg_cmd_arguments& /*args*/, const vcpkg_paths& paths)
+    void update_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths)
     {
+        args.check_exact_arg_count(0);
         System::println("Using local portfile versions. To update the local portfiles, use `git pull`.");
 
         auto status_db = database_load_check(paths);
diff --git a/toolsrc/src/post_build_lint.cpp b/toolsrc/src/post_build_lint.cpp
index 8bd9838c6..29710bd14 100644
--- a/toolsrc/src/post_build_lint.cpp
+++ b/toolsrc/src/post_build_lint.cpp
@@ -309,7 +309,7 @@ namespace vcpkg
         return lint_status::SUCCESS;
     }
 
-    static void operator +=(unsigned int& left, const lint_status& right)
+    static void operator +=(size_t& left, const lint_status& right)
     {
         left += static_cast<unsigned int>(right);
     }
@@ -317,7 +317,7 @@ namespace vcpkg
     void perform_all_checks(const package_spec& spec, const vcpkg_paths& paths)
     {
         System::println("-- Performing post-build validation");
-        unsigned int error_count = 0;
+        size_t error_count = 0;
         error_count += check_for_files_in_include_directory(spec, paths);
         error_count += check_for_files_in_debug_include_directory(spec, paths);
         error_count += check_for_files_in_debug_share_directory(spec, paths);
@@ -345,7 +345,7 @@ namespace vcpkg
         if (error_count != 0)
         {
             const fs::path portfile = paths.ports / spec.name / "portfile.cmake";
-            System::println(System::color::error, "Found %d error(s). Please correct the portfile:\n    %s", error_count, portfile.string());
+            System::println(System::color::error, "Found %u error(s). Please correct the portfile:\n    %s", error_count, portfile.string());
             exit(EXIT_FAILURE);
         }
 
diff --git a/toolsrc/src/vcpkg_cmd_arguments.cpp b/toolsrc/src/vcpkg_cmd_arguments.cpp
index ec6946b98..f1ab4e937 100644
--- a/toolsrc/src/vcpkg_cmd_arguments.cpp
+++ b/toolsrc/src/vcpkg_cmd_arguments.cpp
@@ -50,6 +50,30 @@ namespace vcpkg
         option_field = new_setting;
     }
 
+    package_spec vcpkg_cmd_arguments::check_and_get_package_spec(const std::string& package_spec_as_string, const triplet& default_target_triplet, const char* example_text)
+    {
+        expected<package_spec> expected_spec = package_spec::from_string(package_spec_as_string, default_target_triplet);
+        if (auto spec = expected_spec.get())
+        {
+            return *spec;
+        }
+
+        System::println(System::color::error, "Error: %s: %s", expected_spec.error_code().message(), package_spec_as_string);
+        System::print(example_text);
+        exit(EXIT_FAILURE);
+    }
+
+    std::vector<package_spec> vcpkg_cmd_arguments::check_and_get_package_specs(const std::vector<std::string>& package_specs_as_strings, const triplet& default_target_triplet, const char* example_text)
+    {
+        std::vector<package_spec> specs;
+        for (const std::string& spec : package_specs_as_strings)
+        {
+            specs.push_back(check_and_get_package_spec(spec, default_target_triplet, example_text));
+        }
+
+        return specs;
+    }
+
     vcpkg_cmd_arguments vcpkg_cmd_arguments::create_from_command_line(const int argc, const wchar_t* const* const argv)
     {
         std::vector<std::string> v;
@@ -166,49 +190,51 @@ namespace vcpkg
         return output;
     }
 
-    void vcpkg_cmd_arguments::check_max_args(size_t arg_count, const char* example_text) const
+    void vcpkg_cmd_arguments::check_max_arg_count(const size_t expected_arg_count) const
     {
-        if (command_arguments.size() > arg_count)
+        return check_max_arg_count(expected_arg_count, "");
+    }
+
+    void vcpkg_cmd_arguments::check_min_arg_count(const size_t expected_arg_count) const
+    {
+        return check_min_arg_count(expected_arg_count, "");
+    }
+
+    void vcpkg_cmd_arguments::check_exact_arg_count(const size_t expected_arg_count) const
+    {
+        return check_exact_arg_count(expected_arg_count, "");
+    }
+
+    void vcpkg_cmd_arguments::check_max_arg_count(const size_t expected_arg_count, const char* example_text) const
+    {
+        const size_t actual_arg_count = command_arguments.size();
+        if (actual_arg_count > expected_arg_count)
         {
-            System::println(System::color::error, "Error: too many arguments to command %s", command);
-            if (example_text != nullptr)
-                print_example(example_text);
-            else
-                print_usage();
+            System::println(System::color::error, "Error: `%s` requires at most %u arguments, but %u were provided", this->command, expected_arg_count, actual_arg_count);
+            System::print(example_text);
             exit(EXIT_FAILURE);
         }
     }
 
-    std::vector<package_spec> vcpkg_cmd_arguments::parse_all_arguments_as_package_specs(const triplet& default_target_triplet, const char* example_text) const
+    void vcpkg_cmd_arguments::check_min_arg_count(const size_t expected_arg_count, const char* example_text) const
     {
-        size_t arg_count = command_arguments.size();
-        if (arg_count < 1)
+        const size_t actual_arg_count = command_arguments.size();
+        if (actual_arg_count < expected_arg_count)
         {
-            System::println(System::color::error, "Error: %s requires one or more package specifiers", this->command);
-            if (example_text == nullptr)
-                print_example(Strings::format("%s zlib zlib:x64-windows curl boost", this->command).c_str());
-            else
-                print_example(example_text);
+            System::println(System::color::error, "Error: `%s` requires at least %u arguments, but %u were provided", this->command, expected_arg_count, actual_arg_count);
+            System::print(example_text);
             exit(EXIT_FAILURE);
         }
-        std::vector<package_spec> specs;
-        specs.reserve(arg_count);
+    }
 
-        for (const std::string& command_argument : command_arguments)
+    void vcpkg_cmd_arguments::check_exact_arg_count(const size_t expected_arg_count, const char* example_text) const
+    {
+        const size_t actual_arg_count = command_arguments.size();
+        if (actual_arg_count != expected_arg_count)
         {
-            expected<package_spec> current_spec = package_spec::from_string(command_argument, default_target_triplet);
-            if (auto spec = current_spec.get())
-            {
-                specs.push_back(std::move(*spec));
-            }
-            else
-            {
-                System::println(System::color::error, "Error: %s: %s", current_spec.error_code().message(), command_argument);
-                print_example(Strings::format("%s zlib:x64-windows", this->command).c_str());
-                exit(EXIT_FAILURE);
-            }
+            System::println(System::color::error, "Error: `%s` requires %u arguments, but %u were provided", this->command, expected_arg_count, actual_arg_count);
+            System::print(example_text);
+            exit(EXIT_FAILURE);
         }
-
-        return specs;
     }
 }
diff --git a/toolsrc/src/vcpkg_paths.cpp b/toolsrc/src/vcpkg_paths.cpp
index 463f62c80..982eb9970 100644
--- a/toolsrc/src/vcpkg_paths.cpp
+++ b/toolsrc/src/vcpkg_paths.cpp
@@ -5,8 +5,6 @@
 #include "vcpkg_System.h"
 #include "package_spec.h"
 
-namespace fs = std::tr2::sys;
-
 namespace vcpkg
 {
     expected<vcpkg_paths> vcpkg_paths::create(const fs::path& vcpkg_root_dir)