More std::format

Author: grendello

src/native/monodroid/embedded-assemblies-zip.cc

@@ -45,7 +45,7 @@ EmbeddedAssemblies::zip_load_entry_common (size_t entry_index, std::vector<uint8
 		);
 	}
 
-	log_debug (LOG_ASSEMBLY, std::format ("    ZIP: local header offset: {}; data offset: {}; file size: {}", state.local_header_offset, state.data_offset, state.file_size).c_str ());
+	log_debug (LOG_ASSEMBLY, std::format ("    ZIP: local header offset: {}; data offset: {}; file size: {}", state.local_header_offset, state.data_offset, state.file_size));
 	if (state.compression_method != 0) {
 		return false;
 	}

src/native/monodroid/internal-pinvokes.cc

@@ -1,3 +1,5 @@
+#include <string_view>
+
 #include "android-system.hh"
 #include "globals.hh"
 #include "internal-pinvokes.hh"
@@ -31,30 +33,30 @@ monodroid_log (LogLevel level, LogCategories category, const char *message)
 	switch (level) {
 		case LogLevel::Verbose:
 		case LogLevel::Debug:
-			log_debug_nocheck (category, message);
+			log_debug_nocheck (category, std::string_view { message });
 			break;
 
 		case LogLevel::Info:
-			log_info_nocheck (category, message);
+			log_info_nocheck (category, std::string_view { message });
 			break;
 
 		case LogLevel::Warn:
 		case LogLevel::Silent: // warn is always printed
-			log_warn (category, message);
+			log_warn (category, std::string_view { message });
 			break;
 
 		case LogLevel::Error:
-			log_error (category, message);
+			log_error (category, std::string_view { message });
 			break;
 
 		case LogLevel::Fatal:
-			log_fatal (category, message);
+			log_fatal (category, std::string_view { message });
 			break;
 
 		default:
 		case LogLevel::Unknown:
 		case LogLevel::Default:
-			log_info_nocheck (category, message);
+			log_info_nocheck (category, std::string_view { message });
 			break;
 	}
 }
