BuildSystem: Move all userpace libraries under the userspace directory
As the number of libraries is increasing, root directory starts to expand. This adds better organization for libraries
This commit is contained in:
555
userspace/libraries/LibC/string.cpp
Normal file
555
userspace/libraries/LibC/string.cpp
Normal file
@@ -0,0 +1,555 @@
|
||||
#include <errno.h>
|
||||
#include <signal.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
int errno = 0;
|
||||
|
||||
void* memccpy(void* __restrict s1, const void* __restrict s2, int c, size_t n)
|
||||
{
|
||||
unsigned char* dst = static_cast<unsigned char*>(s1);
|
||||
const unsigned char* src = static_cast<const unsigned char*>(s2);
|
||||
for (size_t i = 0; i < n; i++)
|
||||
if ((dst[i] = src[i]) == c)
|
||||
return dst + i + 1;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void* memchr(const void* s, int c, size_t n)
|
||||
{
|
||||
const unsigned char* u = static_cast<const unsigned char*>(s);
|
||||
for (size_t i = 0; i < n; i++)
|
||||
if (u[i] == c)
|
||||
return const_cast<unsigned char*>(u + i);
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
int memcmp(const void* s1, const void* s2, size_t n)
|
||||
{
|
||||
const unsigned char* a = static_cast<const unsigned char*>(s1);
|
||||
const unsigned char* b = static_cast<const unsigned char*>(s2);
|
||||
|
||||
for (size_t i = 0; i < n; i++)
|
||||
if (a[i] != b[i])
|
||||
return a[i] - b[i];
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void* memcpy(void* __restrict__ dstp, const void* __restrict__ srcp, size_t n)
|
||||
{
|
||||
unsigned char* dst = static_cast<unsigned char*>(dstp);
|
||||
const unsigned char* src = static_cast<const unsigned char*>(srcp);
|
||||
for (size_t i = 0; i < n; i++)
|
||||
dst[i] = src[i];
|
||||
return dstp;
|
||||
}
|
||||
|
||||
void* memmove(void* destp, const void* srcp, size_t n)
|
||||
{
|
||||
unsigned char* dest = static_cast<unsigned char*>(destp);
|
||||
const unsigned char* src = static_cast<const unsigned char*>(srcp);
|
||||
|
||||
if (dest < src)
|
||||
{
|
||||
for (size_t i = 0; i < n; i++)
|
||||
dest[i] = src[i];
|
||||
}
|
||||
else
|
||||
{
|
||||
for (size_t i = 1; i <= n; i++)
|
||||
dest[n - i] = src[n - i];
|
||||
}
|
||||
|
||||
return destp;
|
||||
}
|
||||
|
||||
void* memset(void* s, int c, size_t n)
|
||||
{
|
||||
unsigned char* p = static_cast<unsigned char*>(s);
|
||||
for (size_t i = 0; i < n; i++)
|
||||
p[i] = c;
|
||||
return s;
|
||||
}
|
||||
|
||||
int strcmp(const char* s1, const char* s2)
|
||||
{
|
||||
const unsigned char* u1 = (unsigned char*)s1;
|
||||
const unsigned char* u2 = (unsigned char*)s2;
|
||||
for (; *u1 && *u2; u1++, u2++)
|
||||
if (*u1 != *u2)
|
||||
break;
|
||||
return *u1 - *u2;
|
||||
}
|
||||
|
||||
int strncmp(const char* s1, const char* s2, size_t n)
|
||||
{
|
||||
const unsigned char* u1 = (unsigned char*)s1;
|
||||
const unsigned char* u2 = (unsigned char*)s2;
|
||||
for (; --n && *u1 && *u2; u1++, u2++)
|
||||
if (*u1 != *u2)
|
||||
break;
|
||||
return *u1 - *u2;
|
||||
}
|
||||
|
||||
char* stpcpy(char* __restrict__ dest, const char* __restrict__ src)
|
||||
{
|
||||
size_t i = 0;
|
||||
for (; src[i]; i++)
|
||||
dest[i] = src[i];
|
||||
dest[i] = '\0';
|
||||
return &dest[i];
|
||||
}
|
||||
|
||||
char* stpncpy(char* __restrict__ dest, const char* __restrict__ src, size_t n)
|
||||
{
|
||||
size_t i = 0;
|
||||
for (; src[i] && n; i++, n--)
|
||||
dest[i] = src[i];
|
||||
for (; n; i++, n--)
|
||||
dest[i] = '\0';
|
||||
return &dest[i];
|
||||
}
|
||||
|
||||
char* strcpy(char* __restrict__ dest, const char* __restrict__ src)
|
||||
{
|
||||
stpcpy(dest, src);
|
||||
return dest;
|
||||
}
|
||||
|
||||
char* strncpy(char* __restrict__ dest, const char* __restrict__ src, size_t n)
|
||||
{
|
||||
stpncpy(dest, src, n);
|
||||
return dest;
|
||||
}
|
||||
|
||||
char* strcat(char* __restrict__ dest, const char* __restrict__ src)
|
||||
{
|
||||
strcpy(dest + strlen(dest), src);
|
||||
return dest;
|
||||
}
|
||||
|
||||
char* strncat(char* __restrict__ dest, const char* __restrict__ src, size_t n)
|
||||
{
|
||||
strncpy(dest + strlen(dest), src, n);
|
||||
return dest;
|
||||
}
|
||||
|
||||
char* strdup(const char* str)
|
||||
{
|
||||
const size_t size = strlen(str) + 1;
|
||||
|
||||
char* new_str = (char*)malloc(size);
|
||||
if (new_str == nullptr)
|
||||
return nullptr;
|
||||
|
||||
memcpy(new_str, str, size);
|
||||
return new_str;
|
||||
}
|
||||
|
||||
char* strndup(const char* str, size_t size)
|
||||
{
|
||||
if (strlen(str) < size)
|
||||
size = strlen(str);
|
||||
size += 1;
|
||||
|
||||
char* new_str = (char*)malloc(size);
|
||||
if (new_str == nullptr)
|
||||
return nullptr;
|
||||
|
||||
memcpy(new_str, str, size);
|
||||
return new_str;
|
||||
}
|
||||
|
||||
size_t strlen(const char* str)
|
||||
{
|
||||
size_t len = 0;
|
||||
while (str[len])
|
||||
len++;
|
||||
return len;
|
||||
}
|
||||
|
||||
size_t strnlen(const char* str, size_t maxlen)
|
||||
{
|
||||
size_t len = 0;
|
||||
while (len < maxlen && str[len])
|
||||
len++;
|
||||
return len;
|
||||
}
|
||||
|
||||
char* strchr(const char* str, int c)
|
||||
{
|
||||
while (*str)
|
||||
{
|
||||
if (*str == c)
|
||||
return (char*)str;
|
||||
str++;
|
||||
}
|
||||
return (*str == c) ? (char*)str : nullptr;
|
||||
}
|
||||
|
||||
char* strchrnul(const char* str, int c)
|
||||
{
|
||||
while (*str)
|
||||
{
|
||||
if (*str == (char)c)
|
||||
return (char*)str;
|
||||
str++;
|
||||
}
|
||||
return (char*)str;
|
||||
}
|
||||
|
||||
char* strrchr(const char* str, int c)
|
||||
{
|
||||
size_t len = strlen(str);
|
||||
while (len > 0)
|
||||
{
|
||||
if (str[len] == (char)c)
|
||||
return (char*)str + len;
|
||||
len--;
|
||||
}
|
||||
return (*str == c) ? (char*)str : nullptr;
|
||||
}
|
||||
|
||||
char* strstr(const char* haystack, const char* needle)
|
||||
{
|
||||
size_t needle_len = strlen(needle);
|
||||
for (size_t i = 0; haystack[i]; i++)
|
||||
if (strncmp(haystack + i, needle, needle_len) == 0)
|
||||
return const_cast<char*>(haystack + i);
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
size_t strcspn(const char* s1, const char* s2)
|
||||
{
|
||||
size_t i = 0;
|
||||
for (; s1[i]; i++)
|
||||
for (size_t j = 0; s2[j]; j++)
|
||||
if (s1[i] == s2[j])
|
||||
return i;
|
||||
return i;
|
||||
}
|
||||
|
||||
char* strpbrk(const char* s1, const char* s2)
|
||||
{
|
||||
for (size_t i = 0; s1[i]; i++)
|
||||
for (size_t j = 0; s2[j]; j++)
|
||||
if (s1[i] == s2[j])
|
||||
return const_cast<char*>(s1 + i);
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
size_t strspn(const char* s1, const char* s2)
|
||||
{
|
||||
size_t i = 0;
|
||||
for (; s1[i]; i++)
|
||||
{
|
||||
bool found = false;
|
||||
for (size_t j = 0; s2[j] && !found; j++)
|
||||
if (s1[i] == s2[j])
|
||||
found = true;
|
||||
if (!found)
|
||||
break;
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
char* strtok(char* __restrict s, const char* __restrict sep)
|
||||
{
|
||||
static char* state = nullptr;
|
||||
return strtok_r(s, sep, &state);
|
||||
}
|
||||
|
||||
char* strtok_r(char* __restrict str, const char* __restrict sep, char** __restrict state)
|
||||
{
|
||||
if (str)
|
||||
{
|
||||
while (*str)
|
||||
{
|
||||
bool found = false;
|
||||
for (size_t i = 0; sep[i] && !found; i++)
|
||||
if (*str == sep[i])
|
||||
found = true;
|
||||
if (!found)
|
||||
break;
|
||||
str++;
|
||||
}
|
||||
|
||||
if (!*str)
|
||||
{
|
||||
*state = nullptr;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
*state = str;
|
||||
}
|
||||
|
||||
if (!*state)
|
||||
return nullptr;
|
||||
|
||||
str = *state;
|
||||
for (size_t i = 0; str[i]; i++)
|
||||
{
|
||||
for (size_t j = 0; sep[j]; j++)
|
||||
{
|
||||
if (str[i] == sep[j])
|
||||
{
|
||||
str[i] = '\0';
|
||||
*state = str + i + 1;
|
||||
return str;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
*state = nullptr;
|
||||
return str;
|
||||
}
|
||||
|
||||
char* strsignal(int signum)
|
||||
{
|
||||
static char buffer[128];
|
||||
switch (signum)
|
||||
{
|
||||
case SIGABRT: strcpy(buffer, "SIGABRT"); break;
|
||||
case SIGALRM: strcpy(buffer, "SIGALRM"); break;
|
||||
case SIGBUS: strcpy(buffer, "SIGBUS"); break;
|
||||
case SIGCHLD: strcpy(buffer, "SIGCHLD"); break;
|
||||
case SIGCONT: strcpy(buffer, "SIGCONT"); break;
|
||||
case SIGFPE: strcpy(buffer, "SIGFPE"); break;
|
||||
case SIGHUP: strcpy(buffer, "SIGHUP"); break;
|
||||
case SIGILL: strcpy(buffer, "SIGILL"); break;
|
||||
case SIGINT: strcpy(buffer, "SIGINT"); break;
|
||||
case SIGKILL: strcpy(buffer, "SIGKILL"); break;
|
||||
case SIGPIPE: strcpy(buffer, "SIGPIPE"); break;
|
||||
case SIGQUIT: strcpy(buffer, "SIGQUIT"); break;
|
||||
case SIGSEGV: strcpy(buffer, "SIGSEGV"); break;
|
||||
case SIGSTOP: strcpy(buffer, "SIGSTOP"); break;
|
||||
case SIGTERM: strcpy(buffer, "SIGTERM"); break;
|
||||
case SIGTSTP: strcpy(buffer, "SIGTSTP"); break;
|
||||
case SIGTTIN: strcpy(buffer, "SIGTTIN"); break;
|
||||
case SIGTTOU: strcpy(buffer, "SIGTTOU"); break;
|
||||
case SIGUSR1: strcpy(buffer, "SIGUSR1"); break;
|
||||
case SIGUSR2: strcpy(buffer, "SIGUSR2"); break;
|
||||
case SIGPOLL: strcpy(buffer, "SIGPOLL"); break;
|
||||
case SIGPROF: strcpy(buffer, "SIGPROF"); break;
|
||||
case SIGSYS: strcpy(buffer, "SIGSYS"); break;
|
||||
case SIGTRAP: strcpy(buffer, "SIGTRAP"); break;
|
||||
case SIGURG: strcpy(buffer, "SIGURG"); break;
|
||||
case SIGVTALRM: strcpy(buffer, "SIGVTALRM"); break;
|
||||
case SIGXCPU: strcpy(buffer, "SIGXCPU"); break;
|
||||
case SIGXFSZ: strcpy(buffer, "SIGXFSZ"); break;
|
||||
}
|
||||
return buffer;
|
||||
}
|
||||
|
||||
char* strerror(int error)
|
||||
{
|
||||
static char buffer[128];
|
||||
if (const char* str = strerrordesc_np(error))
|
||||
strcpy(buffer, str);
|
||||
else
|
||||
sprintf(buffer, "Unknown error %d", error);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
int strerror_r(int error, char* strerrbuf, size_t buflen)
|
||||
{
|
||||
const char* str = strerrordesc_np(error);
|
||||
if (!str)
|
||||
return EINVAL;
|
||||
if (strlen(str) + 1 > buflen)
|
||||
return ERANGE;
|
||||
strcpy(strerrbuf, str);
|
||||
return 0;
|
||||
}
|
||||
|
||||
const char* strerrorname_np(int error)
|
||||
{
|
||||
switch (error)
|
||||
{
|
||||
case 0: return "NOERROR";
|
||||
case E2BIG: return "E2BIG";
|
||||
case EACCES: return "EACCES";
|
||||
case EADDRINUSE: return "EADDRINUSE";
|
||||
case EADDRNOTAVAIL: return "EADDRNOTAVAIL";
|
||||
case EAFNOSUPPORT: return "EAFNOSUPPORT";
|
||||
case EAGAIN: return "EAGAIN";
|
||||
case EALREADY: return "EALREADY";
|
||||
case EBADF: return "EBADF";
|
||||
case EBADMSG: return "EBADMSG";
|
||||
case EBUSY: return "EBUSY";
|
||||
case ECANCELED: return "ECANCELED";
|
||||
case ECHILD: return "ECHILD";
|
||||
case ECONNABORTED: return "ECONNABORTED";
|
||||
case ECONNREFUSED: return "ECONNREFUSED";
|
||||
case ECONNRESET: return "ECONNRESET";
|
||||
case EDEADLK: return "EDEADLK";
|
||||
case EDESTADDRREQ: return "EDESTADDRREQ";
|
||||
case EDOM: return "EDOM";
|
||||
case EDQUOT: return "EDQUOT";
|
||||
case EEXIST: return "EEXIST";
|
||||
case EFAULT: return "EFAULT";
|
||||
case EFBIG: return "EFBIG";
|
||||
case EHOSTUNREACH: return "EHOSTUNREACH";
|
||||
case EIDRM: return "EIDRM";
|
||||
case EILSEQ: return "EILSEQ";
|
||||
case EINPROGRESS: return "EINPROGRESS";
|
||||
case EINTR: return "EINTR";
|
||||
case EINVAL: return "EINVAL";
|
||||
case EIO: return "EIO";
|
||||
case EISCONN: return "EISCONN";
|
||||
case EISDIR: return "EISDIR";
|
||||
case ELOOP: return "ELOOP";
|
||||
case EMFILE: return "EMFILE";
|
||||
case EMLINK: return "EMLINK";
|
||||
case EMSGSIZE: return "EMSGSIZE";
|
||||
case EMULTIHOP: return "EMULTIHOP";
|
||||
case ENAMETOOLONG: return "ENAMETOOLONG";
|
||||
case ENETDOWN: return "ENETDOWN";
|
||||
case ENETRESET: return "ENETRESET";
|
||||
case ENETUNREACH: return "ENETUNREACH";
|
||||
case ENFILE: return "ENFILE";
|
||||
case ENOBUFS: return "ENOBUFS";
|
||||
case ENODATA: return "ENODATA";
|
||||
case ENODEV: return "ENODEV";
|
||||
case ENOENT: return "ENOENT";
|
||||
case ENOEXEC: return "ENOEXEC";
|
||||
case ENOLCK: return "ENOLCK";
|
||||
case ENOLINK: return "ENOLINK";
|
||||
case ENOMEM: return "ENOMEM";
|
||||
case ENOMSG: return "ENOMSG";
|
||||
case ENOPROTOOPT: return "ENOPROTOOPT";
|
||||
case ENOSPC: return "ENOSPC";
|
||||
case ENOSR: return "ENOSR";
|
||||
case ENOSTR: return "ENOSTR";
|
||||
case ENOSYS: return "ENOSYS";
|
||||
case ENOTCONN: return "ENOTCONN";
|
||||
case ENOTDIR: return "ENOTDIR";
|
||||
case ENOTEMPTY: return "ENOTEMPTY";
|
||||
case ENOTRECOVERABLE: return "ENOTRECOVERABLE";
|
||||
case ENOTSOCK: return "ENOTSOCK";
|
||||
case ENOTSUP: return "ENOTSUP";
|
||||
case ENOTTY: return "ENOTTY";
|
||||
case ENXIO: return "ENXIO";
|
||||
case EOPNOTSUPP: return "EOPNOTSUPP";
|
||||
case EOVERFLOW: return "EOVERFLOW";
|
||||
case EOWNERDEAD: return "EOWNERDEAD";
|
||||
case EPERM: return "EPERM";
|
||||
case EPIPE: return "EPIPE";
|
||||
case EPROTO: return "EPROTO";
|
||||
case EPROTONOSUPPORT: return "EPROTONOSUPPORT";
|
||||
case EPROTOTYPE: return "EPROTOTYPE";
|
||||
case ERANGE: return "ERANGE";
|
||||
case EROFS: return "EROFS";
|
||||
case ESPIPE: return "ESPIPE";
|
||||
case ESRCH: return "ESRCH";
|
||||
case ESTALE: return "ESTALE";
|
||||
case ETIME: return "ETIME";
|
||||
case ETIMEDOUT: return "ETIMEDOUT";
|
||||
case ETXTBSY: return "ETXTBSY";
|
||||
case EWOULDBLOCK: return "EWOULDBLOCK";
|
||||
case EXDEV: return "EXDEV";
|
||||
case EEXISTS: return "EEXISTS";
|
||||
case ENOTBLK: return "ENOTBLK";
|
||||
case EUNKNOWN: return "EUNKNOWN";
|
||||
}
|
||||
|
||||
errno = EINVAL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
const char* strerrordesc_np(int error)
|
||||
{
|
||||
switch (error)
|
||||
{
|
||||
case 0: return "Success";
|
||||
case E2BIG: return "Argument list too long.";
|
||||
case EACCES: return "Permission denied.";
|
||||
case EADDRINUSE: return "Address in use.";
|
||||
case EADDRNOTAVAIL: return "Address not available.";
|
||||
case EAFNOSUPPORT: return "Address family not supported.";
|
||||
case EAGAIN: return "Resource unavailable, try again.";
|
||||
case EALREADY: return "Connection already in progress.";
|
||||
case EBADF: return "Bad file descriptor.";
|
||||
case EBADMSG: return "Bad message.";
|
||||
case EBUSY: return "Device or resource busy.";
|
||||
case ECANCELED: return "Operation canceled.";
|
||||
case ECHILD: return "No child processes.";
|
||||
case ECONNABORTED: return "Connection aborted.";
|
||||
case ECONNREFUSED: return "Connection refused.";
|
||||
case ECONNRESET: return "Connection reset.";
|
||||
case EDEADLK: return "Resource deadlock would occur.";
|
||||
case EDESTADDRREQ: return "Destination address required.";
|
||||
case EDOM: return "Mathematics argument out of domain of function.";
|
||||
case EDQUOT: return "Reserved.";
|
||||
case EEXIST: return "File exists.";
|
||||
case EFAULT: return "Bad address.";
|
||||
case EFBIG: return "File too large.";
|
||||
case EHOSTUNREACH: return "Host is unreachable.";
|
||||
case EIDRM: return "Identifier removed.";
|
||||
case EILSEQ: return "Illegal byte sequence.";
|
||||
case EINPROGRESS: return "Operation in progress.";
|
||||
case EINTR: return "Interrupted function.";
|
||||
case EINVAL: return "Invalid argument.";
|
||||
case EIO: return "I/O error.";
|
||||
case EISCONN: return "Socket is connected.";
|
||||
case EISDIR: return "Is a directory.";
|
||||
case ELOOP: return "Too many levels of symbolic links.";
|
||||
case EMFILE: return "File descriptor value too large.";
|
||||
case EMLINK: return "Too many links.";
|
||||
case EMSGSIZE: return "Message too large.";
|
||||
case EMULTIHOP: return "Reserved.";
|
||||
case ENAMETOOLONG: return "Filename too long.";
|
||||
case ENETDOWN: return "Network is down.";
|
||||
case ENETRESET: return "Connection aborted by network.";
|
||||
case ENETUNREACH: return "Network unreachable.";
|
||||
case ENFILE: return "Too many files open in system.";
|
||||
case ENOBUFS: return "No buffer space available.";
|
||||
case ENODATA: return "No message is available on the STREAM head read queue.";
|
||||
case ENODEV: return "No such device.";
|
||||
case ENOENT: return "No such file or directory.";
|
||||
case ENOEXEC: return "Executable file format error.";
|
||||
case ENOLCK: return "No locks available.";
|
||||
case ENOLINK: return "Reserved.";
|
||||
case ENOMEM: return "Not enough space.";
|
||||
case ENOMSG: return "No message of the desired type.";
|
||||
case ENOPROTOOPT: return "Protocol not available.";
|
||||
case ENOSPC: return "No space left on device.";
|
||||
case ENOSR: return "No STREAM resources.";
|
||||
case ENOSTR: return "Not a STREAM.";
|
||||
case ENOSYS: return "Functionality not supported.";
|
||||
case ENOTCONN: return "The socket is not connected.";
|
||||
case ENOTDIR: return "Not a directory or a symbolic link to a directory.";
|
||||
case ENOTEMPTY: return "Directory not empty.";
|
||||
case ENOTRECOVERABLE: return "State not recoverable.";
|
||||
case ENOTSOCK: return "Not a socket.";
|
||||
case ENOTSUP: return "Not supported.";
|
||||
case ENOTTY: return "Inappropriate I/O control operation.";
|
||||
case ENXIO: return "No such device or address.";
|
||||
case EOPNOTSUPP: return "Operation not supported on socket .";
|
||||
case EOVERFLOW: return "Value too large to be stored in data type.";
|
||||
case EOWNERDEAD: return "Previous owner died.";
|
||||
case EPERM: return "Operation not permitted.";
|
||||
case EPIPE: return "Broken pipe.";
|
||||
case EPROTO: return "Protocol error.";
|
||||
case EPROTONOSUPPORT: return "Protocol not supported.";
|
||||
case EPROTOTYPE: return "Protocol wrong type for socket.";
|
||||
case ERANGE: return "Result too large.";
|
||||
case EROFS: return "Read-only file system.";
|
||||
case ESPIPE: return "Invalid seek.";
|
||||
case ESRCH: return "No such process.";
|
||||
case ESTALE: return "Reserved.";
|
||||
case ETIME: return "Stream ioctl() timeout.";
|
||||
case ETIMEDOUT: return "Connection timed out.";
|
||||
case ETXTBSY: return "Text file busy.";
|
||||
case EWOULDBLOCK: return "Operation would block.";
|
||||
case EXDEV: return "Cross-device link.";
|
||||
case EEXISTS: return "File exists";
|
||||
case ENOTBLK: return "Block device required";
|
||||
case EUNKNOWN: return "Unknown error";
|
||||
}
|
||||
|
||||
errno = EINVAL;
|
||||
return nullptr;
|
||||
}
|
||||
Reference in New Issue
Block a user