133 lines
3.2 KiB
C
Executable File
133 lines
3.2 KiB
C
Executable File
#include "tlibc/string/str.h"
|
|
#include "tlibc/string/StringBuilder.h"
|
|
|
|
str str_copy(str src){
|
|
if(src.data == NULL || src.size == 0)
|
|
return src;
|
|
|
|
str nstr = str_construct((char*)malloc(src.size + 1), src.size, true);
|
|
memcpy(nstr.data, src.data, src.size);
|
|
nstr.data[nstr.size] = '\0';
|
|
return nstr;
|
|
}
|
|
|
|
bool str_equals(str s0, str s1){
|
|
if(s0.size != s1.size)
|
|
return false;
|
|
|
|
for(u32 i = 0; i < s0.size; i++)
|
|
if(s0.data[i] != s1.data[i])
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
str str_reverse(str s){
|
|
if(s.data == NULL || s.size == 0)
|
|
return s;
|
|
|
|
str r = str_construct(malloc(s.size), s.size, s.isZeroTerminated);
|
|
for(u32 i = 0; i < s.size; i++ )
|
|
r.data[i] = s.data[s.size - i - 1];
|
|
return r;
|
|
}
|
|
|
|
i32 str_seek(str src, str fragment, u32 startIndex){
|
|
if(src.size == 0 || fragment.size == 0)
|
|
return -1;
|
|
|
|
for(u32 i = startIndex; i < src.size - fragment.size + 1; i++){
|
|
for(u32 j = 0;; j++){
|
|
if(j == fragment.size)
|
|
return i;
|
|
if(src.data[i + j] != fragment.data[j])
|
|
break;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
i32 str_seekReverse(str src, str fragment, u32 startIndex){
|
|
if(src.size == 0 || fragment.size == 0)
|
|
return -1;
|
|
|
|
if(startIndex > src.size - 1)
|
|
startIndex = src.size - 1;
|
|
for(u32 i = startIndex; i >= fragment.size - 1; i--){
|
|
for(u32 j = 0;; j++){
|
|
if(j == fragment.size)
|
|
return i - j + 1;
|
|
if(src.data[i - j] != fragment.data[fragment.size - 1 - j])
|
|
break;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
i32 str_seekChar(str src, char c, u32 startIndex){
|
|
for(u32 i = startIndex; i < src.size; i++){
|
|
if(src.data[i] == c)
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
i32 str_seekCharReverse(str src, char c, u32 startIndex){
|
|
if(startIndex > src.size - 1)
|
|
startIndex = src.size - 1;
|
|
for(u32 i = startIndex; i != (u32)-1; i--){
|
|
if(src.data[i] == c)
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
bool str_startsWith(str src, str fragment){
|
|
if(src.size < fragment.size)
|
|
return false;
|
|
|
|
src.size = fragment.size;
|
|
return str_equals(src, fragment);
|
|
}
|
|
|
|
bool str_endsWith(str src, str fragment){
|
|
if(src.size < fragment.size)
|
|
return false;
|
|
|
|
src.data = (char*)(src.data + src.size - fragment.size);
|
|
src.size = fragment.size;
|
|
return str_equals(src, fragment);
|
|
}
|
|
|
|
u32 str_hash32(str s){
|
|
u8* ubuf = (u8*)s.data;
|
|
u32 hash=0;
|
|
for (u32 i = 0; i < s.size; i++)
|
|
hash = (hash<<6) + (hash<<16) - hash + ubuf[i];
|
|
return hash;
|
|
}
|
|
|
|
str str_toUpper(str src){
|
|
str r = str_copy(src);
|
|
for (u32 i = 0; i < r.size; i++){
|
|
if(isAlphabeticalLower(r.data[i]))
|
|
r.data[i] = r.data[i] - 'a' + 'A';
|
|
}
|
|
return r;
|
|
}
|
|
|
|
str str_toLower(str src){
|
|
str r = str_copy(src);
|
|
for (u32 i = 0; i < r.size; i++){
|
|
if(isAlphabeticalUpper(r.data[i]))
|
|
r.data[i] = r.data[i] - 'A' + 'a';
|
|
}
|
|
return r;
|
|
}
|
|
|
|
str hex_to_str(Array buf, bool uppercase){
|
|
StringBuilder sb = StringBuilder_alloc(buf.size * 2 + 1);
|
|
StringBuilder_append_memory(&sb, buf, uppercase);
|
|
return StringBuilder_getStr(&sb);
|
|
}
|