Add dual-arg flags and add debug flag with name and optional value.

3 files changed, 114 insertions, 30 deletions

diff --git a/src/ctor.h b/src/ctor.h
index e0e2bef..0892364 100644
--- a/src/ctor.h
+++ b/src/ctor.h
@@ -98,6 +98,7 @@ enum class cxx_opt
 	optimization,                    //  -O<arg>
 	position_independent_code,       //  -fPIC
 	position_independent_executable, //  -fPIE
+	define,                          //  -D<arg>[=<arg2>]
 	custom,                          // entire option taken verbatim from <arg>
 };
 
@@ -115,6 +116,7 @@ enum class c_opt
 	optimization,                    //  -O<arg>
 	position_independent_code,       //  -fPIC
 	position_independent_executable, //  -fPIE
+	define,                          //  -D<arg>[=<arg2>]
 	custom,                          // entire option taken verbatim from <arg>
 };
 
@@ -159,15 +161,21 @@ public:
 	flag(std::string_view str);
 	flag(const char* str);
 	flag(T opt_) : opt(opt_) {}
-	flag(T opt_, std::string_view arg_) : opt(opt_), arg(arg_) {}
-	flag(T opt_, const char* arg_) : opt(opt_), arg(arg_) {}
-	flag(ctor::toolchain toolchain_, T opt_) : toolchain(toolchain_), opt(opt_) {}
-	flag(ctor::toolchain toolchain_, T opt_, const char* arg_) : toolchain(toolchain_), opt(opt_), arg(arg_) {}
-	flag(ctor::toolchain toolchain_, T opt_, std::string_view arg_) : toolchain(toolchain_), opt(opt_), arg(arg_) {}
+	flag(T opt_, std::string_view arg_, std::string_view arg2_ = "")
+		: opt(opt_), arg(arg_), arg2(arg2_) {}
+	flag(T opt_, const char* arg_, const char* arg2_ = "")
+		: opt(opt_), arg(arg_), arg2(arg2_) {}
+	flag(ctor::toolchain toolchain_, T opt_)
+		: toolchain(toolchain_), opt(opt_) {}
+	flag(ctor::toolchain toolchain_, T opt_, const char* arg_, const char* arg2_ = "")
+		: toolchain(toolchain_), opt(opt_), arg(arg_), arg2(arg2_) {}
+	flag(ctor::toolchain toolchain_, T opt_, std::string_view arg_, std::string_view arg2_ = "")
+		: toolchain(toolchain_), opt(opt_), arg(arg_), arg2(arg2_) {}
 
 	ctor::toolchain toolchain{ctor::toolchain::any};
 	T opt{};
 	std::string arg;
+	std::string arg2;
 };
 
 using c_flag = ctor::flag<ctor::c_opt>;
diff --git a/src/tools.cc b/src/tools.cc
index 394a91c..eb98265 100644
--- a/src/tools.cc
+++ b/src/tools.cc
@@ -28,6 +28,7 @@ std::ostream& operator<<(std::ostream& stream, const ctor::c_opt& opt)
 	case ctor::c_opt::optimization: stream << "ctor::c_opt::optimization"; break;
 	case ctor::c_opt::position_independent_code: stream << "ctor::c_opt::position_independent_code"; break;
 	case ctor::c_opt::position_independent_executable: stream << "ctor::c_opt::position_independent_executable"; break;
+	case ctor::c_opt::define: stream << "ctor::c_opt::define"; break;
 	case ctor::c_opt::custom: stream << "ctor::c_opt::custom"; break;
 	}
 
@@ -50,6 +51,7 @@ std::ostream& operator<<(std::ostream& stream, const ctor::cxx_opt& opt)
 	case ctor::cxx_opt::optimization: stream << "ctor::cxx_opt::optimization"; break;
 	case ctor::cxx_opt::position_independent_code: stream << "ctor::cxx_opt::position_independent_code"; break;
 	case ctor::cxx_opt::position_independent_executable: stream << "ctor::cxx_opt::position_independent_executable"; break;
+	case ctor::cxx_opt::define: stream << "ctor::cxx_opt::define"; break;
 	case ctor::cxx_opt::custom: stream << "ctor::cxx_opt::custom"; break;
 	}
 
@@ -245,6 +247,19 @@ ctor::c_flag c_option(const std::string& flag)
 		return { ctor::c_opt::include_path, path };
 	}
 
