#pragma once

namespace cppwinrt

{

struct finish_with

{

writer& w;

std::function<void(writer&)> finisher;

finish_with(writer& w, std::function<void(writer&)> finisher) : w(w), finisher(std::move(finisher)) {}

finish_with(finish_with const&)= delete;

void operator=(finish_with const&) = delete;

~finish_with() { finisher(w); }

};

static void write_nothing(writer&)

{

}

static void write_preamble(writer& w)

{

if (settings.license)

{

w.write(R"(// C++/WinRT v%

%

)", CPPWINRT_VERSION_STRING, settings.license_template);

}

else

{

w.write(R"(// WARNING: Please don't edit this file. It was generated by C++/WinRT v%

)", CPPWINRT_VERSION_STRING);

}

}

static void write_endif(writer& w, std::string_view macro = {})

{

if (macro.empty())

{

w.write("#endif\n");

}

else

{

w.write("#endif // %\n", macro);

}

}

// When modules are enabled, wraps a block of #include directives in

// #ifndef WINRT_IMPL_BUILD_MODULE ... #endif so that in module builds (where

// WINRT_IMPL_BUILD_MODULE is defined in the global module fragment), textual

// includes are suppressed — dependencies come via import instead.

[[nodiscard]] static finish_with wrap_module_aware_includes_guard(writer& w, bool modules_enabled)

{

if (modules_enabled)

{

w.write("#ifndef WINRT_IMPL_BUILD_MODULE\n");

return { w, [](writer& w) { write_endif(w, "WINRT_IMPL_BUILD_MODULE"); } };

}

else

{

return { w, write_nothing };

}

}

static void write_version_assert(writer& w)

{

w.write_root_include("base");

auto format = R"(static_assert(winrt::check_version(CPPWINRT_VERSION, "%"), "Mismatched C++/WinRT headers.");

#define CPPWINRT_VERSION "%"

)";

w.write(format, CPPWINRT_VERSION_STRING, CPPWINRT_VERSION_STRING);

}

static void write_include_guard(writer& w)

{

auto format = R"(#pragma once

)";

w.write(format);

}

static void write_close_file_guard(writer& w)

{

write_endif(w);

}

static void write_open_file_guard(writer& w, std::string_view const& file_name, char impl = 0)

{

write_include_guard(w);

std::string mangled_name;

for (auto&& c : file_name)

{

mangled_name += c == '.' ? '_' : c;

}

if (impl)

{

mangled_name += '_';

mangled_name += impl;

}

auto format = R"(#ifndef WINRT_%_H

#define WINRT_%_H

)";

w.write(format, mangled_name, mangled_name);

}

template<typename... Args>

[[nodiscard]] static finish_with wrap_open_file_guard(writer& w, Args&&... args)

{

write_open_file_guard(w, std::forward<Args>(args)...);

return { w, write_close_file_guard };

}

[[nodiscard]] static finish_with wrap_lean_and_mean(writer& w, bool is_lean_and_mean = true)

{

if (is_lean_and_mean)

{

auto format = R"(#ifndef WINRT_LEAN_AND_MEAN

)";

w.write(format);

return { w, [](writer& w) { write_endif(w, "WINRT_LEAN_AND_MEAN"); } };

}

else

{

return { w, write_nothing };

}

}

[[nodiscard]] static finish_with wrap_ifdef(writer& w, std::string_view macro)

{

auto format = R"(#ifdef %

)";

w.write(format, macro);

return { w, [macro = std::string(macro)](writer& w) { write_endif(w, macro); } };

}

[[nodiscard]] static finish_with wrap_ifndef(writer& w, std::string_view macro)

{

auto format = R"(#ifndef %

)";

w.write(format, macro);

return { w, [macro = std::string(macro)](writer& w) { write_endif(w, macro); } };

}

static void write_parent_depends(writer& w, cache const& c, std::string_view const& type_namespace)

{

auto pos = type_namespace.rfind('.');

if (pos == std::string::npos)

{

return;

}

auto parent = type_namespace.substr(0, pos);

auto found = c.namespaces().find(parent);

if (found != c.namespaces().end() && has_projected_types(found->second))

{

w.write_root_include(parent);

}

else

{

write_parent_depends(w, c, parent);

}

}

static void write_pch(writer& w)

{

auto format = R"(#include "%"

)";

if (!settings.component_pch.empty())

{

w.write(format, settings.component_pch);

}

}

static void write_close_namespace(writer& w)

{

auto format = R"(}

)";

w.write(format);

}

[[nodiscard]] static finish_with wrap_impl_namespace(writer& w)

