Merge branch 'master' of git://github.com/Microsoft/vcpkg

1 files changed, 74 insertions, 10 deletions

diff --git a/toolsrc/src/Paragraphs.cpp b/toolsrc/src/Paragraphs.cpp
index 823b4a85e..cb90ed1ec 100644
--- a/toolsrc/src/Paragraphs.cpp
+++ b/toolsrc/src/Paragraphs.cpp
@@ -1,13 +1,12 @@
+#include "pch.h"
 #include "Paragraphs.h"
 #include "vcpkg_Files.h"
 
-namespace vcpkg { namespace Paragraphs
+namespace vcpkg::Paragraphs
 {
     struct Parser
     {
-        Parser(const char* c, const char* e) : cur(c), end(e)
-        {
-        }
+        Parser(const char* c, const char* e) : cur(c), end(e) { }
 
     private:
         const char* cur;
@@ -41,8 +40,8 @@ namespace vcpkg { namespace Paragraphs
         static bool is_alphanum(char ch)
         {
             return (ch >= 'A' && ch <= 'Z')
-                || (ch >= 'a' && ch <= 'z')
-                || (ch >= '0' && ch <= '9');
+                   || (ch >= 'a' && ch <= 'z')
+                   || (ch >= '0' && ch <= '9');
         }
 
         static bool is_lineend(char ch)
@@ -100,7 +99,7 @@ namespace vcpkg { namespace Paragraphs
             auto begin_fieldname = cur;
             while (is_alphanum(ch) || ch == '-')
                 next(ch);
-            Checks::check_throw(ch == ':', "Expected ':'");
+            Checks::check_exit(ch == ':', "Expected ':'");
             fieldname = std::string(begin_fieldname, cur);
 
             // skip ': '
@@ -118,7 +117,7 @@ namespace vcpkg { namespace Paragraphs
                 get_fieldname(ch, fieldname);
 
                 auto it = fields.find(fieldname);
-                Checks::check_throw(it == fields.end(), "Duplicate field");
+                Checks::check_exit(it == fields.end(), "Duplicate field");
 
                 get_fieldvalue(ch, fieldvalue);
 
@@ -153,11 +152,76 @@ namespace vcpkg { namespace Paragraphs
 
     std::vector<std::unordered_map<std::string, std::string>> get_paragraphs(const fs::path& control_path)
     {
-        return parse_paragraphs(Files::read_contents(control_path).get_or_throw());
+        const expected<std::string> contents = Files::read_contents(control_path);
+        if (auto spgh = contents.get())
+        {
+            return parse_paragraphs(*spgh);
+        }
+
+        Checks::exit_with_message("Error while reading %s: %s", control_path.generic_string(), contents.error_code().message());
     }
 
     std::vector<std::unordered_map<std::string, std::string>> parse_paragraphs(const std::string& str)
     {
         return Parser(str.c_str(), str.c_str() + str.size()).get_paragraphs();
     }
-}}
+
+    expected<SourceParagraph> try_load_port(const fs::path& path)
+    {
+        try
+        {
+            auto pghs = get_paragraphs(path / "CONTROL");
+            Checks::check_exit(pghs.size() == 1, "Invalid control file at %s\\CONTROL", path.string());
+            return SourceParagraph(pghs[0]);
+        }
+        catch (std::runtime_error const&) {}
+
+        return std::errc::no_such_file_or_directory;
+    }
+
+    expected<BinaryParagraph> try_load_cached_package(const vcpkg_paths& paths, const package_spec& spec)
+    {
+        const fs::path path = paths.package_dir(spec) / "CONTROL";
+
+        auto control_contents_maybe = Files::read_contents(path);
+        if (auto control_contents = control_contents_maybe.get())
+        {
+            std::vector<std::unordered_map<std::string, std::string>> pghs;
+            try
+            {
+                pghs = parse_paragraphs(*control_contents);
+            }
+            catch (std::runtime_error) {}
+            Checks::check_exit(pghs.size() == 1, "Invalid control file at %s", path.string());
+            return BinaryParagraph(pghs[0]);
+        }
+        return control_contents_maybe.error_code();
+    }
+
+    std::vector<SourceParagraph> load_all_ports(const fs::path& ports_dir)
+    {
+        std::vector<SourceParagraph> output;
+        for (auto it = fs::directory_iterator(ports_dir); it != fs::directory_iterator(); ++it)
+        {
+            const fs::path& path = it->path();
+            expected<SourceParagraph> source_paragraph = try_load_port(path);
+            if (auto srcpgh = source_paragraph.get())
+            {
+                output.emplace_back(std::move(*srcpgh));
+            }
+        }
+
+        return output;
+    }
+
+    std::map<std::string, std::string> extract_port_names_and_versions(const std::vector<SourceParagraph>& source_paragraphs)
+    {
+        std::map<std::string, std::string> names_and_versions;
+        for (const SourceParagraph& port : source_paragraphs)
+        {
+            names_and_versions.emplace(port.name, port.version);
+        }
+
+        return names_and_versions;
+    }
+}