From 63bc1c3dcc5d7eb26498d155da73e670aa2da4be Mon Sep 17 00:00:00 2001
From: Bastian Dehn <hhaalo@arcor.de>
Date: Sat, 28 Feb 2026 15:35:11 +0100
Subject: [PATCH] only alloc one dst

---
 src/main.c           |  27 ++++--
 src/rename.c         | 170 +++++++++++---------------------
 src/rename.h         |  12 +--
 tests/rename_tests.c | 226 ++++++++++++++++++++-----------------------
 4 files changed, 187 insertions(+), 248 deletions(-)

diff --git a/src/main.c b/src/main.c
index e5a105c..a33ca0a 100644
--- a/src/main.c
+++ b/src/main.c
@@ -44,25 +44,40 @@ void rename_file(const char* input, const char* output)
 
 void rename_files(const char* dir_path, rename_ptr renamefunc)
 {
+	char* output = malloc(STR_MAX_LENGTH);
+	if (output == NULL)
+		return;
+
+	char* dirname = malloc(STR_MAX_LENGTH);
+	if (dirname == NULL) {
+		free(output);
+		output = NULL;
+		return;
+	}
+
+	memset(output, 0, STR_MAX_LENGTH);
+	memset(dirname, 0, STR_MAX_LENGTH);
 	glob_t* files = get_files(dir_path);
 	for (size_t i = 0; i < files->gl_pathc; i++) {
-		char* output = renamefunc(files->gl_pathv[i]);
+		renamefunc(files->gl_pathv[i], output);
 		rename_file(files->gl_pathv[i], output);
 
 		if (is_dir(output)) {
-			char* dirname = escape(output);
+			escape(output, dirname);
 			rename_files(dirname, renamefunc);
-			free(dirname);
-			dirname = NULL;
+			memset(dirname, 0, STR_MAX_LENGTH);
 		}
 
-		free(output);
-		output = NULL;
+		memset(output, 0, STR_MAX_LENGTH);
 	}
 
 	globfree(files);
 	free(files);
 	files = NULL;
+	free(dirname);
+	dirname = NULL;
+	free(output);
+	output = NULL;
 }
 
 int main(int argc, char* argv[])
diff --git a/src/rename.c b/src/rename.c
index 9e68738..13ac556 100644
--- a/src/rename.c
+++ b/src/rename.c
@@ -4,40 +4,40 @@
 
 #include "rename.h"
 
-uint8_t _replace_two_byte_wide_char(const char* wide_char, char* dest)
+uint8_t _replace_two_byte_wide_char(const char* wide_char, char* dst)
 {
 	switch (wide_char[1]) {
 	case WIDE_CHAR_a:
-		dest[0] = 'a';
-		dest[1] = 'e';
+		dst[0] = 'a';
+		dst[1] = 'e';
 		break;
 	case WIDE_CHAR_A:
-		dest[0] = 'A';
-		dest[1] = 'e';
+		dst[0] = 'A';
+		dst[1] = 'e';
 		break;
 	case WIDE_CHAR_o:
-		dest[0] = 'o';
-		dest[1] = 'e';
+		dst[0] = 'o';
+		dst[1] = 'e';
 		break;
 	case WIDE_CHAR_O:
-		dest[0] = 'O';
-		dest[1] = 'e';
+		dst[0] = 'O';
+		dst[1] = 'e';
 		break;
 	case WIDE_CHAR_u:
-		dest[0] = 'u';
-		dest[1] = 'e';
+		dst[0] = 'u';
+		dst[1] = 'e';
 		break;
 	case WIDE_CHAR_U:
-		dest[0] = 'U';
-		dest[1] = 'e';
+		dst[0] = 'U';
+		dst[1] = 'e';
 		break;
 	case WIDE_CHAR_SS:
-		dest[0] = 's';
-		dest[1] = 's';
+		dst[0] = 's';
+		dst[1] = 's';
 		break;
 	default:
-		dest[0] = wide_char[0];
-		dest[1] = wide_char[1];
+		dst[0] = wide_char[0];
+		dst[1] = wide_char[1];
 		break;
 	}
 
@@ -71,14 +71,9 @@ uint8_t wide_char_length(const char character)
 	return count;
 }
 