{

auto format = R"(WINRT_EXPORT namespace winrt::impl

{

)";

w.write(format);

return { w, write_close_namespace };

}

[[nodiscard]] static finish_with wrap_std_namespace(writer& w)

{

w.write(R"(namespace std

{

)");

return { w, write_close_namespace };

}

[[nodiscard]] static finish_with wrap_type_namespace(writer& w, std::string_view const& ns)

{

auto format = R"(WINRT_EXPORT namespace winrt::@

{

)";

w.write(format, ns);

return { w, write_close_namespace };

}

static void write_enum_field(writer& w, Field const& field)

{

auto format = R"( % = %,

)";

if (auto constant = field.Constant())

{

w.write(format, field.Name(), *constant);

}

}

static void write_enum(writer& w, TypeDef const& type)

{

auto format = R"( enum class % : %

{

% };

)";

auto fields = type.FieldList();

w.write(format, type.TypeName(), fields.first.Signature().Type(), bind_each<write_enum_field>(fields));

}

static void write_enum_operators(writer& w, TypeDef const& type)

{

if (!has_attribute(type, "System", "FlagsAttribute"))

{

return;

}

auto name = type.TypeName();

auto format = R"( constexpr auto operator|(% const left, % const right) noexcept

{

return static_cast<%>(impl::to_underlying_type(left) | impl::to_underlying_type(right));

}

constexpr auto operator|=(%& left, % const right) noexcept

{

left = left | right;

return left;

}

constexpr auto operator&(% const left, % const right) noexcept

{

return static_cast<%>(impl::to_underlying_type(left) & impl::to_underlying_type(right));

}

constexpr auto operator&=(%& left, % const right) noexcept

{

left = left & right;

return left;

}

constexpr auto operator~(% const value) noexcept

{

return static_cast<%>(~impl::to_underlying_type(value));

}

constexpr auto operator^^(% const left, % const right) noexcept

{

return static_cast<%>(impl::to_underlying_type(left) ^^ impl::to_underlying_type(right));

}

constexpr auto operator^^=(%& left, % const right) noexcept

{

left = left ^^ right;

return left;

}

)";

w.write(format, name, name, name, name, name, name, name, name, name, name, name, name, name, name, name, name, name);

}

static void write_generic_typenames(writer& w, std::pair<GenericParam, GenericParam> const& params)

{

separator s{ w };

for (auto&& param : params)

{

s();

w.write("typename %", param);

}

}

static void write_generic_asserts(writer& w, std::pair<GenericParam, GenericParam> const& params)

{

for (auto&& param : params)

{

auto format = R"(

static_assert(impl::has_category_v<%>, "% must be WinRT type.");)";

w.write(format, param, param);

}

}

static void write_comma_generic_typenames(writer& w, std::pair<GenericParam, GenericParam> const& params)

{

for (auto&& param : params)

{

w.write(", typename %", param);

}

}

static void write_comma_generic_types(writer& w, std::pair<GenericParam, GenericParam> const& params)

{

for (auto&& param : params)

{

w.write(", %", param);

}

}

static void write_forward(writer& w, TypeDef const& type)

{

type_name type_name(type);

if (get_category(type) == category::enum_type)

{

auto format = R"( enum class % : %;

)";

w.write(format, type_name.name, type.FieldList().first.Signature().Type());

return;

}

if (type_name == "Windows.Foundation.DateTime" ||

type_name == "Windows.Foundation.TimeSpan")

{

// Don't forward declare these since they're not structs.

return;

}

if (type_name.name_space == "Windows.Foundation.Numerics")

{

if (type_name.name == "Matrix3x2" ||

type_name.name == "Matrix4x4" ||

type_name.name == "Plane" ||

type_name.name == "Quaternion" ||

type_name.name == "Vector2" ||

type_name.name == "Vector3" ||

type_name.name == "Vector4")

{

// Don't forward declare these since they're already defined with different names.

return;

}

}

auto generics = type.GenericParam();

if (empty(generics))

{

auto format = R"( struct %;

)";

w.write(format, type_name.name);

return;

}

auto format = R"( template <%> struct WINRT_IMPL_EMPTY_BASES %;

)";

w.write(format,

bind<write_generic_typenames>(generics),

remove_tick(type_name.name));

}

static void write_guid_value(writer& w, std::vector<FixedArgSig> const& args)