+	if(flag.starts_with("-D"))
+	{
+		std::string def = flag.substr(2);
+		auto pos = def.find('=');
+		if(pos != def.npos)
+		{
+			return { ctor::c_opt::define, def.substr(0, pos), def.substr(pos + 1) };
+		}
+		else
+		{
+			return { ctor::c_opt::define, def };
+		}
+	}
 	return { ctor::c_opt::custom, flag };
 }
 
@@ -257,6 +272,20 @@ ctor::cxx_flag cxx_option(const std::string& flag)
 		return { ctor::cxx_opt::include_path, path };
 	}
 
+	if(flag.starts_with("-D"))
+	{
+		std::string def = flag.substr(2);
+		auto pos = def.find('=');
+		if(pos != def.npos)
+		{
+			return { ctor::cxx_opt::define, def.substr(0, pos), def.substr(pos + 1) };
+		}
+		else
+		{
+			return { ctor::cxx_opt::define, def };
+		}
+	}
+
 	return { ctor::cxx_opt::custom, flag };
 }
 
@@ -277,7 +306,8 @@ ctor::ar_flag ar_option(const std::string& flag)
 	return { ctor::ar_opt::custom, flag };
 }
 
-std::vector<std::string> cxx_option(ctor::cxx_opt opt, const std::string& arg)
+std::vector<std::string> cxx_option(ctor::cxx_opt opt, const std::string& arg,
+                                    const std::string& arg2)
 {
 	switch(opt)
 	{
@@ -303,6 +333,12 @@ std::vector<std::string> cxx_option(ctor::cxx_opt opt, const std::string& arg)
 		return {"-fPIC"};
 	case ctor::cxx_opt::position_independent_executable:
 		return {"-fPIE"};
+	case ctor::cxx_opt::define:
+		if(!arg2.empty())
+		{
+			return {"-D" + arg + "=" + arg2};
+		}
+		return {"-D" + arg};
 	case ctor::cxx_opt::custom:
 		return {arg};
 	}
@@ -311,7 +347,8 @@ std::vector<std::string> cxx_option(ctor::cxx_opt opt, const std::string& arg)
 	return {};
 }
 
-std::vector<std::string> c_option(ctor::c_opt opt, const std::string& arg)
+std::vector<std::string> c_option(ctor::c_opt opt, const std::string& arg,
+                                  const std::string& arg2)
 {
 	switch(opt)
 	{
@@ -337,6 +374,12 @@ std::vector<std::string> c_option(ctor::c_opt opt, const std::string& arg)
 		return {"-fPIC"};
 	case ctor::c_opt::position_independent_executable:
 		return {"-fPIE"};
+	case ctor::c_opt::define:
+		if(!arg2.empty())
+		{
+			return {"-D" + arg + "=" + arg2};
+		}
+		return {"-D" + arg};
 	case ctor::c_opt::custom:
 		return {arg};
 	}
@@ -345,7 +388,8 @@ std::vector<std::string> c_option(ctor::c_opt opt, const std::string& arg)
 	return {};
 }
 