-char* escape(const char* src)
+void escape(const char* src, char* dst)
 {
-	char* dest = malloc(sizeof(char) * STR_MAX_LENGTH);
-	if (dest == NULL)
-		return NULL;
-
-	memset(dest, 0, STR_MAX_LENGTH);
-	uint16_t dest_count = 0;
+	uint16_t dst_count = 0;
 	size_t length = strlen(src);
 	for (size_t i = 0; i < length; i++) {
 		switch(src[i]) {
@@ -89,152 +84,97 @@ char* escape(const char* src)
 		case BRACKET_CLOSE:
 		case BRACE_OPEN:
 		case BRACE_CLOSE:
-			dest[dest_count++] = '\\';
-			dest[dest_count++] = src[i];
+			dst[dst_count++] = '\\';
+			dst[dst_count++] = src[i];
 			break;
 		default:
-			dest[dest_count++] = src[i];
+			dst[dst_count++] = src[i];
 			break;
 		}
 	}
-
-	length = strlen(dest) + 1;
-	char* dest_tmp = realloc(dest, sizeof(char) * length);
-	if (dest_tmp == NULL) {
-		free(dest);
-		dest = NULL;
-		return NULL;
-	}
-	dest = dest_tmp;
-
-	return dest;
 }
 
-char* rename_point(const char* src)
+void rename_point(const char* src, char* dst)
 {
-	char* dest = rename_string(src);
+	rename_string(src, dst);
 
-	size_t length = strlen(dest);
+	size_t length = strlen(dst);
 	int point_count = 0;
 	for (size_t i = length - 1; i > 0; i--) {
-		if (dest[i] == POINT)
+		if (dst[i] == POINT)
 			point_count++;
 
-		if (dest[i] != POINT)
+		if (dst[i] != POINT)
 			break;
 	}
-	dest[length - point_count] = '\0';
 
-	length = strlen(dest) + 1;
-	char* dest_tmp = realloc(dest, sizeof(char) * length);
-	if (dest_tmp == NULL) {
-		free(dest);
-		dest = NULL;
-		return NULL;
-	}
-	dest = dest_tmp;
-
-	return dest;
+	dst[length - point_count] = '\0';
 }
 
-char* rename_lower(const char* src)
+void rename_lower(const char* src, char* dst)
 {
-	char* dest = rename_string(src);
-	size_t length = strlen(dest);
+	rename_string(src, dst);
+	size_t length = strlen(dst);
 	for (size_t i = 0; i < length; i++) {
-		if (dest[i] >= A && dest[i] <= Z)
-			dest[i] += SPACE;
+		if (dst[i] >= A && dst[i] <= Z)
+			dst[i] += SPACE;
 	}
-
-	return dest;
 }
 
-char* rename_string(const char* src)
+void rename_string(const char* src, char* dst)
 {
-	char* dest = malloc(sizeof(char) * STR_MAX_LENGTH);
-	if (dest == NULL)
-		return NULL;
-
-	memset(dest, 0, STR_MAX_LENGTH);
-	uint16_t dest_count = 0;
+	uint16_t dst_count = 0;
 	size_t length = strlen(src);
 	for (size_t i = 0; i < length; i++) {
 		switch (wide_char_length(src[i])) {
 		case 2:
-			dest_count += _replace_two_byte_wide_char(&src[i], &dest[dest_count]);
+			dst_count += _replace_two_byte_wide_char(&src[i], &dst[dst_count]);
 			i++;
 			break;
 		default:
-			dest_count += _replace_char(src[i], &dest[dest_count]);
+			dst_count += _replace_char(src[i], &dst[dst_count]);
 			break;
 		}
 	}
-
-	length = strlen(dest) + 1;
-	char* dest_tmp = realloc(dest, sizeof(char) * length);
-	if (dest_tmp == NULL) {
-		free(dest);
-		dest = NULL;
-		return NULL;
-	}
-	dest = dest_tmp;
-
-	return dest;
 }
 