{

using std::get;

w.write_printf("0x%08X,0x%04X,0x%04X,{ 0x%02X,0x%02X,0x%02X,0x%02X,0x%02X,0x%02X,0x%02X,0x%02X }",

get<std::uint32_t>(get<ElemSig>(args[0].value).value),

get<std::uint16_t>(get<ElemSig>(args[1].value).value),

get<std::uint16_t>(get<ElemSig>(args[2].value).value),

get<std::uint8_t>(get<ElemSig>(args[3].value).value),

get<std::uint8_t>(get<ElemSig>(args[4].value).value),

get<std::uint8_t>(get<ElemSig>(args[5].value).value),

get<std::uint8_t>(get<ElemSig>(args[6].value).value),

get<std::uint8_t>(get<ElemSig>(args[7].value).value),

get<std::uint8_t>(get<ElemSig>(args[8].value).value),

get<std::uint8_t>(get<ElemSig>(args[9].value).value),

get<std::uint8_t>(get<ElemSig>(args[10].value).value));

}

static void write_guid_comment(writer& w, std::vector<FixedArgSig> const& args)

{

using std::get;

w.write_printf("%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",

get<std::uint32_t>(get<ElemSig>(args[0].value).value),

get<std::uint16_t>(get<ElemSig>(args[1].value).value),

get<std::uint16_t>(get<ElemSig>(args[2].value).value),

get<std::uint8_t>(get<ElemSig>(args[3].value).value),

get<std::uint8_t>(get<ElemSig>(args[4].value).value),

get<std::uint8_t>(get<ElemSig>(args[5].value).value),

get<std::uint8_t>(get<ElemSig>(args[6].value).value),

get<std::uint8_t>(get<ElemSig>(args[7].value).value),

get<std::uint8_t>(get<ElemSig>(args[8].value).value),

get<std::uint8_t>(get<ElemSig>(args[9].value).value),

get<std::uint8_t>(get<ElemSig>(args[10].value).value));

}

static void write_category(writer& w, TypeDef const& type, std::string_view const& category)

{

auto generics = type.GenericParam();

if (empty(generics))

{

auto format = R"( template <> struct category<%>{ using type = %; };

)";

w.write(format, type, category);

}

else

{

auto format = R"( template <%> struct category<%>{ using type = generic_category<%>; };

)";

w.write(format,

bind<write_generic_typenames>(generics),

type,

bind_list(", ", generics));

}

}

static void write_generic_names(writer& w, std::pair<GenericParam, GenericParam> const& params)

{

bool first = true;

for (auto&& param : params)

{

if (first)

{

first = false;

}

else

{

w.write(R"(, L", ")");

}

w.write(", name_v<%>", param.Name());

}

}

static void write_name(writer& w, TypeDef const& type)

{

type_name type_name(type);

auto generics = type.GenericParam();

if (empty(generics))

{

auto format = R"( template <> inline constexpr auto& name_v<%> = L"%.%";

)";

w.write(format, type, type_name.name_space, type_name.name);

}

else

{

auto format = R"( template <%> inline constexpr auto name_v<%> = zcombine(L"%.%<"%, L">");

)";

w.write(format,

bind<write_generic_typenames>(generics),

type,

type_name.name_space,

type_name.name,

bind<write_generic_names>(generics));

}

}

static void write_guid(writer& w, TypeDef const& type)

{

auto attribute = get_attribute(type, "Windows.Foundation.Metadata", "GuidAttribute");

if (!attribute)

{

throw_invalid("'Windows.Foundation.Metadata.GuidAttribute' attribute for type '", type.TypeNamespace(), ".", type.TypeName(), "' not found");

}

auto generics = type.GenericParam();

auto guid = attribute.Value().FixedArgs();

if (empty(generics))

{

auto format = R"( template <> inline constexpr guid guid_v<%>{ % }; // %

)";

w.write(format,

type,

bind<write_guid_value>(guid),

bind<write_guid_comment>(guid));

}

else

{

auto format = R"( template <%> inline constexpr guid guid_v<%>{ pinterface_guid<%>::value };

template <%> inline constexpr guid generic_guid_v<%>{ % }; // %

)";

w.write(format,

bind<write_generic_typenames>(generics),

type,

type,

bind<write_generic_typenames>(generics),

type,

bind<write_guid_value>(guid),

bind<write_guid_comment>(guid));

}

}

static void write_default_interface(writer& w, TypeDef const& type)

{

if (auto default_interface = get_default_interface(type))

{

auto format = R"( template <> struct default_interface<%>{ using type = %; };

)";

w.write(format, type, default_interface);

}

}

static void write_struct_category(writer& w, TypeDef const& type)

{

auto format = R"( template <> struct category<%>{ using type = struct_category<%>; };

)";

w.write(format, type, bind_list(", ", type.FieldList()));

}

static void write_array_size_name(writer& w, Param const& param)

