New syntaxdevelop

4 files changed, 222 insertions, 28 deletions

diff --git a/src/configure.cc b/src/configure.cc
index a8b50e0..1b8caa6 100644
--- a/src/configure.cc
+++ b/src/configure.cc
@@ -839,7 +839,7 @@ int regenerateCache(ctor::settings& settings,
 
 		for(const auto& ext : externalConfigs)
 		{
-			istr << "			{ \"" << esc(ext.name) << "\", {\n";
+			istr << "			{ \"" << esc(ext.name) << "\", ctor::flags{\n";
 			ctor::flags resolved_flags;
 			if(std::holds_alternative<ctor::external_manual>(ext.external))
 			{
@@ -858,7 +858,7 @@ int regenerateCache(ctor::settings& settings,
 
 			if(!resolved_flags.cflags.empty())
 			{
-				istr << "			  .cflags = {";
+				istr << "			  ctor::c_flags{";
 				for(const auto& flag : resolved_flags.cflags)
 				{
 					istr << flag << ",";
@@ -868,7 +868,7 @@ int regenerateCache(ctor::settings& settings,
 
 			if(!resolved_flags.cxxflags.empty())
 			{
-				istr << "			  .cxxflags = {";
+				istr << "			  ctor::cxx_flags{";
 				for(const auto& flag : resolved_flags.cxxflags)
 				{
 					istr << flag << ",";
@@ -878,7 +878,7 @@ int regenerateCache(ctor::settings& settings,
 
 			if(!resolved_flags.ldflags.empty())
 			{
-				istr << "			  .ldflags = {";
+				istr << "			  ctor::ld_flags{";
 				for(const auto& flag : resolved_flags.ldflags)
 				{
 					istr << flag << ",";
@@ -888,7 +888,7 @@ int regenerateCache(ctor::settings& settings,
 
 			if(!resolved_flags.asmflags.empty())
 			{
-				istr << "			  .asmflags = {";
+				istr << "			  ctor::asm_flags{";
 				for(const auto& flag : resolved_flags.asmflags)
 				{
 					istr << flag << ",";
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;
diff --git a/src/task_fn.cc b/src/task_fn.cc
index b712e70..4f27cc7 100644
--- a/src/task_fn.cc
+++ b/src/task_fn.cc
@@ -24,7 +24,7 @@ TaskFn::TaskFn(ctor::target_type resolved_target_type,
 	                                    sourceDir.parent_path());
 	source_language = source.language;
 
-	if(std::holds_alternative<ctor::GeneratorOneToOne>(config.function))
+	if(config.function_one_to_one)
 	{
 		if(source.source_type == ctor::source_type::generated)
 		{
@@ -41,7 +41,7 @@ TaskFn::TaskFn(ctor::target_type resolved_target_type,
 		}
 		_targetFile = base / source.output;
 	}
-	else if(std::holds_alternative<ctor::GeneratorManyToOne>(config.function))
+	else if(config.function_many_to_one)
 	{
 		for(const auto& src : config.sources)
 		{
@@ -74,7 +74,7 @@ bool TaskFn::dirtyInner()
 		return true;
 	}
 
-	if(std::holds_alternative<ctor::GeneratorManyToOne>(config.function))
+	if(config.function_many_to_one)
 	{
 		if(!std::filesystem::exists(sourceListFile))
 		{
@@ -94,7 +94,7 @@ bool TaskFn::dirtyInner()
 
 	std::filesystem::file_time_type last_changed{};
 	bool missing{false};
-	if(std::holds_alternative<ctor::GeneratorOneToOne>(config.function))
+	if(config.function_one_to_one)
 	{
 		if(!std::filesystem::exists(sourceFile))
 		{
@@ -102,7 +102,7 @@ bool TaskFn::dirtyInner()
 		}
 		last_changed = std::filesystem::last_write_time(sourceFile);
 	}
-	else if(std::holds_alternative<ctor::GeneratorManyToOne>(config.function))
+	else if(config.function_many_to_one)
 	{
 		bool first{true};
 		for(const auto& source : sources)
@@ -144,7 +144,7 @@ bool TaskFn::dirtyInner()
 
 int TaskFn::runInner()
 {
-	if(std::holds_alternative<ctor::GeneratorManyToOne>(config.function))
+	if(config.function_many_to_one)
 	{
 		// Write sourceList to file.
 		std::ofstream sourceListStream(sourceListFile.string());
@@ -160,20 +160,17 @@ int TaskFn::runInner()
 	}
 
 	int res{};
-	if(std::holds_alternative<std::monostate>(config.function))
+	if(config.function_one_to_one)
 	{
-	}
-	else if(std::holds_alternative<ctor::GeneratorOneToOne>(config.function))
-	{
-		auto func = std::get<ctor::GeneratorOneToOne>(config.function);
+		auto func = config.function_one_to_one;
 		res = func(sourceFile.string(),
 		           targetFile().string(),
 		           config,
 		           settings);
 	}
-	else if(std::holds_alternative<ctor::GeneratorManyToOne>(config.function))
+	else if(config.function_many_to_one)
 	{
-		auto func = std::get<ctor::GeneratorManyToOne>(config.function);
+		auto func = config.function_many_to_one;
 		res = func(sources,
 		           targetFile().string(),
 		           config,
@@ -196,7 +193,7 @@ int TaskFn::clean()
 		std::filesystem::remove(targetFile());
 	}
 
-	if(std::holds_alternative<ctor::GeneratorManyToOne>(config.function))
+	if(config.function_many_to_one)
 	{
 		if(std::filesystem::exists(sourceListFile))
 		{
@@ -211,7 +208,7 @@ int TaskFn::clean()
 std::vector<std::string> TaskFn::depends() const
 {
 	std::vector<std::string> deps;
-	if(std::holds_alternative<ctor::GeneratorManyToOne>(config.function))
+	if(config.function_many_to_one)
 	{
 		for(const auto& src : config.sources)
 		{
diff --git a/src/tasks.cc b/src/tasks.cc
index f520772..5e1d235 100644
--- a/src/tasks.cc
+++ b/src/tasks.cc
@@ -85,7 +85,7 @@ std::vector<std::shared_ptr<Task>> taskFactory(const ctor::build_configuration&
 	ctor::target_type resolved_target_type{config.type};
 	if(resolved_target_type == ctor::target_type::automatic)
 	{
-		if(!std::holds_alternative<std::monostate>(config.function))
+		if(config.function_one_to_one || config.function_many_to_one)
 		{
 			resolved_target_type = ctor::target_type::function;
 		}
@@ -103,8 +103,10 @@ std::vector<std::shared_ptr<Task>> taskFactory(const ctor::build_configuration&
 		for(const auto& source : config.sources)
 		{
 			if(source.toolchain == ctor::toolchain::any ||
-			   (config.system == ctor::output_system::build && source.toolchain == c.build_toolchain) ||
-			   (config.system == ctor::output_system::host && source.toolchain == c.host_toolchain))
+			   (config.system == ctor::output_system::build &&
+			    source.toolchain == c.build_toolchain) ||
+			   (config.system == ctor::output_system::host &&
+			    source.toolchain == c.host_toolchain))
 			{
 				auto task =
 					std::make_shared<TaskCC>(ctor::target_type::object, config, settings, sourceDir, source);
@@ -116,8 +118,7 @@ std::vector<std::shared_ptr<Task>> taskFactory(const ctor::build_configuration&
 #ifndef BOOTSTRAP
 	else
 	{
-		bool multi{std::holds_alternative<ctor::GeneratorManyToOne>(config.function)};
-		if(multi)
+		if(config.function_many_to_one)
 		{
 			auto task =
 				std::make_shared<TaskFn>(resolved_target_type, config, settings, sourceDir, "");