-char* rename_revert(const char* src)
+void rename_revert(const char* src, char* dst)
 {
-	char* dest = malloc(sizeof(char) * STR_MAX_LENGTH);
-	if (dest == NULL)
-		return NULL;
-
-	memset(dest, 0, STR_MAX_LENGTH);
-	uint16_t dest_count = 0;
+	uint16_t dst_count = 0;
 	size_t length = strlen(src);
 	for (size_t i = 0; i < length; i++) {
 		if (src[i] == '_') {
-			dest[dest_count++] = SPACE;
+			dst[dst_count++] = SPACE;
 		} else if (src[i] == 'a' && src[i + 1] == 'e') {
 			i++;
-			dest[dest_count++] = WIDE_CHAR_SHORT_PREFIX;
-			dest[dest_count++] = WIDE_CHAR_SHORT_a;
+			dst[dst_count++] = WIDE_CHAR_SHORT_PREFIX;
+			dst[dst_count++] = WIDE_CHAR_SHORT_a;
 		} else if (src[i] == 'A' && src[i + 1] == 'e') {
 			i++;
-			dest[dest_count++] = WIDE_CHAR_SHORT_PREFIX;
-			dest[dest_count++] = WIDE_CHAR_SHORT_A;
+			dst[dst_count++] = WIDE_CHAR_SHORT_PREFIX;
+			dst[dst_count++] = WIDE_CHAR_SHORT_A;
 		} else if (src[i] == 'o' && src[i + 1] == 'e') {
 			i++;
-			dest[dest_count++] = WIDE_CHAR_SHORT_PREFIX;
-			dest[dest_count++] = WIDE_CHAR_SHORT_o;
+			dst[dst_count++] = WIDE_CHAR_SHORT_PREFIX;
+			dst[dst_count++] = WIDE_CHAR_SHORT_o;
 		} else if (src[i] == 'O' && src[i + 1] == 'e') {
 			i++;
-			dest[dest_count++] = WIDE_CHAR_SHORT_PREFIX;
-			dest[dest_count++] = WIDE_CHAR_SHORT_O;
+			dst[dst_count++] = WIDE_CHAR_SHORT_PREFIX;
+			dst[dst_count++] = WIDE_CHAR_SHORT_O;
 		} else if (src[i] == 'u' && src[i + 1] == 'e') {
 			i++;
-			dest[dest_count++] = WIDE_CHAR_SHORT_PREFIX;
-			dest[dest_count++] = WIDE_CHAR_SHORT_u;
+			dst[dst_count++] = WIDE_CHAR_SHORT_PREFIX;
+			dst[dst_count++] = WIDE_CHAR_SHORT_u;
 		} else if (src[i] == 'U' && src[i + 1] == 'e') {
 			i++;
-			dest[dest_count++] = WIDE_CHAR_SHORT_PREFIX;
-			dest[dest_count++] = WIDE_CHAR_SHORT_U;
+			dst[dst_count++] = WIDE_CHAR_SHORT_PREFIX;
+			dst[dst_count++] = WIDE_CHAR_SHORT_U;
 		} else if (src[i] == 's' && src[i + 1] == 's') {
 			i++;
-			dest[dest_count++] = WIDE_CHAR_SHORT_PREFIX;
-			dest[dest_count++] = WIDE_CHAR_SHORT_SS;
+			dst[dst_count++] = WIDE_CHAR_SHORT_PREFIX;
+			dst[dst_count++] = WIDE_CHAR_SHORT_SS;
 		} else {
-			dest[dest_count++] = src[i];
+			dst[dst_count++] = src[i];
 		}
 	}
-
-	length = strlen(dest) + 1;
-	char* dest_tmp = realloc(dest, sizeof(char) * length);
-	if (dest_tmp == NULL) {
-		free(dest);
-		dest = NULL;
-		return NULL;
-	}
-	dest = dest_tmp;
-
-	return dest;
 }
