Use std::string_view instead of std::string in tools.cc whenever applicable

5 files changed, 84 insertions, 84 deletions

diff --git a/src/ctor.h b/src/ctor.h
index 27b30af..2ecef0e 100644
--- a/src/ctor.h
+++ b/src/ctor.h
@@ -164,7 +164,7 @@ class flag
 {
 public:
 	flag(std::string_view str);
-	flag(const char* str);
+	flag(const char* str) : flag(std::string_view(str)) {}
 	flag(T opt_) : opt(opt_) {}
 	flag(T opt_, std::string_view arg_, std::string_view arg2_ = "")
 		: opt(opt_), arg(arg_), arg2(arg2_) {}
diff --git a/src/tools.cc b/src/tools.cc
index dfabdff..77c0cc0 100644
--- a/src/tools.cc
+++ b/src/tools.cc
@@ -112,7 +112,7 @@ std::ostream& operator<<(std::ostream& stream, const ctor::asm_opt& opt)
 	return stream;
 }
 
-ctor::toolchain getToolChain(const std::string& compiler)
+ctor::toolchain getToolChain(std::string_view compiler)
 {
 	std::filesystem::path cc(compiler);
 	auto cc_cmd = cc.stem().string();
@@ -209,7 +209,7 @@ std::string get_arch(ctor::output_system system)
 	return arch;
 }
 
-ctor::arch get_arch(const std::string& str)
+ctor::arch get_arch(std::string_view str)
 {
 	// gcc -v 2>&1 | grep Target
 	// Target: x86_64-apple-darwin19.6.0
@@ -244,24 +244,24 @@ ctor::arch get_arch(const std::string& str)
 	return ctor::arch::unknown;
 }
 