@@ -156,7 +158,7 @@ _monodroid_timezone_get_default_id ()
 	const char *mutf8    = env->GetStringUTFChars (id, nullptr);
 
 	if (mutf8 == nullptr) {
-		log_error (LOG_DEFAULT, "Failed to convert Java TimeZone ID to UTF8 (out of memory?)");
+		log_error (LOG_DEFAULT, "Failed to convert Java TimeZone ID to UTF8 (out of memory?)"sv);
 		env->DeleteLocalRef (id);
 		env->DeleteLocalRef (d);
 		return nullptr;

src/native/monodroid/mono-image-loader.hh

@@ -110,7 +110,7 @@ namespace xamarin::android::internal {
 		force_inline static MonoImage* stash_and_return (MonoImage *image, MonoImageOpenStatus status, [[maybe_unused]] hash_t hash) noexcept
 		{
 			if (image == nullptr || status != MonoImageOpenStatus::MONO_IMAGE_OK) {
-				log_warn (LOG_ASSEMBLY, "Failed to open assembly image. %s", mono_image_strerror (status));
+				log_warn (LOG_ASSEMBLY, std::format ("Failed to open assembly image. {}", mono_image_strerror (status)));
 				return nullptr;
 			}
 
@@ -119,8 +119,8 @@ namespace xamarin::android::internal {
 			if (index < 0) {
 				Helpers::abort_application (
 					LOG_ASSEMBLY,
-					Util::monodroid_strdup_printf (
-						"Failed to look up image index for hash 0x%zx",
+					std::format (
+						"Failed to look up image index for hash {:x}",
 						hash
 					)
 				);

src/native/monodroid/monodroid-glue-internal.hh

@@ -166,7 +166,7 @@ namespace xamarin::android::internal
 			void *symptr = MonodroidDl::monodroid_dlsym (handle, name, &err, nullptr);
 
 			if (symptr == nullptr) {
-				log_warn (LOG_DEFAULT, "Failed to load symbol '%s' library with handle %p. %s", name, handle, err == nullptr ? "Unknown error" : err);
+				log_warn (LOG_DEFAULT, std::format ("Failed to load symbol '{}' library with handle {}. {}", name, handle, err == nullptr ? "Unknown error"sv : err));
 				fnptr = nullptr;
 				return;
 			}

src/native/monodroid/monodroid-networkinfo.cc

@@ -76,10 +76,10 @@ _monodroid_get_network_interface_state (const char *ifname, mono_bool *is_up, mo
 
 	if (!NetworkInterface_class || !NetworkInterface_getByName) {
 		if (!NetworkInterface_class)
-			log_warn (LOG_NET, "Failed to find the 'java.net.NetworkInterface' Java class");
+			log_warn (LOG_NET, "Failed to find the 'java.net.NetworkInterface' Java class"sv);
 		if (!NetworkInterface_getByName)
-			log_warn (LOG_NET, "Failed to find the 'java.net.NetworkInterface.getByName' function");
-		log_warn (LOG_NET, "Unable to determine network interface state because of missing Java API");
+			log_warn (LOG_NET, "Failed to find the 'java.net.NetworkInterface.getByName' function"sv);
+		log_warn (LOG_NET, "Unable to determine network interface state because of missing Java API"sv);
 		goto leave;
 	}
 
@@ -88,37 +88,37 @@ _monodroid_get_network_interface_state (const char *ifname, mono_bool *is_up, mo
 	networkInterface = env->CallStaticObjectMethod (NetworkInterface_class, NetworkInterface_getByName, NetworkInterface_nameArg);
 	env->DeleteLocalRef (NetworkInterface_nameArg);
 	if (env->ExceptionOccurred ()) {
-		log_warn (LOG_NET, "Java exception occurred while looking up the interface '%s'", ifname);
+		log_warn (LOG_NET, std::format ("Java exception occurred while looking up the interface '{}'", ifname));
 		env->ExceptionDescribe ();
 		env->ExceptionClear ();
 		goto leave;
 	}
 
 	if (!networkInterface) {
-		log_warn (LOG_NET, "Failed to look up interface '%s' using Java API", ifname);
+		log_warn (LOG_NET, std::format ("Failed to look up interface '{}' using Java API", ifname));
 		ret = FALSE;
 		goto leave;
 	}
 
 	if (is_up) {
 		if (!NetworkInterface_isUp) {
-			log_warn (LOG_NET, "Failed to find the 'java.net.NetworkInterface.isUp' function. Unable to determine interface operational state");
+			log_warn (LOG_NET, "Failed to find the 'java.net.NetworkInterface.isUp' function. Unable to determine interface operational state"sv);
 			ret = FALSE;
 		} else
 			*is_up = (mono_bool)env->CallBooleanMethod (networkInterface, NetworkInterface_isUp);
 	}
 
 	if (supports_multicast) {
 		if (!NetworkInterface_supportsMulticast) {
-			log_warn (LOG_NET, "Failed to find the 'java.net.NetworkInterface.supportsMulticast' function. Unable to determine whether interface supports multicast");
+			log_warn (LOG_NET, "Failed to find the 'java.net.NetworkInterface.supportsMulticast' function. Unable to determine whether interface supports multicast"sv);
 			ret = FALSE;
 		} else
 			*supports_multicast = (mono_bool)env->CallBooleanMethod (networkInterface, NetworkInterface_supportsMulticast);
 	}
 
   leave:
 	if (!ret)
-		log_warn (LOG_NET, "Unable to determine interface '%s' state using Java API", ifname);
+		log_warn (LOG_NET, std::format ("Unable to determine interface '{}' state using Java API", ifname));
 
 	if (networkInterface != nullptr && env != nullptr) {
 		env->DeleteLocalRef (networkInterface);
@@ -143,7 +143,7 @@ int
 _monodroid_get_dns_servers (void **dns_servers_array)
 {
 	if (!dns_servers_array) {
-		log_warn (LOG_NET, "Unable to get DNS servers, no location to store data in");
+		log_warn (LOG_NET, "Unable to get DNS servers, no location to store data in"sv);
 		return -1;
 	}
 	*dns_servers_array = nullptr;

src/native/monodroid/monodroid-tracing.cc

@@ -27,7 +27,7 @@ MonodroidRuntime::log_traces (JNIEnv *env, TraceKind kind, const char *first_lin
 		char *err = nullptr;
 		void *handle = MonodroidDl::monodroid_dlopen (SharedConstants::xamarin_native_tracing_name.data (), MONO_DL_EAGER, &err, nullptr);
 		if (handle == nullptr) {
-			log_warn (LOG_DEFAULT, "Failed to load native tracing library '%s'. %s", SharedConstants::xamarin_native_tracing_name, err == nullptr ? "Unknown error" : err);
+			log_warn (LOG_DEFAULT, std::format ("Failed to load native tracing library '{}'. {}", SharedConstants::xamarin_native_tracing_name, err == nullptr ? "Unknown error"sv : err));
 		} else {
 			load_symbol (handle, "xa_get_native_backtrace", _xa_get_native_backtrace);
 			load_symbol (handle, "xa_get_managed_backtrace", _xa_get_managed_backtrace);

src/native/monodroid/xamarin-android-app-context.cc

@@ -15,7 +15,7 @@ MonodroidRuntime::get_method_name (uint32_t mono_image_index, uint32_t method_to
 {
 	uint64_t id = (static_cast<uint64_t>(mono_image_index) << 32) | method_token;
 
-	log_debug (LOG_ASSEMBLY, "MM: looking for name of method with id 0x%llx, in mono image at index %u", id, mono_image_index);
+	log_debug (LOG_ASSEMBLY, std::format ("MM: looking for name of method with id {:x}, in mono image at index {}", id, mono_image_index));
 	size_t i = 0uz;
 	while (mm_method_names[i].id != 0) {
 		if (mm_method_names[i].id == id) {
@@ -43,15 +43,16 @@ MonodroidRuntime::get_function_pointer (uint32_t mono_image_index, uint32_t clas
 {
 	log_debug (
 		LOG_ASSEMBLY,
-		"MM: Trying to look up pointer to method '%s' (token 0x%x) in class '%s' (index %u)",
-		get_method_name (mono_image_index, method_token), method_token,
-		get_class_name (class_index), class_index
+		std::format ("MM: Trying to look up pointer to method '{}' (token {:x}) in class '{}' (index {})",
+			get_method_name (mono_image_index, method_token), method_token,
+			get_class_name (class_index), class_index
+		)
 	);
 
 	if (class_index >= marshal_methods_number_of_classes) [[unlikely]] {
 		Helpers::abort_application (
-			Util::monodroid_strdup_printf (
-				"Internal error: invalid index for class cache (expected at most %u, got %u)",
+			std::format (
+				"Internal error: invalid index for class cache (expected at most {}, got {})",
 				marshal_methods_number_of_classes - 1,
 				class_index
 			)
@@ -78,29 +79,40 @@ MonodroidRuntime::get_function_pointer (uint32_t mono_image_index, uint32_t clas
 			target_ptr = ret;
 		}
 
-		log_debug (LOG_ASSEMBLY, "Loaded pointer to method %s (%p) (mono_image_index == %u; class_index == %u; method_token == 0x%x)", mono_method_full_name (method, true), ret, mono_image_index, class_index, method_token);
+		log_debug (
+			LOG_ASSEMBLY,
+			std::format ("Loaded pointer to method {} ({:p}) (mono_image_index == {}; class_index == {}; method_token == {:x})",
+				mono_method_full_name (method, true),
+				ret,
+				mono_image_index,
+				class_index,
+				method_token
+			)
+		);
 		return;
 	}
 
 	log_fatal (
 		LOG_DEFAULT,
-		"Failed to obtain function pointer to method '%s' in class '%s'",
-		get_method_name (mono_image_index, method_token),
-		get_class_name (class_index)
+		std::format ("Failed to obtain function pointer to method '{}' in class '{}'",
+				get_method_name (mono_image_index, method_token),
+				get_class_name (class_index)
+		)
 	);
 
 	log_fatal (
 		LOG_DEFAULT,
-		"Looked for image index %u, class index %u, method token 0x%x",
-		mono_image_index,
-		class_index,
-		method_token
+		std::format ("Looked for image index {}, class index {}, method token {:x}",
+			mono_image_index,
+			class_index,
+			method_token
+		)
 	);
 
 	if (image == nullptr) {
-		log_fatal (LOG_DEFAULT, "Failed to load MonoImage for the assembly");
+		log_fatal (LOG_DEFAULT, "Failed to load MonoImage for the assembly"sv);
 	} else if (method == nullptr) {
-		log_fatal (LOG_DEFAULT, "Failed to load class from the assembly");
+		log_fatal (LOG_DEFAULT, "Failed to load class from the assembly"sv);
 	}
 
 	const char *message = nullptr;
@@ -109,7 +121,7 @@ MonodroidRuntime::get_function_pointer (uint32_t mono_image_index, uint32_t clas
 	}
 
 	Helpers::abort_application (
-		message == nullptr ? "Failure to obtain marshal methods function pointer" : message
+		message == nullptr ? "Failure to obtain marshal methods function pointer"sv : message
 	);
 }
 

src/native/pinvoke-override/precompiled.cc

@@ -67,7 +67,7 @@ PinvokeOverride::monodroid_pinvoke_override (const char *library_name, const cha
 
 			load_library_entry (library_name, entrypoint_name, *entry, dotnet_dso_handle);
 			if (entry->func == nullptr) {
-				log_fatal (LOG_ASSEMBLY, "Failed to load symbol '%s' from shared library '%s'", entrypoint_name, library_name);
+				log_fatal (LOG_ASSEMBLY, std::format ("Failed to load symbol '{}' from shared library '{}'", entrypoint_name, library_name));
 				return nullptr; // let Mono deal with the fallout
 			}
 

src/native/runtime-base/internal-pinvokes.hh

@@ -3,7 +3,7 @@
 #include <cstdio>
 
 #include <mono/utils/mono-publib.h>
-#include <java-interop-logger.h>
+//#include <java-interop-logger.h>
 #include <java-interop.h>
 #include <jni.h>
 

src/native/runtime-base/logger.cc

@@ -27,8 +27,15 @@ namespace {
 		FILE *f;
 
 		if (path && access (path, W_OK) < 0) {
-			log_warn (category, "Could not open path '%s' for logging (\"%s\"). Using '%s/%s' instead.",
-								path, strerror (errno), override_dir, filename);
+			log_warn (category,
+				std::format (
+					"Could not open path '{}' for logging (\"{}\"). Using '{}/{}' instead.",
+					path,
+					strerror (errno),
+					override_dir,
+					filename
+				)
+			);
 			path  = NULL;
 		}
 
@@ -45,7 +52,7 @@ namespace {
 		if (f) {
 			Util::set_world_accessable (path);
 		} else {
-			log_warn (category, "Could not open path '%s' for logging: %s", path, strerror (errno));
+			log_warn (category, std::format ("Could not open path '{}' for logging: {}", path, strerror (errno)));
 		}
 
 		free (p);
@@ -71,12 +78,12 @@ Logger::set_debugger_log_level (const char *level) noexcept
 
 	unsigned long v = strtoul (level, nullptr, 0);
 	if (v == std::numeric_limits<unsigned long>::max () && errno == ERANGE) {
-		log_error (LOG_DEFAULT, "Invalid debugger log level value '%s', expecting a positive integer or zero", level);
+		log_error (LOG_DEFAULT, std::format ("Invalid debugger log level value '{}', expecting a positive integer or zero", level));
 		return;
 	}
 
 	if (v > std::numeric_limits<int>::max ()) {
-		log_warn (LOG_DEFAULT, "Debugger log level value is higher than the maximum of %u, resetting to the maximum value.", std::numeric_limits<int>::max ());
+		log_warn (LOG_DEFAULT, std::format ("Debugger log level value is higher than the maximum of {}, resetting to the maximum value.", std::numeric_limits<int>::max ()));
 		v = std::numeric_limits<int>::max ();
 	}
 

src/native/runtime-base/strings.hh

@@ -156,7 +156,7 @@ namespace xamarin::android::internal
 			}
 
 			if (!can_access (start_index)) {
-				log_error (LOG_DEFAULT, "Cannot convert string to integer, index %u is out of range", start_index);
+				log_error (LOG_DEFAULT, std::format ("Cannot convert string to integer, index {} is out of range", start_index));
 				return false;
 			}
 
@@ -180,17 +180,17 @@ namespace xamarin::android::internal
 			}
 
 			if (out_of_range || errno == ERANGE) {
-				log_error (LOG_DEFAULT, "Value %s is out of range of this type (%lld..%llu)", s, static_cast<int64_t>(min), static_cast<uint64_t>(max));
+				log_error (LOG_DEFAULT, std::format ("Value {} is out of range of this type ({}..{})", reinterpret_cast<char*>(s), static_cast<int64_t>(min), static_cast<uint64_t>(max)));
 				return false;
 			}
 
 			if (endp == s) {
-				log_error (LOG_DEFAULT, "Value %s does not represent a base %d integer", s, base);
+				log_error (LOG_DEFAULT, std::format ("Value {} does not represent a base {} integer", reinterpret_cast<char*>(s), base));
 				return false;
 			}
 
 			if (*endp != '\0') {
-				log_error (LOG_DEFAULT, "Value %s has non-numeric characters at the end", s);
+				log_error (LOG_DEFAULT, std::format ("Value {} has non-numeric characters at the end", reinterpret_cast<char*>(s)));
 				return false;
 			}
 

src/native/runtime-base/timing-internal.cc

@@ -78,11 +78,11 @@ FastTiming::dump () noexcept
 	log_write (LOG_TIMING, LogLevel::Info, "[2/4] Accumulated performance results");
 
 	ns_to_time (total_assembly_load_time, sec, ms, ns);
-	log_info_nocheck (LOG_TIMING, "  [2/5] Assembly load: %u:%u::%u", sec, ms, ns);
+	log_info_nocheck (LOG_TIMING, std::format ("  [2/5] Assembly load: {}:{}::{}", sec, ms, ns));
 
 	ns_to_time (total_java_to_managed_time, sec, ms, ns);
-	log_info_nocheck (LOG_TIMING, "  [2/6] Java to Managed lookup: %u:%u::%u", sec, ms, ns);
+	log_info_nocheck (LOG_TIMING, std::format ("  [2/6] Java to Managed lookup: {}:{}::{}", sec, ms, ns));
 
 	ns_to_time (total_managed_to_java_time, sec, ms, ns);
-	log_info_nocheck (LOG_TIMING, "  [2/7] Managed to Java lookup: %u:%u::%u", sec, ms, ns);
+	log_info_nocheck (LOG_TIMING, std::format ("  [2/7] Managed to Java lookup: {}:{}::{}", sec, ms, ns));
 }

src/native/runtime-base/timing-internal.hh

@@ -144,7 +144,7 @@ namespace xamarin::android::internal
 					// likely we'll run out of memory way, way, way before that happens
 					size_t old_size = events.capacity ();
 					events.reserve (old_size << 1);
-					log_warn (LOG_TIMING, "Reallocated timing event buffer from %zu to %zu", old_size, events.size ());
+					log_warn (LOG_TIMING, std::format ("Reallocated timing event buffer from {} to {}", old_size, events.size ()));
 				}
 			}
 
@@ -246,7 +246,7 @@ namespace xamarin::android::internal
 		force_inline bool is_valid_event_index (size_t index, const char *method_name) noexcept
 		{
 			if (index >= events.capacity ()) [[unlikely]] {
-				log_warn (LOG_TIMING, "Invalid event index passed to method '%s'", method_name);
+				log_warn (LOG_TIMING, std::format ("Invalid event index passed to method '{}'", method_name));
 				return false;
 			}