1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
/* cfetch is my try to implement a neofetch/fastfetch/commiefetch clone in C.
* Copyright (C) 2026 Anser <https://codeberg.org/Anser/cfetch>
*
* cfetch is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* cfetch is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include "../include/cfetch.h"
#include <string.h>
/* function: char *string_format(char* string)
* input: pointer to a null-terminated string (must not be NULL)
* return: pointer to a newly allocated string containing all space-separated words,
* joined by single spaces; leading/trailing/multiple spaces are ignored.
* on-error: returns NULL if memory allocation fails
* misc: the returned pointer must be freed by the caller using free()
* limits: processes at most 10 words, each up to 49 characters (last '\0')
*/
char *string_format(char* string)
{
// Wörterbuch array [Wort][Zeichenkette]
char woerter[10][50] = { 0 };
int wort_index = 0;
int char_index = 0;
while (*string != '\0') {
// add '\0' stringterminator to end of word
if (*string == ' ' && char_index > 0) {
// safty check for array length
if (wort_index > 9 || char_index > 49) {
break;
}
// next slot is char
// add '\0' to end string
woerter[wort_index][char_index] = '\0';
wort_index++;
char_index = 0;
string++;
continue;
}
// skip extra spaces
else if (*string == ' ' && char_index == 0) {
string++;
continue;
}
// safty check for array length
if (char_index >= 49) {
break;
}
woerter[wort_index][char_index] = *string;
char_index++;
string++;
}
// terminate last word with '\0'
if (char_index > 0 && wort_index < 10 && char_index < 49) {
woerter[wort_index][char_index] = '\0';
wort_index++;
}
/*
* return
*/
char *ptr = NULL;
// get length of woerter array
if (wort_index == 0) {
ptr = NULL;
} else {
int sum = 0;
for (int i = 0; i < wort_index; i++) {
sum += strlen(woerter[i]);
}
sum += wort_index - 1; // for spaces
sum += 1; // for Nulltermination
ptr = (char *)malloc(sum);
// check for NULL pointer
if (ptr == NULL) {
return NULL;
}
//strcpy
char *ende = ptr;
for (int i = 0; i < wort_index; i++) {
ende = stpcpy(ende, woerter[i]);
if (i != wort_index - 1) {
*(ende++) = ' ';
}
}
}
return ptr;
}
// input two char pointer
// output: one char pointer
// misc: caller needs to free the memory
char *concat(const char *s1, const char *s2)
{
const size_t len1 = strlen(s1);
const size_t len2 = strlen(s2);
char *result = malloc(len1 + len2 + 1); // +1 for '\0'
if (result == NULL) {
perror("allocating memory for strings failed");
return NULL;
}
memcpy(result, s1, len1);
memcpy(result + len1, s2, len2 + 1); // +1 for null-terminator
return result; //caller needs to free memory
}
// input: pointer to string
// output: pointer to string with leading and tailing whitespaces removed
char *trim_whitespace(char* str)
{
char *end;
// Trim leading spaces
while (*str == ' ' || *str == '\t' || *str == '\n' || *str == '\r') {
str++;
}
if (*str == '\0') return str; // all spaces
// Trim trailing space
end = str + strlen(str) - 1;
while (end > str && (*end == ' ' || *end == '\t' || *end == '\r' || *end == '\n')) end--;
// Write new null terminator character
end[1] = '\0';
return str;
}
|