\ No newline at end of file
diff --git a/src/rename.h b/src/rename.h
index 0b60269..76334eb 100644
--- a/src/rename.h
+++ b/src/rename.h
@@ -31,13 +31,13 @@
 #define WIDE_CHAR_SHORT_U (char) 0x9c
 #define WIDE_CHAR_SHORT_SS (char) 0x9f
 
-typedef char* (*rename_ptr)(const char* src);
+typedef void (*rename_ptr)(const char* src, char* dst);
 
 uint8_t wide_char_length(const char character);
-char* escape(const char* src);
-char* rename_point(const char* src);
-char* rename_lower(const char* src);
-char* rename_string(const char* src);
-char* rename_revert(const char* src);
+void escape(const char* src, char* dst);
+void rename_point(const char* src, char* dst);
+void rename_lower(const char* src, char* dst);
+void rename_string(const char* src, char* dst);
+void rename_revert(const char* src, char* dst);
 
 #endif
\ No newline at end of file
diff --git a/tests/rename_tests.c b/tests/rename_tests.c
index 0fc681b..346db23 100644
--- a/tests/rename_tests.c
+++ b/tests/rename_tests.c
@@ -7,244 +7,228 @@
 #include <string.h>
 #include "../src/rename.h"
 
-void rename_spaces()
+int setup_group(void** state)
 {
+	char* output = malloc(STR_MAX_LENGTH);
+	if (output == NULL)
+		return 1;
+
+	*state = output;
+	return 0;
+}
+
+int teardown_group(void** state)
+{
+	free(*state);
+	*state = NULL;
+
+	return 0;
+}
+
+int setup(void** state)
+{
+	memset(*state, 0, STR_MAX_LENGTH);
+	return 0;
+}
+
+void rename_spaces(void** state)
+{
+	char* output = (char*) *state;
 	const char* input = "Dies ist ein Test Satz";
 
-	char* output = rename_string(input);
+	rename_string(input, output);
 
 	assert_string_equal(output, "Dies_ist_ein_Test_Satz");
-
-	free(output);
-	output = NULL;
 }
 
-void rename_ae()
+void rename_ae(void** state)
 {
+	char* output = (char*) *state;
 	const char* input = "wäre";
 
-	char* output = rename_string(input);
+	rename_string(input, output);
 
 	assert_string_equal(output, "waere");
-
-	free(output);
-	output = NULL;
 }
 
-void rename_Ae()
+void rename_Ae(void** state)
 {
+	char* output = (char*) *state;
 	const char* input = "Ächtzen";
 
-	char* output = rename_string(input);
+	rename_string(input, output);
 
 	assert_string_equal(output, "Aechtzen");
-
-	free(output);
-	output = NULL;
 }
 
-void rename_oe()
+void rename_oe(void** state)
 {
+	char* output = (char*) *state;
 	const char* input = "König";
 
-	char* output = rename_string(input);
+	rename_string(input, output);
 
 	assert_string_equal(output, "Koenig");
-
-	free(output);
-	output = NULL;
 }
 
-void rename_Oe()
+void rename_Oe(void** state)
 {
+	char* output = (char*) *state;
 	const char* input = "Ökosystem";
 
-	char* output = rename_string(input);
+	rename_string(input, output);
 
 	assert_string_equal(output, "Oekosystem");
-
-	free(output);
-	output = NULL;
 }
 
-void rename_ue()
+void rename_ue(void** state)
 {
+	char* output = (char*) *state;
 	const char* input = "brüllt";
 
-	char* output = rename_string(input);
+	rename_string(input, output);
 
 	assert_string_equal(output, "bruellt");
-
-	free(output);
-	output = NULL;
 }
 
