port

Author: kennykerr

cppwinrt.props

@@ -36,7 +36,7 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
 
   <PropertyGroup>
-    <XlangBuildVersion Condition="'$(XlangBuildVersion)'==''">2.3.4.5</XlangBuildVersion>
+    <CppWinRTBuildVersion Condition="'$(CppWinRTBuildVersion)'==''">2.3.4.5</CppWinRTBuildVersion>
     <CmakePlatform>$(Platform)</CmakePlatform>
     <CmakePlatform Condition="'$(Platform)'=='Win32'">x86</CmakePlatform>
     <CmakeOutDir Condition="'$(CmakeOutDir)'==''">$(SolutionDir)build\$(CmakePlatform)\$(Configuration)</CmakeOutDir>
@@ -53,7 +53,7 @@
       <LanguageStandard>stdcpp17</LanguageStandard>
       <PrecompiledHeader>Use</PrecompiledHeader>
       <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
-      <PreprocessorDefinitions>XLANG_VERSION_STRING="$(XlangBuildVersion)";NOMINMAX;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>CPPWINRT_VERSION_STRING="$(CppWinRTBuildVersion)";NOMINMAX;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
       <AdditionalOptions>/await /bigobj</AdditionalOptions>
       <AdditionalOptions Condition="'$(Clang)'=='1'">-Wno-unused-command-line-argument -fno-delayed-template-parsing -Xclang -fcoroutines-ts -mcx16</AdditionalOptions>
@@ -62,7 +62,7 @@
       <AdditionalDependencies>onecore.lib</AdditionalDependencies>
     </Link>
     <ResourceCompile>
-      <PreprocessorDefinitions>XLANG_VERSION_STRING="$(XlangBuildVersion)";%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>CPPWINRT_VERSION_STRING="$(CppWinRTBuildVersion)";%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ResourceCompile>
   </ItemDefinitionGroup>
 

cppwinrt/cmd_reader.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <assert.h>
 #include <array>
 #include <limits>
 #include <stdint.h>
@@ -14,10 +15,263 @@
 #include <Windows.h>
 #include <shlwapi.h>
 #include <XmlLite.h>
-#include "cmd_reader_windows.h"
 
