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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
|
/* -------------------------------------------
Copyright (C) 2024, Amlal EL Mahrouss, all rights reserved.
------------------------------------------- */
#include <NewKit/Utils.h>
namespace Kernel
{
Int32 rt_string_cmp(const Char* src, const Char* cmp, Size size)
{
Int32 counter = 0;
for (Size index = 0; index < size; ++index)
{
if (src[index] != cmp[index])
++counter;
}
return counter;
}
Void rt_zero_memory(voidPtr pointer, Size len)
{
rt_set_memory(pointer, 0, len);
}
SizeT rt_string_len(const Char* str, SizeT _len)
{
SizeT len{0};
do
{
if (len > _len)
{
return _len;
}
++len;
} while (str[len] != '\0');
return len;
}
Size rt_string_len(const Char* ptr)
{
SizeT cnt{0};
while (ptr[cnt] != 0)
++cnt;
return cnt;
}
voidPtr rt_set_memory(voidPtr src, UInt32 value, Size len)
{
UInt32* start = reinterpret_cast<UInt32*>(src);
while (len)
{
*start = value;
++start;
--len;
}
return (voidPtr)start;
}
Int rt_move_memory(const voidPtr src, voidPtr dst, Size len)
{
Char* srcChr = reinterpret_cast<Char*>(src);
Char* dstChar = reinterpret_cast<Char*>(dst);
SizeT index = 0;
while (index < len)
{
dstChar[index] = srcChr[index];
srcChr[index] = 0;
++index;
}
return 0;
}
Int rt_copy_memory(const voidPtr src, voidPtr dst, Size len)
{
char* srcChr = reinterpret_cast<char*>(src);
char* dstChar = reinterpret_cast<char*>(dst);
Size index = 0;
while (index < len)
{
dstChar[index] = srcChr[index];
++index;
}
dstChar[index] = 0;
return index;
}
const Char* rt_alloc_string(const Char* src)
{
const Char* string = new Char[rt_string_len(src) + 1];
if (!string)
return nullptr;
voidPtr v_src = reinterpret_cast<voidPtr>(const_cast<char*>(src));
voidPtr v_dst = reinterpret_cast<voidPtr>(const_cast<char*>(string));
rt_copy_memory(v_src, v_dst, rt_string_len(src) + 1);
return string;
}
Int32 rt_to_uppercase(Int32 character)
{
if (character >= 'a' && character <= 'z')
return character - 0x20;
return character;
}
Int32 rt_to_lower(Int32 character)
{
if (character >= 'A' && character <= 'Z')
return character + 0x20;
return character;
}
Boolean is_space(Char chr)
{
return chr == ' ';
}
Boolean is_newln(Char chr)
{
return chr == '\n';
}
VoidPtr rt_string_in_string(const Char* in, const Char* needle)
{
for (SizeT i = 0; i < rt_string_len(in); ++i)
{
if (rt_string_cmp(in + i, needle, rt_string_len(needle)) == 0)
return reinterpret_cast<voidPtr>(const_cast<char*>(in + i));
}
return nullptr;
}
Char rt_to_char(UInt64 base, Int32 limit)
{
const Char kNumbers[17] = "0123456789ABCDEF";
return kNumbers[base % limit];
}
Bool rt_to_string(Char* str, UInt64 base, Int32 limit)
{
#ifdef __ZKA_AMD64__
auto i = 0;
auto final_number = base;
auto mult = 1;
auto elems = 0L;
base /= 10;
while (base > 0)
{
elems++;
mult *= 10;
base /= 10;
}
while (elems > -1)
{
final_number = (final_number % mult) * 10 + final_number / mult;
str[i] = rt_to_char(final_number, limit);
--elems;
++i;
}
#endif
return YES;
}
/// @brief Checks for a string start at the character.
Char* rt_string_has_char(Char* str, const Char chr)
{
while (*str != chr)
{
++str;
if (*str == 0)
return nullptr;
}
return str;
}
} // namespace Kernel
EXTERN_C void* memset(void* dst, int c, long long unsigned int len)
{
return Kernel::rt_set_memory(dst, c, len);
}
EXTERN_C void* memcpy(void* dst, const void* src, long long unsigned int len)
{
Kernel::rt_copy_memory(const_cast<void*>(src), dst, len);
return dst;
}
|