-void rename_Ue()
+void rename_Ue(void** state)
 {
+	char* output = (char*) *state;
 	const char* input = "Überlastung";
 
-	char* output = rename_string(input);
+	rename_string(input, output);
 
 	assert_string_equal(output, "Ueberlastung");
-
-	free(output);
-	output = NULL;
 }
 
-void rename_scharfes_s()
+void rename_scharfes_s(void** state)
 {
+	char* output = (char*) *state;
 	const char* input = "Gruß";
 
-	char* output = rename_string(input);
+	rename_string(input, output);
 
 	assert_string_equal(output, "Gruss");
-
-	free(output);
-	output = NULL;
 }
 
-void none_replace_wide_char()
+void none_replace_wide_char(void** state)
 {
+	char* output = (char*) *state;
 	const char* none_replace = "ō";
 
-	char* output = rename_string(none_replace);
+	rename_string(none_replace, output);
 
 	assert_string_equal(output, none_replace);
-
-	free(output);
-	output = NULL;
 }
 
-void rename_lower_case()
+void rename_lower_case(void** state)
 {
+	char* output = (char*) *state;
 	const char* input = "Gruß Gott, hat der Biergarten offen?";
 
-	char* output = rename_lower(input);
+	rename_lower(input, output);
 
 	assert_string_equal(output, "gruss_gott,_hat_der_biergarten_offen?");
-
-	free(output);
-	output = NULL;
 }
 
-void rename_point_case()
+void rename_point_case(void** state)
 {
+	char* output = (char*) *state;
 	const char* input = "Dies ist die Geschichte von...........";
 
-	char* output = rename_point(input);
+	rename_point(input, output);
 
 	assert_string_equal(output, "Dies_ist_die_Geschichte_von");
-
-	free(output);
-	output = NULL;
 }
 
-void escape_test()
+void escape_test(void** state)
 {
+	char* output = (char*) *state;
 	const char* input = "Dies ist [die] (Geschichte) {von}";
 
-	char* output = escape(input);
+	escape(input, output);
 
 	assert_string_equal(output, "Dies\\ ist\\ \\[die\\]\\ \\(Geschichte\\)\\ \\{von\\}");
-
-	free(output);
-	output = NULL;
 }
 
-void rename_revert_spaces()
+void rename_revert_spaces(void** state)
 {
+	char* output = (char*) *state;
 	const char* input = "Dies_ist_ein_Test_Satz";
 
-	char* output = rename_revert(input);
+	rename_revert(input, output);
 
 	assert_string_equal(output, "Dies ist ein Test Satz");
-
-	free(output);
-	output = NULL;
 }
 
-void rename_revert_ae()
+void rename_revert_ae(void** state)
 {
+	char* output = (char*) *state;
 	const char* input = "waere";
 
-	char* output = rename_revert(input);
+	rename_revert(input, output);
 
 	assert_string_equal(output, "wäre");
-
-	free(output);
-	output = NULL;
 }
 
-void rename_revert_Ae()
+void rename_revert_Ae(void** state)
 {
+	char* output = (char*) *state;
 	const char* input = "Aechtzen";
 
-	char* output = rename_revert(input);
+	rename_revert(input, output);
 
 	assert_string_equal(output, "Ächtzen");
-
-	free(output);
-	output = NULL;
 }
 
-void rename_revert_oe()
+void rename_revert_oe(void** state)
 {
+	char* output = (char*) *state;
 	const char* input = "Koenig";
 
-	char* output = rename_revert(input);
+	rename_revert(input, output);
 
 	assert_string_equal(output, "König");
-
-	free(output);
-	output = NULL;
 }
 
-void rename_revert_Oe()
+void rename_revert_Oe(void** state)
 {
+	char* output = (char*) *state;
 	const char* input = "Oekosystem";
 
-	char* output = rename_revert(input);
+	rename_revert(input, output);
 
 	assert_string_equal(output, "Ökosystem");
-
-	free(output);
-	output = NULL;
 }
 