-ctor::c_flag c_option(const std::string& flag)
+ctor::c_flag c_option(std::string_view flag)
 {
 	if(flag.starts_with("-I"))
 	{
-		std::string path = flag.substr(2);
+		std::string path(flag.substr(2));
 		path.erase(0, path.find_first_not_of(' '));
 		return { ctor::c_opt::include_path, path };
 	}
 
 	if(flag.starts_with("-std="))
 	{
-		std::string std = flag.substr(5);
+		auto std = flag.substr(5);
 		return { ctor::c_opt::c_std, std };
 	}
 
 	if(flag.starts_with("-O"))
 	{
-		std::string opt = flag.substr(2, 1);
+		auto opt = flag.substr(2, 1);
 		return { ctor::c_opt::optimization, opt };
 	}
 
@@ -297,7 +297,7 @@ ctor::c_flag c_option(const std::string& flag)
 
 	if(flag.starts_with("-D"))
 	{
-		std::string def = flag.substr(2);
+		auto def = flag.substr(2);
 		auto pos = def.find('=');
 		if(pos != def.npos)
 		{
@@ -311,24 +311,24 @@ ctor::c_flag c_option(const std::string& flag)
 	return { ctor::c_opt::custom, flag };
 }
 
-ctor::cxx_flag cxx_option(const std::string& flag)
+ctor::cxx_flag cxx_option(std::string_view flag)
 {
 	if(flag.starts_with("-I"))
 	{
-		std::string path = flag.substr(2);
+		std::string path(flag.substr(2));
 		path.erase(0, path.find_first_not_of(' '));
 		return { ctor::cxx_opt::include_path, path };
 	}
 
 	if(flag.starts_with("-std="))
 	{
-		std::string std = flag.substr(5);
+		auto std = flag.substr(5);
 		return { ctor::cxx_opt::cpp_std, std };
 	}
 
 	if(flag.starts_with("-O"))
 	{
-		std::string opt = flag.substr(2, 1);
+		auto opt = flag.substr(2, 1);
 		return { ctor::cxx_opt::optimization, opt };
 	}
 
@@ -364,7 +364,7 @@ ctor::cxx_flag cxx_option(const std::string& flag)
 
 	if(flag.starts_with("-D"))
 	{
-		std::string def = flag.substr(2);
+		auto def = flag.substr(2);
 		auto pos = def.find('=');
 		if(pos != def.npos)
 		{
@@ -379,11 +379,11 @@ ctor::cxx_flag cxx_option(const std::string& flag)
 	return { ctor::cxx_opt::custom, flag };
 }
 
-ctor::ld_flag ld_option(const std::string& flag)
+ctor::ld_flag ld_option(std::string_view flag)
 {
 	if(flag.starts_with("-L"))
 	{
-		std::string path = flag.substr(2);
+		std::string path(flag.substr(2));
 		path.erase(0, path.find_first_not_of(' '));
 		return { ctor::ld_opt::library_path, path };
 	}
@@ -396,18 +396,18 @@ ctor::ld_flag ld_option(const std::string& flag)
 	return { ctor::ld_opt::custom, flag };
 }
 
-ctor::ar_flag ar_option(const std::string& flag)
+ctor::ar_flag ar_option(std::string_view flag)
 {
 	return { ctor::ar_opt::custom, flag };
 }
 
-std::vector<std::string> cxx_option(ctor::cxx_opt opt, const std::string& arg,
-                                    const std::string& arg2)
+std::vector<std::string> cxx_option(ctor::cxx_opt opt, std::string_view arg,
+                                    std::string_view arg2)
 {
 	switch(opt)
 	{
 	case ctor::cxx_opt::output:
-		return {"-o", arg};
+		return {"-o", std::string(arg)};
 	case ctor::cxx_opt::debug:
 		return {"-g"};
 	case ctor::cxx_opt::warn_all:
@@ -425,11 +425,11 @@ std::vector<std::string> cxx_option(ctor::cxx_opt opt, const std::string& arg,
 	case ctor::cxx_opt::no_link:
 		return {"-c"};
 	case ctor::cxx_opt::include_path:
-		return {"-I" + arg};
+		return {"-I" + std::string(arg)};
 	case ctor::cxx_opt::cpp_std:
-		return {"-std=" + arg};
+		return {"-std=" + std::string(arg)};
 	case ctor::cxx_opt::optimization:
-		return {"-O" + arg};
+		return {"-O" + std::string(arg)};
 	case ctor::cxx_opt::position_independent_code:
 		return {"-fPIC"};
 	case ctor::cxx_opt::position_independent_executable:
@@ -437,9 +437,9 @@ std::vector<std::string> cxx_option(ctor::cxx_opt opt, const std::string& arg,
 	case ctor::cxx_opt::define:
 		if(!arg2.empty())
 		{
-			return {"-D" + arg + "=" + arg2};
+			return {"-D" + std::string(arg) + "=" + std::string(arg2)};
 		}
-		return {"-D" + arg};
+		return {"-D" + std::string(arg)};
 	case ctor::cxx_opt::custom:
 		return argsplit(arg);
 	}
@@ -448,13 +448,13 @@ 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,
-                                  const std::string& arg2)
+std::vector<std::string> c_option(ctor::c_opt opt, std::string_view arg,
+                                  std::string_view arg2)
 {
 	switch(opt)
 	{
 	case ctor::c_opt::output:
-		return {"-o", arg};
+		return {"-o", std::string(arg)};
 	case ctor::c_opt::debug:
 		return {"-g"};
 	case ctor::c_opt::warn_all:
@@ -472,11 +472,11 @@ std::vector<std::string> c_option(ctor::c_opt opt, const std::string& arg,
 	case ctor::c_opt::no_link:
 		return {"-c"};
 	case ctor::c_opt::include_path:
-		return {"-I" + arg};
+		return {"-I" + std::string(arg)};
 	case ctor::c_opt::c_std:
-		return {"-std=" + arg};
+		return {"-std=" + std::string(arg)};
 	case ctor::c_opt::optimization:
-		return {"-O" + arg};
+		return {"-O" + std::string(arg)};
 	case ctor::c_opt::position_independent_code:
 		return {"-fPIC"};
 	case ctor::c_opt::position_independent_executable:
@@ -484,9 +484,9 @@ std::vector<std::string> c_option(ctor::c_opt opt, const std::string& arg,
 	case ctor::c_opt::define:
 		if(!arg2.empty())
 		{
-			return {"-D" + arg + "=" + arg2};
+			return {"-D" + std::string(arg) + "=" + std::string(arg2)};
 		}
-		return {"-D" + arg};
+		return {"-D" + std::string(arg)};
 	case ctor::c_opt::custom:
 		return argsplit(arg);
 	}
@@ -495,23 +495,23 @@ 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,
-                                   [[maybe_unused]]const std::string& arg2)
+std::vector<std::string> ld_option(ctor::ld_opt opt, std::string_view arg,
+                                   [[maybe_unused]]std::string_view arg2)
 {
 	switch(opt)
 	{
 	case ctor::ld_opt::output:
-		return {"-o", arg};
+		return {"-o", std::string(arg)};
 	case ctor::ld_opt::warn_all:
 		return {"-Wall"};
 	case ctor::ld_opt::warnings_as_errors:
 		return {"-Werror"};
 	case ctor::ld_opt::library_path:
-		return {"-L" + arg};
+		return {"-L" + std::string(arg)};
 	case ctor::ld_opt::link:
-		return {"-l" + arg};
+		return {"-l" + std::string(arg)};
 	case ctor::ld_opt::cpp_std:
-		return {"-std=" + arg};
+		return {"-std=" + std::string(arg)};
 	case ctor::ld_opt::build_shared:
 		return {"-shared"};
 	case ctor::ld_opt::threads:
@@ -528,8 +528,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,
-                                   [[maybe_unused]]const std::string& arg2)
+std::vector<std::string> ar_option(ctor::ar_opt opt, std::string_view arg,
+                                   [[maybe_unused]]std::string_view arg2)
 {
 	switch(opt)
 	{
@@ -540,7 +540,7 @@ std::vector<std::string> ar_option(ctor::ar_opt opt, const std::string& arg,
 	case ctor::ar_opt::create:
 		return {"-c"};
 	case ctor::ar_opt::output:
-		return {arg};
+		return {std::string(arg)};
 	case ctor::ar_opt::custom:
 		return argsplit(arg);
 	}
@@ -549,8 +549,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,
-                                    [[maybe_unused]]const std::string& arg2)
+std::vector<std::string> asm_option(ctor::asm_opt opt, std::string_view arg,
+                                    [[maybe_unused]]std::string_view arg2)
 {
 	switch(opt)
 	{
@@ -578,7 +578,7 @@ std::string get_arch(ctor::output_system system)
 	return {};
 }
 
-ctor::arch get_arch(ctor::output_system system, const std::string& str)
+ctor::arch get_arch(ctor::output_system system, std::string_view str)
 {
 	auto toolchain = getToolChain(system);
 	switch(toolchain)
@@ -595,8 +595,8 @@ 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& arg2)
+                                  std::string_view arg,
+                                  std::string_view arg2)
 {
 	switch(toolchain)
 	{
@@ -628,8 +628,8 @@ 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& arg2)
+                                    std::string_view arg,
+                                    std::string_view arg2)
 {
 	switch(toolchain)
 	{
@@ -661,8 +661,8 @@ 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& arg2)
+                                   std::string_view arg,
+                                   std::string_view arg2)
 {
 	switch(toolchain)
 	{
@@ -694,8 +694,8 @@ 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& arg2)
+                                   std::string_view arg,
+                                   std::string_view arg2)
 {
 	switch(toolchain)
 	{
@@ -727,8 +727,8 @@ 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& arg2)
+                                    std::string_view arg,
+                                    std::string_view arg2)
 {
 	switch(toolchain)
 	{
@@ -759,7 +759,7 @@ std::vector<std::string> asm_option(ctor::toolchain toolchain,
 }
 
 
-ctor::c_flag c_option(const std::string& flag, ctor::toolchain toolchain)
+ctor::c_flag c_option(std::string_view flag, ctor::toolchain toolchain)
 {
 	switch(toolchain)
 	{
@@ -774,7 +774,7 @@ ctor::c_flag c_option(const std::string& flag, ctor::toolchain toolchain)
 	return { ctor::c_opt::custom, flag };
 }
 
-ctor::cxx_flag cxx_option(const std::string& flag, ctor::toolchain toolchain)
+ctor::cxx_flag cxx_option(std::string_view flag, ctor::toolchain toolchain)
 {
 	switch(toolchain)
 	{
@@ -789,7 +789,7 @@ ctor::cxx_flag cxx_option(const std::string& flag, ctor::toolchain toolchain)
 	return { ctor::cxx_opt::custom, flag };
 }
 
-ctor::ld_flag ld_option(const std::string& flag, ctor::toolchain toolchain)
+ctor::ld_flag ld_option(std::string_view flag, ctor::toolchain toolchain)
 {
 	switch(toolchain)
 	{
@@ -804,7 +804,7 @@ ctor::ld_flag ld_option(const std::string& flag, ctor::toolchain toolchain)
 	return { ctor::ld_opt::custom, flag };
 }
 
-ctor::ar_flag ar_option(const std::string& flag, ctor::toolchain toolchain)
+ctor::ar_flag ar_option(std::string_view flag, ctor::toolchain toolchain)
 {
 	switch(toolchain)
 	{
@@ -819,7 +819,7 @@ ctor::ar_flag ar_option(const std::string& flag, ctor::toolchain toolchain)
 	return { ctor::ar_opt::custom, flag };
 }
 
-ctor::asm_flag asm_option(const std::string& flag, ctor::toolchain toolchain)
+ctor::asm_flag asm_option(std::string_view flag, ctor::toolchain toolchain)
 {
 	switch(toolchain)
 	{
@@ -896,7 +896,7 @@ std::vector<std::string> to_strings(ctor::toolchain toolchain,
 }
 
 namespace {
-ctor::toolchain guess_toolchain(const std::string& opt)
+ctor::toolchain guess_toolchain(std::string_view opt)
 {
 	if(opt.empty())
 	{
@@ -917,31 +917,31 @@ ctor::toolchain guess_toolchain(const std::string& opt)
 }
 
 template<>
-ctor::flag<ctor::c_opt>::flag(const char* str)
+ctor::flag<ctor::c_opt>::flag(std::string_view str)
 {
 	*this = c_option(str, guess_toolchain(str));
 }
 
 template<>
-ctor::flag<ctor::cxx_opt>::flag(const char* str)
+ctor::flag<ctor::cxx_opt>::flag(std::string_view str)
 {
 	*this = cxx_option(str, guess_toolchain(str));
 }
 
 template<>
-ctor::flag<ctor::ld_opt>::flag(const char* str)
+ctor::flag<ctor::ld_opt>::flag(std::string_view str)
 {
 	*this = ld_option(str, guess_toolchain(str));
 }
 
 template<>
-ctor::flag<ctor::ar_opt>::flag(const char* str)
+ctor::flag<ctor::ar_opt>::flag(std::string_view str)
 {
 	*this = ar_option(str, guess_toolchain(str));
 }
 
 template<>
-ctor::flag<ctor::asm_opt>::flag(const char* str)
+ctor::flag<ctor::asm_opt>::flag(std::string_view str)
 {
 	*this = asm_option(str, guess_toolchain(str));
 }
diff --git a/src/tools.h b/src/tools.h
index 0e7fc15..b8df022 100644
--- a/src/tools.h
+++ b/src/tools.h
@@ -18,10 +18,10 @@ std::ostream& operator<<(std::ostream& stream, const ctor::ar_opt& opt);
 std::ostream& operator<<(std::ostream& stream, const ctor::asm_opt& opt);
 
 std::string get_arch(ctor::output_system system);
-ctor::arch get_arch(ctor::output_system system, const std::string& str);
+ctor::arch get_arch(ctor::output_system system, std::string_view str);
 
 //! Get tool-chain type from compiler path string
-ctor::toolchain getToolChain(const std::string& compiler);
+ctor::toolchain getToolChain(std::string_view compiler);
 
 //! Get tool-chain type from output system (via configuration)
 ctor::toolchain getToolChain(ctor::output_system system);
@@ -32,63 +32,63 @@ 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& arg2 = {});
+                                  std::string_view arg = {},
+                                  std::string_view 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& arg2 = {});
+                                    std::string_view arg = {},
+                                    std::string_view 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& arg2 = {});
+                                   std::string_view arg = {},
+                                   std::string_view 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& arg2 = {});
+                                   std::string_view arg = {},
+                                   std::string_view 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& arg2 = {});
+                                    std::string_view arg = {},
+                                    std::string_view arg2 = {});
 
 
 
 //! Get ctor::c_opt enum value and argument from string,
 //! ie. { ctor::c_opt::inlude_path, "foo/bar" } from "-Ifoo/bar"
 //! Returns { ctor::c_opt::custom, flag } if unknown.
-ctor::c_flag c_option(const std::string& flag, ctor::toolchain toolchain);
+ctor::c_flag c_option(std::string_view flag, ctor::toolchain toolchain);
 
 //! Get ctor::cxx_opt enum value and argument from string,
 //! ie. { ctor::cxx_opt::inlude_path, "foo/bar" } from "-Ifoo/bar"
 //! Returns { ctor::cxx_opt::custom, flag } if unknown.
-ctor::cxx_flag cxx_option(const std::string& flag, ctor::toolchain toolchain);
+ctor::cxx_flag cxx_option(std::string_view flag, ctor::toolchain toolchain);
 
 //! Get ctor::ld_opt enum value and argument from string,
 //! ie. { ctor::ld_opt::inlude_path, "foo/bar" } from "-Ifoo/bar"
 //! Returns { ctor::ld_opt::custom, flag } if unknown.
-ctor::ld_flag ld_option(const std::string& flag, ctor::toolchain toolchain);
+ctor::ld_flag ld_option(std::string_view flag, ctor::toolchain toolchain);
 
 //! Get ctor::ar_opt enum value and argument from string,
 //! ie. { ctor::ar_opt::inlude_path, "foo/bar" } from "-Ifoo/bar"
 //! Returns { ctor::ar_opt::custom, flag } if unknown.
-ctor::ar_flag ar_option(const std::string& flag, ctor::toolchain toolchain);
+ctor::ar_flag ar_option(std::string_view flag, ctor::toolchain toolchain);
 
 //! Get ctor::asm_opt enum value and argument from string,
 //! ie. { ctor::asm_opt::inlude_path, "foo/bar" } from "-Ifoo/bar"
 //! Returns { ctor::asm_opt::custom, flag } if unknown.
-ctor::asm_flag asm_option(const std::string& flag, ctor::toolchain toolchain);
+ctor::asm_flag asm_option(std::string_view flag, ctor::toolchain toolchain);
 
 
 
diff --git a/src/util.cc b/src/util.cc
index a4abd23..010cde3 100644
--- a/src/util.cc
+++ b/src/util.cc
@@ -205,7 +205,7 @@ std::string locate(const std::string& prog,
 	return {};
 }
 
-std::vector<std::string> argsplit(const std::string& str)
+std::vector<std::string> argsplit(std::string_view str)
 {
 	enum class state
 	{
diff --git a/src/util.h b/src/util.h
index 38d89f2..337c1e4 100644
--- a/src/util.h
+++ b/src/util.h
@@ -34,7 +34,7 @@ std::string locate(const std::string& app,
                    const std::string& arch = {});
 
 //! Splits string into tokens adhering to quotations " and '
-std::vector<std::string> argsplit(const std::string& str);
+std::vector<std::string> argsplit(std::string_view str);
 
 //! Calls the system getenv and sets the string if the env name it exists.
 //! \returns true if the env name existed, false otherwise.