Formatting system improved

`unveil<>` renamed to `fmt_unveil<>`, now packs args to u64 imitating va_args
`bijective...` removed, `cfg::enum_entry` now uses formatting system
`fmt_class_string<>` added, providing type-specific "%s" handler function
Added `fmt::append`, removed `fmt::narrow` (too obscure)
Utilities/cfmt.h: C-style format template function (WIP)
Minor formatting fixes and cleanup

Author: Nekotekina

Utilities/BEType.h

@@ -298,10 +298,6 @@ union alignas(16) v128
 		_u64[0] = 0;
 		_u64[1] = 0;
 	}
-
-	std::string to_hex() const;
-
-	std::string to_xyzw() const;
 };
 
 inline v128 operator |(const v128& left, const v128& right)
@@ -950,11 +946,13 @@ template<typename T> using atomic_le_t = atomic_t<le_t<T>>;
 
 // Formatting for BE/LE data
 template<typename T, bool Se, std::size_t Align>
-struct unveil<se_t<T, Se, Align>, void>
+struct fmt_unveil<se_t<T, Se, Align>, void>
 {
-	static inline auto get(const se_t<T, Se, Align>& arg)
+	using type = typename fmt_unveil<T>::type;
+
+	static inline u64 get(const se_t<T, Se, Align>& arg)
 	{
-		return unveil<T>::get(arg);
+		return fmt_unveil<T>::get(arg);
 	}
 };
 

Utilities/BitField.h

@@ -242,3 +242,36 @@ struct ff_t : bf_base<T, N>
 		return V;
 	}
 };
+
+template<typename T, uint I, uint N>
+struct fmt_unveil<bf_t<T, I, N>, void>
+{
+	using type = typename fmt_unveil<simple_t<T>>::type;
+
+	static inline u64 get(const bf_t<T, I, N>& bf)
+	{
+		return fmt_unveil<type>::get(bf);
+	}
+};
+
+template<typename F, typename... Fields>
+struct fmt_unveil<cf_t<F, Fields...>, void>
+{
+	using type = typename fmt_unveil<simple_t<typename F::type>>::type;
+
+	static inline u64 get(const cf_t<F, Fields...>& cf)
+	{
+		return fmt_unveil<type>::get(cf);
+	}
+};
+
+template<typename T, T V, uint N>
+struct fmt_unveil<ff_t<T, V, N>, void>
+{
+	using type = typename fmt_unveil<simple_t<T>>::type;
+
+	static inline u64 get(const ff_t<T, V, N>& ff)
+	{
+		return fmt_unveil<type>::get(ff);
+	}
+};

Utilities/BitSet.h

@@ -256,3 +256,14 @@ struct atomic_test_and_complement<bitset_t<T>, T, std::enable_if_t<std::is_enum<
 
 	static constexpr auto atomic_op = &_op;
 };
+
+template<typename T, std::size_t BitSize>
+struct fmt_unveil<bitset_t<T, BitSize>, void>
+{
+	using type = typename bitset_t<T, BitSize>::raw_type;
+
+	static inline u64 get(const bitset_t<T, BitSize>& value)
+	{
+		return fmt_unveil<type>::get(static_cast<type>(value._value()));
+	}
+};

Utilities/Config.cpp

@@ -85,6 +85,62 @@ bool cfg::try_to_int64(s64* out, const std::string& value, s64 min, s64 max)
 	return true;
 }
 
