SayoriOS 0.3.3

string.c
См. документацию.
1
9 #include "common.h"
10 #include "lib/string.h"
11 #include "lib/math.h"
12 //#include <emmintrin.h> // SSE functions and types
13
14 bool isalnum(char c){
15 return (c >= '0' && c <= '9') ||
16 (c >= 'a' && c <= 'z') ||
17 (c >= 'A' && c <= 'Z') ;
18 }
19
27 bool isUTF(char c) {
28 if (c == -47 || c == -48){
29 return true;
30 }
31 return false;
32 }
33
41 bool isSymbol(char c){
42 if (c == -62 || c == -106 || c == -30){
43 return true;
44 }
45 return false;
46 }
56 uint32_t SymConvert(char c, char c1, char c2){
57 uint32_t s = 0;
58 if (c == -62){
59 s = 1000;
60 } else if (c == -106){
61 s = 2000+(((int) c1)* -1);
62 } else if (c == -30){
63 s = 3000+(((int) c1)* -1);
64 }
65 return (isSymbol(c)?((((int) c)* -1)+(((int) c1)* -1)+s):((int) c));
66 }
67
77 uint32_t UTFConvert(char c, char c1){
78 return (isUTF(c)?((((int) c)* -1)+(((int) c1)* -1)):((int) c));
79 }
80
88 size_t strlen(const char *str){
89 if(str == nullptr) {
90 return 0;
91 }
92
93 size_t len = 0;
94 while (str[len] != 0){
95 len++;
96 }
97 return len;
98 }
99
107 size_t mb_strlen(const char *str){
108 size_t len = 0;
109 const size_t def = strlen(str);
110
111 for(size_t i = 0; i < def;i++){
112 if (isUTF(str[i])) continue;
113 len++;
114 }
115 return len;
116 }
117
124 size_t struntil(const char* str, const char find) {
125 size_t len = 0;
126
127 while(str[len] && str[len] != find)
128 len++;
129
130 return len;
131 }
132
140 /*void sse_memcpy(void* restrict dest, const void* restrict src, size_t size) {
141 __m128i* d = (__m128i*)dest;
142 const __m128i* s = (const __m128i*)src;
143
144 size_t num_elems = size / sizeof(__m128i);
145 const size_t remaining_bytes = size % sizeof(__m128i);
146
147 _mm_prefetch(s, _MM_HINT_NTA);
148
149 while(num_elems--) {
150 _mm_storeu_si128(d++, _mm_loadu_si128(s++));
151 }
152
153 // Copy remaining bytes
154 if (remaining_bytes > 0) {
155 char* d_char = (char*)d;
156 const char* s_char = (const char*)s;
157
158 for (size_t i = 0; i < remaining_bytes; i++) {
159 *d_char++ = *s_char++;
160 }
161 }
162
163 _mm_sfence();
164 }*/
165
173 void* memcpy(void *restrict destination, const void *restrict source, size_t n){
174 size_t *tmp_dest = (size_t *)destination;
175 size_t *tmp_src = (size_t *)source;
176 size_t len = n / sizeof(size_t);
177 size_t i = 0;
178 size_t tail = n & (sizeof(size_t) - 1);
179
180 for (; i < len; i++) {
181 *tmp_dest++ = *tmp_src++;
182 }
183
184 if(tail) {
185 char *dest = (char *)destination;
186 const char *src = (const char *)source;
187
188 for(i = n - tail; i < n; i++) {
189 dest[i] = src[i];
190 }
191 }
192
193 return destination;
194 }
195
203 void* memset(void* ptr, char value, size_t num) {
204 uint8_t* p = (uint8_t*)ptr;
205
206 for (size_t i = 0; i < num; i++) {
207 p[i] = value;
208 }
209
210 return ptr;
211 }
212
220 void* memmove(void *dest, void *src, size_t count) {
221 void * ret = dest;
222 if (dest <= src || (char*)dest >= ((char*)src + count))
223 {
224 while (count--)
225 {
226 *(char*)dest = *(char*)src;
227 dest = (char*)dest + 1;
228 src = (char*)src + 1;
229 }
230 }
231 else
232 {
233 dest = (char*)dest + count - 1;
234 src = (char*)src + count - 1;
235 while (count--)
236 {
237 *(char*)dest = *(char*)src;
238 dest = (char*)dest - 1;
239 src = (char*)src - 1;
240 }
241 }
242 return ret;
243 }
244
253 int strcmp(const char *s1, const char *s2) {
254 while (*s1 && *s1 == *s2) {
255 ++s1;
256 ++s2;
257 }
258
259 return (*s1 - *s2);
260 }
261
270 bool strcmpn(const char *str1, const char *str2){
271 return strcmp(str1, str2) == 0;
272 }
273
282 int strcpy(char* dest, const char* src){
283 int i = 0;
284
285 while (src[i] != '\0')
286 {
287 dest[i] = src[i];
288 i++;
289 }
290
291 dest[i] = '\0';
292
293 return i;
294 }
295
305 int32_t memcmp(const char *s1, const char *s2, size_t n){
306 unsigned char u1, u2;
307
308 for (; n--; s1++, s2++){
309 u1 = *(unsigned char *)s1;
310 u2 = *(unsigned char *)s2;
311 if (u1 != u2){
312 return (u1 - u2);
313 }
314 }
315 return 0;
316 }
325 size_t str_bksp(char *str, char c){
326 size_t i = strlen(str);
327 i--;
328 while (i){
329 i--;
330 if (str[i] == c){
331 str[i + 1] = 0;
332 return 1;
333 }
334 }
335 return 0;
336 }
345 char *strpbrk(const char *s, const char *accept){
346 while (*s != '\0'){
347 const char *a = accept;
348 while (*a != '\0'){
349 if (*a++ == *s){
350 return (char *)s;
351 }
352 }
353 ++s;
354 }
355 return nullptr;
356 }
357
366 size_t strspn(const char *s, const char *accept){
367 const char *p;
368 const char *a;
369 size_t count = 0;
370
371 for (p = s; *p != '\0'; ++p){
372 for (a = accept; *a != '\0'; ++a){
373 if (*p == *a){
374 break;
375 }
376 }
377 if (*a == '\0') {
378 return count;
379 }
380
381 ++count;
382 }
383 return count;
384 }
385
394 int32_t strncmp(const char *s1, const char *s2, size_t num){
395 for (size_t i = 0; i < num; i++){
396 if (s1[i] != s2[i]){
397 return 1;
398 }
399 }
400 return 0;
401 }
402
411 char *strtok(char *s, const char *delim){
412 static char *olds = nullptr;
413 char *token;
414
415 if (s == nullptr){
416 s = olds;
417 }
418
419 s += strspn(s, delim);
420
421 if (*s == '\0'){
422 olds = s;
423 return nullptr;
424 }
425
426 token = s;
427 s = strpbrk(token, delim);
428 if (s == nullptr){
429 olds = token;
430 }
431 else{
432 *s = '\0';
433 olds = s + 1;
434 }
435 return token;
436 }
437
447 char *strncpy(char *dest, const char *src, size_t n) {
448 for (size_t i = 0; i < n && src[i] != '\0'; i++) {
449 dest[i] = src[i];
450 }
451
452 return dest;
453 }
454
463 char* strcat(char* destination, const char* source) {
464 char* ptr = destination;
465
466 // Находим конец строки в destination
467 while (*ptr != '\0') {
468 ptr++;
469 }
470
471 // Копируем символы из source в конец destination
472 while (*source != '\0') {
473 *ptr = *source;
474 ptr++;
475 source++;
476 }
477
478 // Добавляем завершающий нулевой символ в destination
479 *ptr = '\0';
480
481 return destination;
482 }
483
492 void substr(char* restrict dest, const char* restrict source, int from, int length){
493 strncpy(dest, source + from, length);
494 dest[length] = 0;
495 }
496
505 char *strchr(const char *_s, char _c){
506 while (*_s != (char)_c){
507 if (!*_s++){
508 return 0;
509 }
510 }
511 return (char *)_s;
512 }
513
519 void strtolower(char* as){
520 while(*as != 0)
521 {
522 if(*as >= 'A' && *as <= 'Z')
523 *as += ('a' - 'A');
524 as++;
525 }
526 }
527
533 void strtoupper(char* as){
534 while(*as != 0)
535 {
536 if(*as >= 'a' && *as <= 'z')
537 *as -= ('a' - 'A');
538 as++;
539 }
540 }
541
549 bool isNumber(const char* c) {
550 for(uint32_t i = 0, len = strlen(c); i < len; i++){
551 if (!(c[i] >= '0' && c[i] <= '9')) {
552 return false;
553 }
554 }
555 return true;
556 }
557
565 uint32_t atoi(const char s[]){
566 int i = 0, n = 0;
567 bool minus = *s == '-';
568
569 if(minus)
570 i++;
571
572 for (; s[i] >= '0' && s[i] <= '9'; ++i)
573 n = (n * 10) + (s[i] - '0');
574
575 n *= minus ? -1 : 1;
576
577 return n;
578 }
579
580 size_t htoi(const char* hex) {
581 const char* p = hex;
582 size_t result = 0;
583
584 while (*p != '\0') {
585 if (*p >= '0' && *p <= '9') {
586 result = (result << 4) + (*p - '0');
587 } else if (*p >= 'A' && *p <= 'F') {
588 result = (result << 4) + (*p - 'A' + 10);
589 } else if (*p >= 'a' && *p <= 'f') {
590 result = (result << 4) + (*p - 'a' + 10);
591 } else {
592 break;
593 }
594 p++;
595 }
596
597 return result;
598 }
599
605 void strver(char *str) {
606 size_t j = strlen(str) - 1;
607
608 for (int32_t i = 0; i < j; i++) {
609 char c = str[i];
610 str[i] = str[j];
611 str[j] = c;
612 j--;
613 }
614 }
615
623 size_t itoa(int32_t n, char *buffer) {
624 char const digits[] = "0123456789";
625 char* p = buffer;
626
627 if (n < 0){
628 *p++ = '-';
629 n = -n;
630 }
631
632 int s = n;
633
634 do {
635 ++p;
636 s = s / 10;
637 } while(s);
638
639 *p = '\0';
640
641 do {
642 *--p = digits[n % 10];
643 n = n / 10;
644 } while(n);
645
646 return strlen(buffer);
647 }
648
649 // Unsigned int to charptr
650 // Bufferless variant: That's ideal!
651 size_t itou(size_t n, char *buffer) {
652 char* p = buffer;
653
654 size_t s = n;
655
656 do {
657 ++p;
658 s = s / 10;
659 } while(s);
660
661 *p = '\0';
662
663 do {
664 *--p = '0' + (n % 10);
665 n = n / 10;
666 } while(n);
667
668 return strlen(buffer);
669 }
670
671 size_t itoh(size_t i, char *buffer) {
672 const unsigned char hex[16] = "0123456789ABCDEF";
673 uint32_t n, d = 0x10000000;
674 char* p = buffer;
675
676 while ((i / d == 0) && (d >= 0x10)) {
677 d /= 0x10;
678 }
679 n = i;
680
681 while (d >= 0xF) {
682 *p++ = hex[n / d];
683 n = n % d;
684 d /= 0x10;
685 }
686
687 *p++ = hex[n];
688 *p = 0;
689
690 return strlen(buffer);
691 }
692
693
694 int dcmpstr( const char *s1, const char *s2 )
695 {
696 while ( *s1 && *s1 == *s2 ) ++s1, ++s2;
697
698 return ( ( unsigned char )*s1 > ( unsigned char )*s2 ) -
699 ( ( unsigned char )*s1 < ( unsigned char )*s2 );
700 }
701
702 char digit_count(uint64_t num) {
703 if(num == 0)
704 return 1;
705
706 char count = 0;
707 while(num > 0) {
708 num /= 10;
709 count++;
710 }
711 return count;
712 }
713
714 char hex_count(size_t num) {
715 if(num == 0)
716 return 1;
717
718 char _ = 0;
719 while(num > 0) {
720 num /= 16;
721 _++;
722 }
723 return _;
724 }
725
726 bool isnumberstr(char* a) {
727 while(*a) {
728 if(!isdigit(*a)) {
729 return false;
730 }
731
732 a++;
733 }
734
735 return true;
736 }
737
746 size_t strcount(const char* string, char character) {
747 size_t count = 0;
748
749 while(*string++) {
750 if(*string == character)
751 count++;
752 }
753
754 return count;
755 }
756
757 char* strstr(const char* haystack, const char* needle) {
758 if (*needle == '\0') {
759 return (char*) haystack;
760 }
761
762 while (*haystack) {
763 const char* h = haystack;
764 const char* n = needle;
765
766 while (*h && *n && (*h == *n)) {
767 h++;
768 n++;
769 }
770
771 if (*n == '\0') {
772 return (char*) haystack;
773 }
774
775 haystack++;
776 }
777
778 return NULL;
779 }
780
781
782 double strtod(const char* str, char** endptr) {
783 double result = 0.0;
784 // bool negative = false;
785 int exponent = 0;
786 int sign = 1;
787
788 // Пропускаем начальные пробелы
789 while (*str == ' ') {
790 str++;
791 }
792
793 // Определяем знак числа
794 if (*str == '-' || *str == '+') {
795 sign = (*str++ == '-') ? -1 : 1;
796 }
797
798 // Парсим целую часть числа
799 while (*str >= '0' && *str <= '9') {
800 result = result * 10 + (*str++ - '0');
801 }
802
803 // Парсим дробную часть числа
804 if (*str == '.') {
805 double fraction = 1.0;
806 str++;
807 while (*str >= '0' && *str <= '9') {
808 result = result + (double)(*str - '0') / (fraction *= 10.0);
809 str++;
810 }
811 }
812
813 // Парсим порядок числа
814 if (*str == 'e' || *str == 'E') {
815 str++;
816 // Определяем знак порядка числа
817 if (*str == '-' || *str == '+') {
818 exponent = (*str++ == '-') ? -1 : 1;
819 }
820 // Парсим значение порядка
821 int temp_exponent = 0;
822 while (*str >= '0' && *str <= '9') {
823 temp_exponent = temp_exponent * 10 + (*str++ - '0');
824 }
825 exponent *= temp_exponent;
826 }
827
828 result *= sign;
829
830 if (endptr != NULL) {
831 *endptr = (char*)str;
832 }
833
834 return result * pow(10, exponent);
835 }
836
837
838
839
840 unsigned long strtoul(const char* str, char** endptr, int base) {
841 unsigned long result = 0;
842 int i = 0;
843
844 // Пропускаем начальные пробелы
845 while (str[i] == ' ') {
846 i++;
847 }
848
849 // Преобразуем основание base в случае необходимости
850 if (base == 0) {
851 if (str[i] == '0') {
852 if (str[i + 1] == 'x' || str[i + 1] == 'X') {
853 base = 16;
854 i += 2;
855 } else {
856 base = 8;
857 i++;
858 }
859 } else {
860 base = 10;
861 }
862 }
863
864 // Обрабатываем число
865 while (str[i] != '\0') {
866 int digit;
867 if (str[i] >= '0' && str[i] <= '9') {
868 digit = str[i] - '0';
869 } else if (str[i] >= 'a' && str[i] <= 'z') {
870 digit = str[i] - 'a' + 10;
871 } else if (str[i] >= 'A' && str[i] <= 'Z') {
872 digit = str[i] - 'A' + 10;
873 } else {
874 break;
875 }
876 if (digit < base) {
877 result = result * base + digit;
878 i++;
879 } else {
880 break;
881 }
882 }
883
884 // Устанавливаем значение endptr
885 if (endptr != NULL) {
886 *endptr = (char*)(str + i);
887 }
888
889 return result;
890 }
common.h
Основные определения ядра
strlen
size_t strlen(const char *str)
Возращает длину строки
Definition: string.c:88
strpbrk
char * strpbrk(const char *s, const char *accept)
???
Definition: string.c:345
strcmp
int strcmp(const char *s1, const char *s2)
Сравнение строк
Definition: string.c:253
atoi
uint32_t atoi(const char s[])
Превращает строку в число
Definition: string.c:565
strcmpn
bool strcmpn(const char *str1, const char *str2)
Сравнение строк
Definition: string.c:270
strtolower
void strtolower(char *as)
Перевод строки в нижний регистр
Definition: string.c:519
SymConvert
uint32_t SymConvert(char c, char c1, char c2)
Возращает индекс символа
Definition: string.c:56
strncmp
int32_t strncmp(const char *s1, const char *s2, size_t num)
Сравнение строк с ограничением количества сравниваемых символов
Definition: string.c:394
strcount
size_t strcount(const char *string, char character)
Посчитать количество символов character в строке string
Definition: string.c:746
strncpy
char * strncpy(char *dest, const char *src, size_t n)
Копирование строк c ограничением длины
Definition: string.c:447
strchr
char * strchr(const char *_s, char _c)
Поиск первого вхождения символа в строку
Definition: string.c:505
isNumber
bool isNumber(const char *c)
Проверяет, является ли строка числом
Definition: string.c:549
strver
void strver(char *str)
Переворачивает строку задом наперед
Definition: string.c:605
memset
void * memset(void *ptr, char value, size_t num)
Заполнение массива указанными символами
Definition: string.c:203
UTFConvert
uint32_t UTFConvert(char c, char c1)
Возращает индекс символа
Definition: string.c:77
strtok
char * strtok(char *s, const char *delim)
Разбиение строки на части по указанному разделителю
Definition: string.c:411
mb_strlen
size_t mb_strlen(const char *str)
Возращает длину строки с учетом UTF-8.
Definition: string.c:107
memcpy
void * memcpy(void *restrict destination, const void *restrict source, size_t n)
Копирование непересекающихся массивов используя SSE.
Definition: string.c:173
isSymbol
bool isSymbol(char c)
Проверяет, является ли специальным символом
Definition: string.c:41
strspn
size_t strspn(const char *s, const char *accept)
Определение максимальной длины участка строки, содержащего только указанные символы
Definition: string.c:366
substr
void substr(char *restrict dest, const char *restrict source, int from, int length)
Вырезает и возвращает подстроку из строки
Definition: string.c:492
isUTF
bool isUTF(char c)
Проверяет, является ли символ формата UTF-8.
Definition: string.c:27
memcmp
int32_t memcmp(const char *s1, const char *s2, size_t n)
Сравнение массивов
Definition: string.c:305
strtoupper
void strtoupper(char *as)
Перевод строки в верхний регистр
Definition: string.c:533
strcpy
int strcpy(char *dest, const char *src)
Копирование строк
Definition: string.c:282
memmove
void * memmove(void *dest, void *src, size_t count)
Копирование массивов (в том числе пересекающихся)
Definition: string.c:220
itoa
size_t itoa(int32_t n, char *buffer)
Конвертируем число в символы
Definition: string.c:623
struntil
size_t struntil(const char *str, const char find)
Возвращает индекс символа в строке
Definition: string.c:124
str_bksp
size_t str_bksp(char *str, char c)
???
Definition: string.c:325
strcat
char * strcat(char *destination, const char *source)
Объединение строк
Definition: string.c:463