From 668158a83bc9e5af7bf65fe88d22d1958e33443f Mon Sep 17 00:00:00 2001
From: Bent Bisballe Nyeng <deva@aasimon.org>
Date: Fri, 6 Feb 2026 18:25:41 +0100
Subject: New syntax

---
 src/ctor.h | 202 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 199 insertions(+), 3 deletions(-)

(limited to 'src/ctor.h')

diff --git a/src/ctor.h b/src/ctor.h
index 29c8f6d..890c257 100644
--- a/src/ctor.h
+++ b/src/ctor.h
@@ -269,6 +269,41 @@ using asm_flags = std::vector<ctor::asm_flag>;
 
 struct flags
 {
+	template <class ... Args>
+		requires ((
+		          std::is_same_v<Args, ctor::c_flags> ||
+		          std::is_same_v<Args, ctor::cxx_flags> ||
+		          std::is_same_v<Args, ctor::ld_flags> ||
+		          std::is_same_v<Args, ctor::ar_flags> ||
+		          std::is_same_v<Args, ctor::asm_flags>
+		          ) && ...)
+	constexpr flags(Args && ... arg)
+	{
+		([&]
+		{
+			if constexpr(std::is_same_v<Args, ctor::c_flags>)
+			{
+				cflags = arg;
+			}
+			else if constexpr(std::is_same_v<Args, ctor::cxx_flags>)
+			{
+				cxxflags = arg;
+			}
+			else if constexpr(std::is_same_v<Args, ctor::ld_flags>)
+			{
+				ldflags = arg;
+			}
+			else if constexpr(std::is_same_v<Args, ctor::ar_flags>)
+			{
+				arflags = arg;
+			}
+			else if constexpr(std::is_same_v<Args, ctor::asm_flags>)
+			{
+				asmflags = arg;
+			}
+		}(), ...);
+	}
+
 	ctor::c_flags cflags; // flags for c compiler
 	ctor::cxx_flags cxxflags; // flags for c++ compiler
 	ctor::ld_flags ldflags; // flags for linker
@@ -297,8 +332,110 @@ using GeneratorManyToOne =
 	                  const ctor::build_configuration& config,
 	                  const ctor::settings& settings)>;
 
+struct name
+{
+	std::string name;
+};
+
+struct target
+{
+	std::string target;
+};
+
+using sources = std::vector<ctor::source>;
+
+struct depends
+{
+	std::vector<std::string> depends;
+};
+
+struct externals
+{
+	std::vector<std::string> externals;
+};
+
 struct build_configuration
 {
+	template <class ... Args>
+		requires ((
+		          std::is_same_v<Args, ctor::name> ||
+		          std::is_same_v<Args, ctor::target_type> ||
+		          std::is_same_v<Args, ctor::output_system> ||
+		          std::is_same_v<Args, ctor::target> ||
+		          std::is_same_v<Args, ctor::sources> ||
+		          std::is_same_v<Args, ctor::depends> ||
+		          std::is_same_v<Args, ctor::externals> ||
+		          std::is_convertible_v<Args, ctor::GeneratorOneToOne> ||
+		          std::is_convertible_v<Args, ctor::GeneratorManyToOne> ||
+		          std::is_same_v<Args, ctor::c_flags> ||
+		          std::is_same_v<Args, ctor::cxx_flags> ||
+		          std::is_same_v<Args, ctor::ld_flags> ||
+		          std::is_same_v<Args, ctor::ar_flags> ||
+		          std::is_same_v<Args, ctor::asm_flags>
+		          ) && ...)
+	constexpr build_configuration(Args && ... arg)
+	{
+		([&]
+		{
+			if constexpr(std::is_same_v<Args, ctor::name>)
+			{
+				name = arg.name;
+			}
+			else if constexpr(std::is_same_v<Args, ctor::target_type>)
+			{
+				type = arg;
+			}
+			else if constexpr(std::is_same_v<Args, ctor::output_system>)
+			{
+				system = arg;
+			}
+			else if constexpr(std::is_same_v<Args, ctor::target>)
+			{
+				target = arg.target;
+			}
+			else if constexpr(std::is_same_v<Args, ctor::sources>)
+			{
+				sources = arg;
+			}
+			else if constexpr(std::is_same_v<Args, ctor::depends>)
+			{
+				depends = arg.depends;
+			}
+			else if constexpr(std::is_same_v<Args, ctor::externals>)
+			{
+				externals = arg.externals;
+			}
+			else if constexpr(std::is_convertible_v<Args, ctor::GeneratorOneToOne>)
+			{
+				function_one_to_one = arg;
+			}
+			else if constexpr(std::is_convertible_v<Args, ctor::GeneratorManyToOne>)
+			{
+				function_many_to_one = arg;
+			}
+			else if constexpr(std::is_same_v<Args, ctor::c_flags>)
+			{
+				flags.cflags = arg;
+			}
+			else if constexpr(std::is_same_v<Args, ctor::cxx_flags>)
+			{
+				flags.cxxflags = arg;
+			}
+			else if constexpr(std::is_same_v<Args, ctor::ld_flags>)
+			{
+				flags.ldflags = arg;
+			}
+			else if constexpr(std::is_same_v<Args, ctor::ar_flags>)
+			{
+				flags.arflags = arg;
+			}
+			else if constexpr(std::is_same_v<Args, ctor::asm_flags>)
+			{
+				flags.asmflags = arg;
+			}
+		}(), ...);
+	}
+
 	std::string name; // Name - used for referring in other configurations.
 	ctor::target_type type{ctor::target_type::automatic};
 	ctor::output_system system{ctor::output_system::build};
@@ -307,9 +444,8 @@ struct build_configuration
 	std::vector<std::string> depends; // internal target dependencies
 	ctor::flags flags;
 	std::vector<std::string> externals; // externals used by this configuration
-	std::variant<std::monostate,
-	             GeneratorOneToOne,
-	             GeneratorManyToOne> function;
+	ctor::GeneratorOneToOne function_one_to_one;
+	ctor::GeneratorManyToOne function_many_to_one;
 };
 
 using build_configurations = std::vector<build_configuration>;