-namespace xlang::cmd
+namespace cppwinrt
 {
+    struct registry_key
+    {
+        HKEY handle{};
+
+        registry_key(registry_key const&) = delete;
+        registry_key& operator=(registry_key const&) = delete;
+
+        ~registry_key() noexcept
+        {
+            if (handle)
+            {
+                RegCloseKey(handle);
+            }
+        }
+    };
+
+    template <typename T>
+    struct com_ptr
+    {
+        T* ptr{};
+
+        com_ptr(com_ptr const&) = delete;
+        com_ptr& operator=(com_ptr const&) = delete;
+
+        com_ptr() noexcept = default;
+
+        ~com_ptr() noexcept
+        {
+            if (ptr)
+            {
+                ptr->Release();
+            }
+        }
+
+        auto operator->() const noexcept
+        {
+            return ptr;
+        }
+    };
+
+    static void check_xml(HRESULT result)
+    {
+        if (result < 0)
+        {
+            throw std::invalid_argument("Could not read the Windows SDK's Platform.xml");
+        }
+    }
+
+    inline void add_files_from_xml(
+        std::set<std::string>& files,
+        std::string const& sdk_version,
+        std::filesystem::path const& xml_path,
+        std::filesystem::path const& sdk_path)
+    {
+        com_ptr<IStream> stream;
+
+        check_xml(SHCreateStreamOnFileW(
+            xml_path.c_str(),
+            STGM_READ, &stream.ptr));
+
+        com_ptr<IXmlReader> reader;
+
+        check_xml(CreateXmlReader(
+            __uuidof(IXmlReader),
+            reinterpret_cast<void**>(&reader.ptr),
+            nullptr));
+
+        check_xml(reader->SetInput(stream.ptr));
+        XmlNodeType node_type = XmlNodeType_None;
+
+        while (S_OK == reader->Read(&node_type))
+        {
+            if (node_type != XmlNodeType_Element)
+            {
+                continue;
+            }
+
+            wchar_t const* value{ nullptr };
+            check_xml(reader->GetLocalName(&value, nullptr));
+
+            if (0 != wcscmp(value, L"ApiContract"))
+            {
+                continue;
+            }
+
+            auto path = sdk_path;
+            path /= L"References";
+            path /= sdk_version;
+
+            check_xml(reader->MoveToAttributeByName(L"name", nullptr));
+            check_xml(reader->GetValue(&value, nullptr));
+            path /= value;
+
+            check_xml(reader->MoveToAttributeByName(L"version", nullptr));
+            check_xml(reader->GetValue(&value, nullptr));
+            path /= value;
+
+            check_xml(reader->MoveToAttributeByName(L"name", nullptr));
+            check_xml(reader->GetValue(&value, nullptr));
+            path /= value;
+
+            path += L".winmd";
+            files.insert(path.string());
+        }
+    }
+
+    inline registry_key open_sdk()
+    {
+        HKEY key;
+
+        if (0 != RegOpenKeyExW(
+            HKEY_LOCAL_MACHINE,
+            L"SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots",
+            0,
+            KEY_READ,
+            &key))
+        {
+            throw std::invalid_argument("Could not find the Windows SDK in the registry");
+        }
+
+        return { key };
+    }
+
+    inline std::filesystem::path get_sdk_path()
+    {
+        auto key = open_sdk();
+
+        DWORD path_size = 0;
+
+        if (0 != RegQueryValueExW(
+            key.handle,
+            L"KitsRoot10",
+            nullptr,
+            nullptr,
+            nullptr,
+            &path_size))
+        {
+            throw std::invalid_argument("Could not find the Windows SDK path in the registry");
+        }
+
+        std::wstring root((path_size / sizeof(wchar_t)) - 1, L'?');
+
+        RegQueryValueExW(
+            key.handle,
+            L"KitsRoot10",
+            nullptr,
+            nullptr,
+            reinterpret_cast<BYTE*>(root.data()),
+            &path_size);
+
+        return root;
+    }
+
+    inline std::string get_module_path()
+    {
+        std::string path(100, '?');
+        DWORD actual_size{};
+
+        while (true)
+        {
+            actual_size = GetModuleFileNameA(nullptr, path.data(), 1 + static_cast<uint32_t>(path.size()));
+
+            if (actual_size < 1 + path.size())
+            {
+                path.resize(actual_size);
+                break;
+            }
+            else
+            {
+                path.resize(path.size() * 2, '?');
+            }
+        }
+
+        return path;
+    }
+
+    inline std::string get_sdk_version()
+    {
+        auto module_path = get_module_path();
+        std::regex rx(R"(((\d+)\.(\d+)\.(\d+)\.(\d+)))");
+        std::cmatch match;
+        auto sdk_path = get_sdk_path();
+
+        if (std::regex_search(module_path.c_str(), match, rx))
+        {
+            auto path = sdk_path / "Platforms\\UAP" / match[1].str() / "Platform.xml";
+
+            if (std::filesystem::exists(path))
+            {
+                return match[1].str();
+            }
+        }
+
+        auto key = open_sdk();
+        uint32_t index{};
+        std::array<char, 100> subkey;
+        std::array<unsigned long, 4> version_parts{};
+        std::string result;
+
+        while (0 == RegEnumKeyA(key.handle, index++, subkey.data(), static_cast<uint32_t>(subkey.size())))
+        {
+            if (!std::regex_match(subkey.data(), match, rx))
+            {
+                continue;
+            }
+
+            auto path = sdk_path / "Platforms\\UAP" / match[1].str() / "Platform.xml";
+            if (!std::filesystem::exists(path))
+            {
+                continue;
+            }
+
+            char* next_part = subkey.data();
+            bool force_newer = false;
+
+            for (size_t i = 0; ; ++i)
+            {
+                auto version_part = strtoul(next_part, &next_part, 10);
+
+                if ((version_part < version_parts[i]) && !force_newer)
+                {
+                    break;
+                }
+                else if (version_part > version_parts[i])
+                {
+                    // E.g. ensure something like '2.1' is considered newer than '1.2'
+                    force_newer = true;
+                }
+
+                version_parts[i] = version_part;
+
+                if (i == std::size(version_parts) - 1)
+                {
+                    result = subkey.data();
+                    break;
+                }
+
+                if (!next_part)
+                {
+                    break;
+                }
+
+                ++next_part;
+            }
+        }
+
+        if (result.empty())
+        {
+            throw std::invalid_argument("Could not find the Windows SDK");
+        }
+
+        return result;
+    }
+
     [[noreturn]] inline void throw_invalid(std::string const& message)
     {
         throw std::invalid_argument(message);
@@ -47,14 +301,14 @@ namespace xlang::cmd
         template <typename C, typename V, size_t numOptions>
         reader(C const argc, V const argv, const option(& options)[numOptions])
         {
-#ifdef XLANG_DEBUG
+#ifdef _DEBUG
             {
                 std::set<std::string_view> unique;
 
                 for (auto&& option : options)
                 {
                     // If this assertion fails it means there are duplicate options.
-                    XLANG_ASSERT(unique.insert(option.name).second);
+                    assert(unique.insert(option.name).second);
                 }
             }
 #endif
@@ -180,7 +434,7 @@ namespace xlang::cmd
 
                 if (path == "sdk" || path == "sdk+")
                 {
-                    sdk_version = impl::get_sdk_version();
+                    sdk_version = get_sdk_version();
                 }
                 else
                 {
@@ -195,13 +449,13 @@ namespace xlang::cmd
 
                 if (!sdk_version.empty())
                 {
-                    auto sdk_path = impl::get_sdk_path();
+                    auto sdk_path = get_sdk_path();
                     auto xml_path = sdk_path;
                     xml_path /= L"Platforms\\UAP";
                     xml_path /= sdk_version;
                     xml_path /= L"Platform.xml";
 
-                    impl::add_files_from_xml(files, sdk_version, xml_path, sdk_path);
+                    add_files_from_xml(files, sdk_version, xml_path, sdk_path);
 
                     if (path.back() != '+')
                     {
@@ -213,7 +467,7 @@ namespace xlang::cmd
                         xml_path = item.path() / sdk_version;
                         xml_path /= L"SDKManifest.xml";
 
-                        impl::add_files_from_xml(files, sdk_version, xml_path, sdk_path);
+                        add_files_from_xml(files, sdk_version, xml_path, sdk_path);
                     }
 
                     continue;