rt-thread-official/components/libc/compilers/common/cstring.c

224 lines
3.9 KiB
C

/*
* Copyright (c) 2006-2022, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2022-01-12 Meco Man The first version.
*/
#include "posix/string.h"
#include <ctype.h>
#include <rtthread.h>
#include <stdlib.h>
/**
* @brief erases the data in the n bytes of the memory starting at the
* location pointed to by s, by writing zeros (bytes containing '\0') to that area.
*
* @note The bzero() function is deprecated (marked as LEGACY in POSIX. 1-2001).
*/
void bzero(void* s, size_t n)
{
rt_memset(s, 0, n);
}
void bcopy(const void* src, void* dest, size_t n)
{
rt_memcpy(dest, src, n);
}
int bcmp(const void* s1, const void* s2, size_t n)
{
return rt_memcmp(s1, s2, n);
}
void explicit_bzero(void* s, size_t n)
{
volatile char* vs = (volatile char*)s;
while (n)
{
*vs++ = 0;
n--;
}
}
char* index(const char* s, int c)
{
return strchr(s, c);
}
char* rindex(const char* s, int c)
{
return strrchr(s, c);
}
int ffs(int i)
{
int bit;
if (0 == i)
return 0;
for (bit = 1; !(i & 1); ++bit)
i >>= 1;
return bit;
}
int ffsl(long i)
{
int bit;
if (0 == i)
return 0;
for (bit = 1; !(i & 1); ++bit)
i >>= 1;
return bit;
}
int ffsll(long long i)
{
int bit;
if (0 == i)
return 0;
for (bit = 1; !(i & 1); ++bit)
i >>= 1;
return bit;
}
/**
* @brief The memchr() function scans the initial n bytes of the memory area pointed to
* by s for the first instance of c. Both c and the bytes of the memory area
* pointed to by s are interpreted as unsigned char.
*
* @note This function is GNU extension, available since glibc 2.1.91.
*/
void* memrchr(const void* ptr, int ch, size_t pos)
{
char* end = (char*)ptr + pos - 1;
while (end != ptr)
{
if (*end == ch)
return end;
end--;
}
return (*end == ch) ? (end) : (NULL);
}
size_t strnlen(const char *s, size_t maxlen)
{
const char *sc;
for (sc = s; maxlen != 0 && *sc != '\0'; maxlen--, ++sc);
return sc - s;
}
char* strchrnul(const char* s, int c)
{
while (*s != '\0' && *s != c)
s++;
return (char*)s;
}
int strcasecmp(const char* s1, const char* s2)
{
const unsigned char* u1 = (const unsigned char*)s1;
const unsigned char* u2 = (const unsigned char*)s2;
int result;
while ((result = tolower(*u1) - tolower(*u2)) == 0 && *u1 != 0)
{
u1++;
u2++;
}
return result;
}
int strncasecmp(const char* s1, const char* s2, size_t n)
{
const unsigned char* u1 = (const unsigned char*)s1;
const unsigned char* u2 = (const unsigned char*)s2;
int result;
for (; n != 0; n--)
{
result = tolower(*u1) - tolower(*u2);
if (result)
return result;
if (*u1 == 0)
return 0;
u1++;
u2++;
}
return 0;
}
char *strdup(const char *s)
{
char *news = (char *)malloc(strlen(s) + 1);
if (news)
{
strcpy(news, s);
}
return news;
}
char *strndup(const char *s, size_t size)
{
size_t nsize = strnlen(s, size);
char *news = (char *)malloc(nsize + 1);
if (news)
{
rt_memcpy(news, s, nsize);
news[nsize] = '\0';
}
return news;
}
rt_weak char *strtok_r(char *str, const char *delim, char **saveptr)
{
char *pbegin;
char *pend = NULL;
if (str)
{
pbegin = str;
}
else if (saveptr && *saveptr)
{
pbegin = *saveptr;
}
else
{
return NULL;
}
for (;*pbegin && strchr(delim, *pbegin) != NULL; pbegin++);
if (!*pbegin)
{
return NULL;
}
for (pend = pbegin + 1; *pend && strchr(delim, *pend) == NULL; pend++);
if (*pend)
{
*pend++ = '\0';
}
if (saveptr)
{
*saveptr = pend;
}
return pbegin;
}