+bool cfg::try_to_enum_value(u64* out, decltype(&fmt_class_string<int>::format) func, const std::string& value)
+{
+	for (u64 i = 0;; i++)
+	{
+		std::string var;
+		func(var, i);
+
+		if (var == value)
+		{
+			if (out) *out = i;
+			return true;
+		}
+
+		std::string hex;
+		fmt_class_string<u64>::format(hex, i);
+		if (var == hex)
+		{
+			break;
+		}
+	}
+
+	try
+	{
+		const auto val = std::stoull(value, nullptr, 0);
+
+		if (out) *out = val;
+		return true;
+	}
+	catch (...)
+	{
+		return false;
+	}
+}
+
+std::vector<std::string> cfg::try_to_enum_list(decltype(&fmt_class_string<int>::format) func)
+{
+	std::vector<std::string> result;
+
+	for (u64 i = 0;; i++)
+	{
+		std::string var;
+		func(var, i);
+
+		std::string hex;
+		fmt_class_string<u64>::format(hex, i);
+		if (var == hex)
+		{
+			break;
+		}
+
+		result.emplace_back(std::move(var));
+	}
+
+	return result;
+}
+
 void cfg::encode(YAML::Emitter& out, const cfg::entry_base& rhs)
 {
 	switch (rhs.get_type())

Utilities/Config.h

@@ -2,6 +2,7 @@
 
 #include "Utilities/types.h"
 #include "Utilities/Atomic.h"
+#include "Utilities/StrFmt.h"
 
 #include <initializer_list>
 #include <exception>
@@ -18,6 +19,12 @@ namespace cfg
 	// Convert string to signed integer
 	bool try_to_int64(s64* out, const std::string& value, s64 min, s64 max);
 
+	// Internal hack
+	bool try_to_enum_value(u64* out, decltype(&fmt_class_string<int>::format) func, const std::string&);
+
+	// Internal hack
+	std::vector<std::string> try_to_enum_list(decltype(&fmt_class_string<int>::format) func);
+
 	// Config tree entry type.
 	enum class type : uint
 	{
@@ -296,41 +303,34 @@ namespace cfg
 
 		std::string to_string() const override
 		{
-			for (std::size_t i = 0; i < sizeof(bijective<T, const char*>::map) / sizeof(bijective_pair<T, const char*>); i++)
-			{
-				if (bijective<T, const char*>::map[i].v1 == m_value)
-				{
-					return bijective<T, const char*>::map[i].v2;
-				}
-			}
-
-			return{}; // TODO: ???
+			std::string result;
+			fmt_class_string<T>::format(result, fmt_unveil<T>::get(m_value));
+			return result; // TODO: ???
 		}
 
 		bool from_string(const std::string& value) override
 		{
-			for (std::size_t i = 0; i < sizeof(bijective<T, const char*>::map) / sizeof(bijective_pair<T, const char*>); i++)
+			u64 result;
+
+			if (try_to_enum_value(&result, &fmt_class_string<T>::format, value))
 			{
-				if (bijective<T, const char*>::map[i].v2 == value)
+				const auto val = static_cast<std::underlying_type_t<T>>(result);
+
+				if (static_cast<u64>(val) != result)
 				{
-					m_value = bijective<T, const char*>::map[i].v1;
-					return true;
+					return false;
 				}
+
+				m_value = static_cast<T>(val);
+				return true;
 			}
 
 			return false;
 		}
 
 		std::vector<std::string> to_list() const override
 		{
-			std::vector<std::string> result;
-
-			for (std::size_t i = 0; i < sizeof(bijective<T, const char*>::map) / sizeof(bijective_pair<T, const char*>); i++)
-			{
-				result.emplace_back(bijective<T, const char*>::map[i].v2);
-			}
-
-			return result;
+			return try_to_enum_list(&fmt_class_string<T>::format);
 		}
 	};
 

Utilities/File.cpp

@@ -1333,3 +1333,37 @@ u64 fs::get_dir_size(const std::string& path)
 
 	return result;
 }
+
+template<>
+void fmt_class_string<fs::seek_mode>::format(std::string& out, u64 arg)
+{
+	format_enum(out, arg, [](auto arg)
+	{
+		switch (arg)
+		{
+		STR_CASE(fs::seek_mode::seek_set);
+		STR_CASE(fs::seek_mode::seek_cur);
+		STR_CASE(fs::seek_mode::seek_end);
+		}
+
+		return unknown;
+	});
+}
+
+template<>
+void fmt_class_string<fs::error>::format(std::string& out, u64 arg)
+{
+	format_enum(out, arg, [](auto arg)
+	{
+		switch (arg)
+		{
+		case fs::error::ok: return "OK";
+
+		case fs::error::inval: return "Invalid arguments";
+		case fs::error::noent: return "Not found";
+		case fs::error::exist: return "Already exists";
+		}
+
+		return unknown;
+	});
+}

Utilities/File.h

@@ -463,21 +463,3 @@ namespace fs
 	// Error code returned
 	extern thread_local error g_tls_error;
 }
-
-template<>
-struct unveil<fs::error>
-{
-	static inline const char* get(fs::error error)
-	{
-		switch (error)
-		{
-		case fs::error::ok: return "OK";
-
-		case fs::error::inval: return "Invalid arguments";
-		case fs::error::noent: return "Not found";
-		case fs::error::exist: return "Already exists";
-
-		default: throw error;
-		}
-	}
-};

Utilities/Log.cpp

@@ -3,15 +3,31 @@
 #include "StrFmt.h"
 
 #include "rpcs3_version.h"
-#include <cstdarg>
 #include <string>
 
 // Thread-specific log prefix provider
 thread_local std::string(*g_tls_log_prefix)() = nullptr;
 
-#ifndef _MSC_VER
-constexpr DECLARE(bijective<logs::level, const char*>::map);
-#endif
+template<>
+void fmt_class_string<logs::level>::format(std::string& out, u64 arg)
+{
+	format_enum(out, arg, [](auto lev)
+	{
+		switch (lev)
+		{
+		case logs::level::always: return "Nothing";
+		case logs::level::fatal: return "Fatal";
+		case logs::level::error: return "Error";
+		case logs::level::todo: return "TODO";
+		case logs::level::success: return "Success";
+		case logs::level::warning: return "Warning";
+		case logs::level::notice: return "Notice";
+		case logs::level::trace: return "Trace";
+		}
+
+		return unknown;
+	});
+}
 
 namespace logs
 {
@@ -72,13 +88,10 @@ void logs::listener::add(logs::listener* _new)
 	}
 }
 
-void logs::channel::broadcast(const logs::channel& ch, logs::level sev, const char* fmt...)
+void logs::channel::broadcast(const logs::channel& ch, logs::level sev, const char* fmt, const fmt::supplementary_info* sup, const u64* args)
 {
-	va_list args;
-	va_start(args, fmt);
-	std::string&& text = fmt::unsafe_vformat(fmt, args);
-	std::string&& prefix = g_tls_log_prefix ? g_tls_log_prefix() : "";
-	va_end(args);
+	std::string text; fmt::raw_append(text, fmt, sup, args);
+	std::string prefix(g_tls_log_prefix ? g_tls_log_prefix() : "");
 
 	// Prepare message information
 	message msg;