strutil cleanup & fixes

common.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include <cassert>
 #include <cstdint>
 #include <cstdio>

files.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include <filesystem>
 #include <string>
 

handles.h

@@ -1,4 +1,6 @@
-#include <stdlib.h>
+#pragma once
+
+#include <cstdlib>
 
 namespace handles {
 	enum Type {

processes.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include <cstdint>
 #include <sched.h>
 

resources.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cstdint>
 
 namespace wibo {
 
@@ -11,4 +12,4 @@ bool resourceEntryBelongsToExecutable(const Executable &exe, const ImageResource
 ResourceIdentifier resourceIdentifierFromAnsi(const char *id);
 ResourceIdentifier resourceIdentifierFromWide(const uint16_t *id);
 
-}
+} // namespace wibo

strutil.cpp

@@ -1,14 +1,13 @@
+#include "strutil.h"
 #include "common.h"
-#include "strings.h"
 #include <cstdint>
-#include <vector>
-#include <string>
-#include <locale>
-#include <codecvt>
 #include <sstream>
+#include <string>
+#include <vector>
 
 size_t wstrlen(const uint16_t *str) {
-	if(!str) return 0;
+	if (!str)
+		return 0;
 
 	size_t len = 0;
 	while (str[len] != 0)
@@ -16,191 +15,209 @@ size_t wstrlen(const uint16_t *str) {
 	return len;
 }
 
-size_t wstrnlen(const uint16_t* str, size_t numberOfElements){
+size_t wstrnlen(const uint16_t *str, size_t numberOfElements) {
+	if (!str)
+		return 0;
 	size_t len = 0;
-    while (str[len] != 0 && len < numberOfElements)
+	while (len < numberOfElements && str[len] != 0)
 		++len;
-    return len;
+	return len;
 }
 
-int wstrncmp(const uint16_t *string1, const uint16_t *string2, size_t count){
+int wstrncmp(const uint16_t *string1, const uint16_t *string2, size_t count) {
-	const uint16_t* ptr1 = string1;
+	const uint16_t *ptr1 = string1;
-	const uint16_t* ptr2 = string2;
+	const uint16_t *ptr2 = string2;
-	for(size_t i = 0; i < count; i++){
+	for (size_t i = 0; i < count; i++) {
 		uint16_t c1 = *ptr1++;
 		uint16_t c2 = *ptr2++;
 		if (c1 != c2) {
-            return (c1 > c2) ? 1 : -1;
+			return (c1 > c2) ? 1 : -1;
-        }
+		}
 	}
 	return 0;
 }
 
-const uint16_t* wstrstr(const uint16_t *dest, const uint16_t *src){
+const uint16_t *wstrstr(const uint16_t *dest, const uint16_t *src) {
-	if (!*src) return dest;
+	if (!*src)
+		return dest;
 
-    for (; *dest != 0; dest++) {
+	for (; *dest != 0; dest++) {
-        const uint16_t* d = dest;
+		const uint16_t *d = dest;
-        const uint16_t* s = src;
+		const uint16_t *s = src;
 
-        while (*d != 0 && *s != 0 && *d == *s) {
+		while (*d != 0 && *s != 0 && *d == *s) {
-            d++;
+			d++;
-            s++;
+			s++;
-        }
+		}
 
-        if (*s == 0) {
+		if (*s == 0) {
-            return dest;
+			return dest;
-        }
+		}
-    }
+	}
 
-    return nullptr;
+	return nullptr;
 }
 
-uint16_t* wstrchr(const uint16_t* str, uint16_t c) {
+uint16_t *wstrchr(const uint16_t *str, uint16_t c) {
-    for (; *str != 0; str++) {
+	if (!str)
-        if (*str == c) {
+		return nullptr;
-            return (uint16_t*)str;
+	for (; *str != 0; str++) {
-        }
+		if (*str == c) {
-    }
+			return (uint16_t *)str;
-    // If searching for '\0', return pointer to terminator
+		}
-    if (c == 0) {
+	}
-        return (uint16_t*)str;
+	// If searching for '\0', return pointer to terminator
-    }
+	if (c == 0) {
-    return nullptr;
+		return (uint16_t *)str;
+	}
+	return nullptr;
 }
 
-uint16_t* wstrrchr(const uint16_t* str, uint16_t c){
+uint16_t *wstrrchr(const uint16_t *str, uint16_t c) {
-	const uint16_t* last = nullptr;
+	if (!str)
-    for (; *str != 0; str++) {
+		return nullptr;
-        if (*str == c) {
+	const uint16_t *last = nullptr;
-            last = str;
+	const uint16_t *it = str;
-        }
+	for (; *it != 0; ++it) {
-    }
+		if (*it == c) {
-    return (uint16_t*)last;
+			last = it;
+		}
+	}
+	if (c == 0)
+		return (uint16_t *)it;
+	return (uint16_t *)last;
 }
 
-uint16_t* wstrcat(uint16_t* dest, const uint16_t* src){
+uint16_t *wstrcat(uint16_t *dest, const uint16_t *src) {
-	uint16_t* d = dest;
+	uint16_t *d = dest;
-	while (*d) d++;
+	while (*d)
-	while ((*d++ = *src++) != 0);
+		d++;
+	while ((*d++ = *src++) != 0)
+		;
 	return dest;
 }
 
-uint16_t* wstrncat(uint16_t* dest, const uint16_t* src, size_t count){
+uint16_t *wstrncat(uint16_t *dest, const uint16_t *src, size_t count) {
-    uint16_t* d = dest;
+	uint16_t *d = dest;
-	while (*d) d++;
+	while (*d)
-	for(size_t i = 0; i < count && src[i] != 0; i++){
+		d++;
+	for (size_t i = 0; i < count && src[i] != 0; i++) {
 		*d++ = src[i];
 	}
 	*d = 0;
-    return dest;
+	return dest;
 }
 
-uint16_t* wstrcpy(uint16_t* dest, const uint16_t* src){
+uint16_t *wstrcpy(uint16_t *dest, const uint16_t *src) {
-	uint16_t* d = dest;
+	uint16_t *d = dest;
-    while ((*d++ = *src++) != 0);
+	while ((*d++ = *src++) != 0)
-    return dest;
+		;
+	return dest;
 }
 
 size_t wstrncpy(uint16_t *dst, const uint16_t *src, size_t n) {
+	if (!dst || !src || n == 0)
+		return 0;
 	size_t i = 0;
-	while (i < n && src[i] != 0) {
+	for (; i < n && src[i] != 0; ++i) {
 		dst[i] = src[i];
-		++i;
 	}
-	if (i < n)
+	for (size_t j = i; j < n; ++j) {
-		dst[i] = 0;
+		dst[j] = 0;
+	}
 	return i;
 }
 
-std::string wideStringToString(const uint16_t *src, int len = -1) {
+std::string wideStringToString(const uint16_t *src, int len) {
-	if(!src) return std::string();
+	if (!src)
-	if (len < 0) {
+		return {};
-		len = src ? wstrlen(src) : 0;
+
+	size_t count;
+	if (len >= 0) {
+		count = static_cast<size_t>(len);
+	} else {
+		count = wstrlen(src);
 	}
 
-	// std::u16string u16str;
+#ifndef NDEBUG
-	// for(const uint16_t* p = src; *p != 0; p++){
+	std::stringstream hexDump;
-	// 	u16str.push_back(*p);
+	hexDump << std::hex;
-	// }
+	bool sawWide = false;
+#endif
 
-	// std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
+	std::string result(count, '\0');
-	// return convert.to_bytes(reinterpret_cast<const char16_t*>(u16str.data()));
+	for (size_t i = 0; i < count; ++i) {
+		uint16_t value = src[i];
+		if (i > 0)
+			hexDump << ' ';
+		hexDump << "0x" << value;
+		if (value > 0xFF)
+			sawWide = true;
+		result[i] = static_cast<char>(value & 0xFF);
+	}
 
-	// the old implementation
+#ifndef NDEBUG
-	std::string res(len, '\0');
+	if (sawWide) {
-	std::string debug_wstr;
+		size_t loggedLength = (len >= 0) ? count : wstrlen(src);
-		std::stringstream ss;
+		DEBUG_LOG("wideString (%zu): %s\n", loggedLength, hexDump.str().c_str());
-		bool is_wide = false;
-	for (int i = 0; i < len; i++) {
-		ss << "0x" << std::hex << src[i] << " ";
-		// debug_wstr += std::format("0x%X ", src[i]);
-		if(src[i] > 255){
-		// 	DEBUG_LOG("Encountered wide char with value 0x%X!\n", src[i]);
-		// 	assert(src[i] <= 255);
-			is_wide = true;
-		}
-		res[i] = src[i] & 0xFF;
 	}
-	if(is_wide){
+#endif
-		debug_wstr += ss.str();
+
-		DEBUG_LOG("wideString (%d): %s\n", wstrlen(src), debug_wstr.c_str());
+	return result;
-	}
-	return res;
 }
 
 std::vector<uint16_t> stringToWideString(const char *src) {
-	int len = strlen(src);
+	if (!src)
+		return std::vector<uint16_t>{0};
+	size_t len = strlen(src);
 	std::vector<uint16_t> res(len + 1);
-
 	for (size_t i = 0; i < res.size(); i++) {
-		res[i] = src[i] & 0xFF;
+		res[i] = static_cast<uint16_t>(src[i] & 0xFF);
 	}
 	res[len] = 0; // NUL terminate
-
 	return res;
 }
 
-long wstrtol(const uint16_t* string, uint16_t** end_ptr, int base){
+long wstrtol(const uint16_t *string, uint16_t **end_ptr, int base) {
-	if(!string){
+	if (!string) {
-		if(end_ptr) *end_ptr = nullptr;
+		if (end_ptr)
+			*end_ptr = nullptr;
 		return 0;
 	}
 
 	std::string normal_str = wideStringToString(string);
-	char* normal_end = nullptr;
+	char *normal_end = nullptr;
 	long res = std::strtol(normal_str.c_str(), &normal_end, base);
 
-	if(end_ptr){
+	if (end_ptr) {
-		if(normal_end && *normal_end){
+		if (normal_end && *normal_end) {
 			size_t offset = normal_end - normal_str.c_str();
-			*end_ptr = (uint16_t*)(string + offset);
+			*end_ptr = (uint16_t *)(string + offset);
-		}
+		} else {
-		else {
+			*end_ptr = (uint16_t *)(string + normal_str.size());
-			*end_ptr = (uint16_t*)(string + normal_str.size());
 		}
 	}
 
 	return res;
 }
 
-unsigned long wstrtoul(const uint16_t* string, uint16_t** end_ptr, int base){
+unsigned long wstrtoul(const uint16_t *string, uint16_t **end_ptr, int base) {
-	if(!string){
+	if (!string) {
-		if(end_ptr) *end_ptr = nullptr;
+		if (end_ptr)
+			*end_ptr = nullptr;
 		return 0;
 	}
 
 	std::string normal_str = wideStringToString(string);
-	char* normal_end = nullptr;
+	char *normal_end = nullptr;
 	unsigned long res = std::strtoul(normal_str.c_str(), &normal_end, base);
 
-	if(end_ptr){
+	if (end_ptr) {
-		if(normal_end && *normal_end){
+		if (normal_end && *normal_end) {
 			size_t offset = normal_end - normal_str.c_str();
-			*end_ptr = (uint16_t*)(string + offset);
+			*end_ptr = (uint16_t *)(string + offset);
-		}
+		} else {
-		else {
+			*end_ptr = (uint16_t *)(string + normal_str.size());
-			*end_ptr = (uint16_t*)(string + normal_str.size());
 		}
 	}
 

strutil.h

@@ -1,17 +1,20 @@
+#pragma once
+
+#include <cstdint>
 #include <string>
 #include <vector>
 
 size_t wstrlen(const uint16_t *str);
-size_t wstrnlen(const uint16_t* str, size_t numberOfElements);
+size_t wstrnlen(const uint16_t *str, size_t numberOfElements);
 int wstrncmp(const uint16_t *string1, const uint16_t *string2, size_t count);
-const uint16_t* wstrstr(const uint16_t *dest, const uint16_t *src);
+const uint16_t *wstrstr(const uint16_t *dest, const uint16_t *src);
-uint16_t* wstrchr(const uint16_t* str, uint16_t c);
+uint16_t *wstrchr(const uint16_t *str, uint16_t c);
-uint16_t* wstrrchr(const uint16_t* str, uint16_t c);
+uint16_t *wstrrchr(const uint16_t *str, uint16_t c);
-uint16_t* wstrcat(uint16_t* dest, const uint16_t* src);
+uint16_t *wstrcat(uint16_t *dest, const uint16_t *src);
-uint16_t* wstrncat(uint16_t* dest, const uint16_t* src, size_t count);
+uint16_t *wstrncat(uint16_t *dest, const uint16_t *src, size_t count);
-uint16_t* wstrcpy(uint16_t* dest, const uint16_t* src);
+uint16_t *wstrcpy(uint16_t *dest, const uint16_t *src);
 size_t wstrncpy(uint16_t *dst, const uint16_t *src, size_t n);
 std::string wideStringToString(const uint16_t *src, int len = -1);
 std::vector<uint16_t> stringToWideString(const char *src);
-long wstrtol(const uint16_t* string, uint16_t** end_ptr, int base);
+long wstrtol(const uint16_t *string, uint16_t **end_ptr, int base);
-unsigned long wstrtoul(const uint16_t* strSource, uint16_t** end_ptr, int base);
+unsigned long wstrtoul(const uint16_t *string, uint16_t **end_ptr, int base);