-std::vector<std::string> ld_option(ctor::ld_opt opt, const std::string& arg)
+std::vector<std::string> ld_option(ctor::ld_opt opt, const std::string& arg,
+                                   [[maybe_unused]]const std::string& arg2)
 {
 	switch(opt)
 	{
@@ -379,7 +423,8 @@ std::vector<std::string> ld_option(ctor::ld_opt opt, const std::string& arg)
 	return {};
 }
 
-std::vector<std::string> ar_option(ctor::ar_opt opt, const std::string& arg)
+std::vector<std::string> ar_option(ctor::ar_opt opt, const std::string& arg,
+                                   [[maybe_unused]]const std::string& arg2)
 {
 	switch(opt)
 	{
@@ -399,7 +444,8 @@ std::vector<std::string> ar_option(ctor::ar_opt opt, const std::string& arg)
 	return {};
 }
 
-std::vector<std::string> asm_option(ctor::asm_opt opt, const std::string& arg)
+std::vector<std::string> asm_option(ctor::asm_opt opt, const std::string& arg,
+                                    [[maybe_unused]]const std::string& arg2)
 {
 	switch(opt)
 	{
@@ -444,13 +490,14 @@ ctor::arch get_arch(ctor::output_system system, const std::string& str)
 
 std::vector<std::string> c_option(ctor::toolchain toolchain,
                                   ctor::c_opt opt,
-                                  const std::string& arg)
+                                  const std::string& arg,
+                                  const std::string& arg2)
 {
 	switch(toolchain)
 	{
 	case ctor::toolchain::gcc:
 	case ctor::toolchain::clang:
-		return gcc::c_option(opt, arg);
+		return gcc::c_option(opt, arg, arg2);
 	case ctor::toolchain::any:
 		{
 			std::ostringstream ss;
@@ -459,6 +506,10 @@ std::vector<std::string> c_option(ctor::toolchain toolchain,
 			{
 				ss << ", \"" << arg << "\"";
 			}
+			if(!arg2.empty())
+			{
+				ss << ", \"" << arg2 << "\"";
+			}
 			ss << "}";
 			return { ss.str() };
 		}
@@ -472,13 +523,14 @@ std::vector<std::string> c_option(ctor::toolchain toolchain,
 
 std::vector<std::string> cxx_option(ctor::toolchain toolchain,
                                     ctor::cxx_opt opt,
-                                    const std::string& arg)
+                                    const std::string& arg,
+                                    const std::string& arg2)
 {
 	switch(toolchain)
 	{
 	case ctor::toolchain::gcc:
 	case ctor::toolchain::clang:
-		return gcc::cxx_option(opt, arg);
+		return gcc::cxx_option(opt, arg, arg2);
 	case ctor::toolchain::any:
 		{
 			std::ostringstream ss;
@@ -487,6 +539,10 @@ std::vector<std::string> cxx_option(ctor::toolchain toolchain,
 			{
 				ss << ", \"" << arg << "\"";
 			}
+			if(!arg2.empty())
+			{
+				ss << ", \"" << arg2 << "\"";
+			}
 			ss << "}";
 			return { ss.str() };
 		}
@@ -500,13 +556,14 @@ std::vector<std::string> cxx_option(ctor::toolchain toolchain,
 
 std::vector<std::string> ld_option(ctor::toolchain toolchain,
                                    ctor::ld_opt opt,
-                                   const std::string& arg)
+                                   const std::string& arg,
+                                   const std::string& arg2)
 {
 	switch(toolchain)
 	{
 	case ctor::toolchain::gcc:
 	case ctor::toolchain::clang:
-		return gcc::ld_option(opt, arg);
+		return gcc::ld_option(opt, arg, arg2);
 	case ctor::toolchain::any:
 		{
 			std::ostringstream ss;
@@ -515,6 +572,10 @@ std::vector<std::string> ld_option(ctor::toolchain toolchain,
 			{
 				ss << ", \"" << arg << "\"";
 			}
+			if(!arg2.empty())
+			{
+				ss << ", \"" << arg2 << "\"";
+			}
 			ss << "}";
 			return { ss.str() };
 		}
@@ -528,13 +589,14 @@ std::vector<std::string> ld_option(ctor::toolchain toolchain,
 
 std::vector<std::string> ar_option(ctor::toolchain toolchain,
                                    ctor::ar_opt opt,
-                                   const std::string& arg)
+                                   const std::string& arg,
+                                   const std::string& arg2)
 {
 	switch(toolchain)
 	{
 	case ctor::toolchain::gcc:
 	case ctor::toolchain::clang:
-		return gcc::ar_option(opt, arg);
+		return gcc::ar_option(opt, arg, arg2);
 	case ctor::toolchain::any:
 		{
 			std::ostringstream ss;
@@ -543,6 +605,10 @@ std::vector<std::string> ar_option(ctor::toolchain toolchain,
 			{
 				ss << ", \"" << arg << "\"";
 			}
+			if(!arg2.empty())
+			{
+				ss << ", \"" << arg2 << "\"";
+			}
 			ss << "}";
 			return { ss.str() };
 		}
@@ -556,13 +622,14 @@ std::vector<std::string> ar_option(ctor::toolchain toolchain,
 
 std::vector<std::string> asm_option(ctor::toolchain toolchain,
                                     ctor::asm_opt opt,
-                                    const std::string& arg)
+                                    const std::string& arg,
+                                    const std::string& arg2)
 {
 	switch(toolchain)
 	{
 	case ctor::toolchain::gcc:
 	case ctor::toolchain::clang:
-		return gcc::asm_option(opt, arg);
+		return gcc::asm_option(opt, arg, arg2);
 	case ctor::toolchain::any:
 		{
 			std::ostringstream ss;
@@ -571,6 +638,10 @@ std::vector<std::string> asm_option(ctor::toolchain toolchain,
 			{
 				ss << ", \"" << arg << "\"";
 			}
+			if(!arg2.empty())
+			{
+				ss << ", \"" << arg2 << "\"";
+			}
 			ss << "}";
 			return { ss.str() };
 		}
@@ -665,7 +736,7 @@ std::vector<std::string> to_strings(ctor::toolchain toolchain,
 	if(flag.toolchain == ctor::toolchain::any ||
 	   flag.toolchain == toolchain)
 	{
-		return c_option(toolchain, flag.opt, flag.arg);
+		return c_option(toolchain, flag.opt, flag.arg, flag.arg2);
 	}
 
 	return {};
@@ -677,7 +748,7 @@ std::vector<std::string> to_strings(ctor::toolchain toolchain,
 	if(flag.toolchain == ctor::toolchain::any ||
 	   flag.toolchain == toolchain)
 	{
-		return cxx_option(toolchain, flag.opt, flag.arg);
+		return cxx_option(toolchain, flag.opt, flag.arg, flag.arg2);
 	}
 
 	return {};
@@ -689,7 +760,7 @@ std::vector<std::string> to_strings(ctor::toolchain toolchain,
 	if(flag.toolchain == ctor::toolchain::any ||
 	   flag.toolchain == toolchain)
 	{
-		return ld_option(toolchain, flag.opt, flag.arg);
+		return ld_option(toolchain, flag.opt, flag.arg, flag.arg2);
 	}
 
 	return {};
@@ -701,7 +772,7 @@ std::vector<std::string> to_strings(ctor::toolchain toolchain,
 	if(flag.toolchain == ctor::toolchain::any ||
 	   flag.toolchain == toolchain)
 	{
-		return ar_option(toolchain, flag.opt, flag.arg);
+		return ar_option(toolchain, flag.opt, flag.arg, flag.arg2);
 	}
 
 	return {};
@@ -713,7 +784,7 @@ std::vector<std::string> to_strings(ctor::toolchain toolchain,
 	if(flag.toolchain == ctor::toolchain::any ||
 	   flag.toolchain == toolchain)
 	{
-		return asm_option(toolchain, flag.opt, flag.arg);
+		return asm_option(toolchain, flag.opt, flag.arg, flag.arg2);
 	}
 
 	return {};
diff --git a/src/tools.h b/src/tools.h
index 188d49f..0e7fc15 100644
--- a/src/tools.h
+++ b/src/tools.h
@@ -32,31 +32,36 @@ ctor::toolchain getToolChain(ctor::output_system system);
 //! tool-chain
 std::vector<std::string> c_option(ctor::toolchain toolchain,
                                   ctor::c_opt option,
-                                  const std::string& arg = {});
+                                  const std::string& arg = {},
+                                  const std::string& arg2 = {});
 
 //! Get tool argument(s) for specific option type matching the supplied
 //! tool-chain
 std::vector<std::string> cxx_option(ctor::toolchain toolchain,
                                     ctor::cxx_opt option,
-                                    const std::string& arg = {});
+                                    const std::string& arg = {},
+                                    const std::string& arg2 = {});
 
 //! Get tool argument(s) for specific option type matching the supplied
 //! tool-chain
 std::vector<std::string> ld_option(ctor::toolchain toolchain,
                                    ctor::ld_opt option,
-                                   const std::string& arg = {});
+                                   const std::string& arg = {},
+                                   const std::string& arg2 = {});
 
 //! Get tool argument(s) for specific option type matching the supplied
 //! tool-chain
 std::vector<std::string> ar_option(ctor::toolchain toolchain,
                                    ctor::ar_opt option,
-                                   const std::string& arg = {});
+                                   const std::string& arg = {},
+                                   const std::string& arg2 = {});
 
 //! Get tool argument(s) for specific option type matching the supplied
 //! tool-chain
 std::vector<std::string> asm_option(ctor::toolchain toolchain,
                                     ctor::asm_opt option,
-                                    const std::string& arg = {});
+                                    const std::string& arg = {},
+                                    const std::string& arg2 = {});