-void rename_revert_ue()
+void rename_revert_ue(void** state)
 {
+	char* output = (char*) *state;
 	const char* input = "bruellt";
 
-	char* output = rename_revert(input);
+	rename_revert(input, output);
 
 	assert_string_equal(output, "brüllt");
-
-	free(output);
-	output = NULL;
 }
 
-void rename_revert_Ue()
+void rename_revert_Ue(void** state)
 {
+	char* output = (char*) *state;
 	const char* input = "Ueberlastung";
 
-	char* output = rename_revert(input);
+	rename_revert(input, output);
 
 	assert_string_equal(output, "Überlastung");
-
-	free(output);
-	output = NULL;
 }
 
-void rename_revert_ss()
+void rename_revert_ss(void** state)
 {
+	char* output = (char*) *state;
 	const char* input = "Gruss";
 
-	char* output = rename_revert(input);
+	rename_revert(input, output);
 
 	assert_string_equal(output, "Gruß");
-
-	free(output);
-	output = NULL;
 }
 
 void no_wide_character()
@@ -286,31 +270,31 @@ void four_byte_wide_character()
 int main()
 {
 	const struct CMUnitTest tests[] = {
-		cmocka_unit_test(rename_spaces),
-		cmocka_unit_test(rename_ae),
-		cmocka_unit_test(rename_Ae),
-		cmocka_unit_test(rename_oe),
-		cmocka_unit_test(rename_Oe),
-		cmocka_unit_test(rename_ue),
-		cmocka_unit_test(rename_Ue),
-		cmocka_unit_test(none_replace_wide_char),
-		cmocka_unit_test(rename_scharfes_s),
-		cmocka_unit_test(rename_lower_case),
-		cmocka_unit_test(rename_point_case),
-		cmocka_unit_test(escape_test),
-		cmocka_unit_test(rename_revert_spaces),
-		cmocka_unit_test(rename_revert_ae),
-		cmocka_unit_test(rename_revert_Ae),
-		cmocka_unit_test(rename_revert_oe),
-		cmocka_unit_test(rename_revert_Oe),
-		cmocka_unit_test(rename_revert_ue),
-		cmocka_unit_test(rename_revert_Ue),
-		cmocka_unit_test(rename_revert_ss),
+		cmocka_unit_test_setup(rename_spaces, setup),
+		cmocka_unit_test_setup(rename_ae, setup),
+		cmocka_unit_test_setup(rename_Ae, setup),
+		cmocka_unit_test_setup(rename_oe, setup),
+		cmocka_unit_test_setup(rename_Oe, setup),
+		cmocka_unit_test_setup(rename_ue, setup),
+		cmocka_unit_test_setup(rename_Ue, setup),
+		cmocka_unit_test_setup(none_replace_wide_char, setup),
+		cmocka_unit_test_setup(rename_scharfes_s, setup),
+		cmocka_unit_test_setup(rename_lower_case, setup),
+		cmocka_unit_test_setup(rename_point_case, setup),
+		cmocka_unit_test_setup(escape_test, setup),
+		cmocka_unit_test_setup(rename_revert_spaces, setup),
+		cmocka_unit_test_setup(rename_revert_ae, setup),
+		cmocka_unit_test_setup(rename_revert_Ae, setup),
+		cmocka_unit_test_setup(rename_revert_oe, setup),
+		cmocka_unit_test_setup(rename_revert_Oe, setup),
+		cmocka_unit_test_setup(rename_revert_ue, setup),
+		cmocka_unit_test_setup(rename_revert_Ue, setup),
+		cmocka_unit_test_setup(rename_revert_ss, setup),
 		cmocka_unit_test(no_wide_character),
 		cmocka_unit_test(two_byte_wide_character),
 		cmocka_unit_test(three_byte_wide_character),
 		cmocka_unit_test(four_byte_wide_character),
 	};
 
-	return cmocka_run_group_tests(tests, NULL, NULL);
+	return cmocka_run_group_tests(tests, setup_group, teardown_group);
 }
\ No newline at end of file
-- 
2.47.3