{

if (w.param_names)

{

w.write(" __%Size", param.Name());

}

}

static void write_abi_arg_in(writer& w, TypeSig const& type)

{

if (std::holds_alternative<GenericTypeIndex>(type.Type()))

{

w.write("arg_in<%>", type);

}

else

{

w.write(type);

}

}

static void write_abi_arg_out(writer& w, TypeSig const& type)

{

if (std::holds_alternative<GenericTypeIndex>(type.Type()))

{

w.write("arg_out<%>", type);

}

else

{

w.write("%*", type);

}

}

static void write_abi_params(writer& w, method_signature const& method_signature)

{

auto abi_guard = w.push_abi_types(true);

separator s{ w };

for (auto&& [param, param_signature] : method_signature.params())

{

s();

if (param_signature->Type().is_szarray())

{

std::string_view format;

if (param.Flags().In())

{

format = "std::uint32_t%, %";

}

else if (param_signature->ByRef())

{

format = "std::uint32_t*%, %*";

}

else

{

format = "std::uint32_t%, %";

}

w.write(format, bind<write_array_size_name>(param), bind<write_abi_arg_out>(param_signature->Type()));

}

else

{

if (param.Flags().In())

{

write_abi_arg_in(w, param_signature->Type());

if (is_const(*param_signature))

{

w.write(" const&");

}

}

else

{

write_abi_arg_out(w, param_signature->Type());

}

}

if (w.param_names)

{

w.write(" %", param.Name());

}

}

if (method_signature.return_signature())

{

s();

auto const& type = method_signature.return_signature().Type();

if (type.is_szarray())

{

w.write("std::uint32_t* __%Size, %**", method_signature.return_param_name(), type);

}

else

{

write_abi_arg_out(w, type);

}

if (w.param_names)

{

w.write(" %", method_signature.return_param_name());

}

}

}

static void write_abi_args(writer& w, method_signature const& method_signature, bool start_comma)

{

separator s{ w };

if (start_comma)

{

s();

}

for (auto&& [param, param_signature] : method_signature.params())

{

s();

auto param_name = param.Name();

TypeDef signature_type;

auto category = get_category(param_signature->Type(), &signature_type);

if (param.Flags().In())

{

switch (category)

{

case param_category::object_type:

case param_category::string_type:

w.write("*(void**)(&%)", param_name);

break;

case param_category::generic_type:

case param_category::struct_type:

w.write("impl::bind_in(%)", param_name);

break;

case param_category::enum_type:

w.write("static_cast<%>(%)", signature_type.FieldList().first.Signature().Type(), param_name);

break;

case param_category::fundamental_type:

w.write(param_name);

break;

case param_category::array_type:

w.write("%.size(), get_abi(%)", param_name, param_name);

break;

}

}

else

{

switch (category)

{

case param_category::fundamental_type:

w.write("&%", param_name);

break;

case param_category::enum_type:

w.write("reinterpret_cast<%*>(&%)", signature_type.FieldList().first.Signature().Type(), param_name);

break;

case param_category::array_type:

if (param_signature->ByRef())

{

w.write("impl::put_size_abi(%), put_abi(%)", param_name, param_name);

}

else

{

w.write("%.size(), put_abi(%)", param_name, param_name);

}

break;

default:

w.write("impl::bind_out(%)", param_name);

break;

}

}

}

if (method_signature.return_signature())

{

s();

auto param_name = method_signature.return_param_name();

TypeDef signature_type;

auto category = get_category(method_signature.return_signature().Type(), &signature_type);

if (category == param_category::array_type)

{

w.write("&%_impl_size, &%", param_name, param_name);

}

else if (category == param_category::struct_type || category == param_category::generic_type)

{

w.write("put_abi(%)", param_name);

}

else if (category == param_category::enum_type)

{

w.write("reinterpret_cast<%*>(&%)", signature_type.FieldList().first.Signature().Type(), param_name);

}

else

{

w.write("&%", param_name);

}

}

}

static void write_fast_interface_abi(writer& w, TypeDef const& default_interface)

{

if (!settings.fastabi)

{

return;

}

auto pair = settings.fastabi_cache.find(default_interface);

if (pair == settings.fastabi_cache.end())

{

return;

}

auto bases = get_bases(pair->second);

std::for_each(bases.rbegin(), bases.rend(), [&](auto&& base)

{

auto format = R"( virtual void* __stdcall base_%() noexcept = 0;

)";

w.write(format, base.TypeName());

});

for (auto&& [name, info] : get_interfaces(w, pair->second))