@@ -320,12 +456,72 @@ int reg(std::function<ctor::build_configurations (const ctor::settings&)> cb,
 // This type will use flags verbatim
 struct external_manual
 {
+	template <class ... Args>
+		requires ((
+		          std::is_same_v<Args, ctor::c_flags> ||
+		          std::is_same_v<Args, ctor::cxx_flags> ||
+		          std::is_same_v<Args, ctor::ld_flags> ||
+		          std::is_same_v<Args, ctor::ar_flags> ||
+		          std::is_same_v<Args, ctor::asm_flags>
+		          ) && ...)
+	constexpr external_manual(Args && ... arg)
+	{
+		([&]
+		{
+			if constexpr(std::is_same_v<Args, ctor::c_flags>)
+			{
+				flags.cflags = arg;
+			}
+			else if constexpr(std::is_same_v<Args, ctor::cxx_flags>)
+			{
+				flags.cxxflags = arg;
+			}
+			else if constexpr(std::is_same_v<Args, ctor::ld_flags>)
+			{
+				flags.ldflags = arg;
+			}
+			else if constexpr(std::is_same_v<Args, ctor::ar_flags>)
+			{
+				flags.arflags = arg;
+			}
+			else if constexpr(std::is_same_v<Args, ctor::asm_flags>)
+			{
+				flags.asmflags = arg;
+			}
+		}(), ...);
+	}
+
 	ctor::flags flags;
 };
 
 
 struct external_configuration
 {
+	template <class ... Args>
+		requires ((
+		          std::is_same_v<Args, ctor::name> ||
+		          std::is_same_v<Args, ctor::output_system> ||
+		          std::is_same_v<Args, ctor::external_manual>
+		          ) && ...)
+	constexpr external_configuration(Args && ... arg)
+	{
+		([&]
+		{
+			if constexpr(std::is_same_v<Args, ctor::name>)
+			{
+				name = arg.name;
+			}
+			else if constexpr(std::is_same_v<Args, ctor::output_system>)
+			{
+				system = arg;
+			}
+			else if constexpr(std::is_same_v<Args, ctor::external_manual>)
+			{
+				external = arg;
+			}
+		}(), ...);
+	}
+
 	std::string name; // Name for configuration
 	ctor::output_system system{ctor::output_system::build};
 	std::variant<ctor::external_manual> external;
-- 
cgit v1.2.3