{

if (info.is_default)

{

continue;

}

if (!info.fastabi)

{

break;

}

auto format = R"( virtual std::int32_t __stdcall %(%) noexcept = 0;

)";

for (auto&& method : info.type.MethodList())

{

method_signature signature{ method };

w.write(format, get_abi_name(method), bind<write_abi_params>(signature));

}

}

}

static void write_interface_abi(writer& w, TypeDef const& type)

{

auto generics = type.GenericParam();

auto guard{ w.push_generic_params(generics) };

if (empty(generics))

{

auto format = R"( template <> struct abi<%>

{

struct WINRT_IMPL_ABI_DECL type : inspectable_abi

{

)";

w.write(format, type);

}

else

{

auto format = R"( template <%> struct abi<%>

{

struct WINRT_IMPL_ABI_DECL type : inspectable_abi

{

)";

w.write(format,

bind<write_generic_typenames>(generics),

type);

}

auto format = R"( virtual std::int32_t __stdcall %(%) noexcept = 0;

)";

auto abi_guard = w.push_abi_types(true);

for (auto&& method : type.MethodList())

{

try

{

method_signature signature{ method };

w.write(format, get_abi_name(method), bind<write_abi_params>(signature));

}

catch (std::exception const& e)

{

throw_invalid(e.what(),

"\n method: ", get_name(method),

"\n type: ", type.TypeNamespace(), ".", type.TypeName(),

"\n database: ", type.get_database().path());

}

}

write_fast_interface_abi(w, type);

w.write(R"( };

};

)");

}

static void write_delegate_abi(writer& w, TypeDef const& type)

{

auto format = R"( template <%> struct abi<%>

{

struct WINRT_IMPL_ABI_DECL type : unknown_abi

{

virtual std::int32_t __stdcall Invoke(%) noexcept = 0;

};

};

)";

auto generics = type.GenericParam();

auto guard{ w.push_generic_params(generics) };

auto method = get_delegate_method(type);

method_signature signature{ method };

w.write(format,

bind<write_generic_typenames>(generics),

type,

bind<write_abi_params>(signature));

}

static void write_field_abi(writer& w, Field const& field)

{

w.write(" % %;\n", get_field_abi(w, field), field.Name());

}

static void write_struct_abi(writer& w, TypeDef const& type)

{

auto abi_guard = w.push_abi_types(true);

auto format = R"( struct struct_%

{

% };

template <> struct abi<@::%>

{

using type = struct_%;

};

)";

type_name type_name(type);

auto impl_name = get_impl_name(type_name.name_space, type_name.name);

w.write(format,

impl_name,

bind_each<write_field_abi>(type.FieldList()),

type_name.name_space, type_name.name,

impl_name);

}

static void write_consume_params(writer& w, method_signature const& signature)

{

separator s{ w };

for (auto&& [param, param_signature] : signature.params())

{

s();

if (param_signature->Type().is_szarray())

{

std::string_view format;

if (param.Flags().In())

{

format = "array_view<% const>";

}

else if (param_signature->ByRef())

{

format = "com_array<%>&";

}

else

{

format = "array_view<%>";

}

w.write(format, param_signature->Type().Type());

}

else

{

if (param.Flags().In())

{

assert(!param.Flags().Out());

w.consume_types = true;

auto param_type = std::get_if<ElementType>(&param_signature->Type().Type());

if (param_type && *param_type != ElementType::String && *param_type != ElementType::Object)

{

w.write("%", param_signature->Type());

}

else if (std::holds_alternative<GenericTypeIndex>(param_signature->Type().Type()))

{

w.write("impl::param_type<%> const&", param_signature->Type());

}

else

{

w.write("% const&", param_signature->Type());

}

w.consume_types = false;

}

else

{

assert(!param.Flags().In());

assert(param.Flags().Out());

w.write("%&", param_signature->Type());

}

}

w.write(" %", param.Name());

}

}

static void write_implementation_params(writer& w, method_signature const& method_signature)

{

separator s{ w };

for (auto&& [param, param_signature] : method_signature.params())

{

s();

if (param_signature->Type().is_szarray())

{

std::string_view format;

if (param.Flags().In())

{

format = "array_view<% const>";

}

else if (param_signature->ByRef())

{

format = "com_array<%>&";

}

else

{

format = "array_view<%>";

}

w.write(format, param_signature->Type().Type());

}

else

{

if (param.Flags().In())

{

assert(!param.Flags().Out());

auto param_type = std::get_if<ElementType>(&param_signature->Type().Type());

if ((!is_put_overload(method_signature.method()) && w.async_types) ||

(param_type && *param_type != ElementType::String && *param_type != ElementType::Object))