diff --git a/BAN/include/BAN/Assert.h b/BAN/include/BAN/Assert.h index 089e93d4a5..e24761d051 100644 --- a/BAN/include/BAN/Assert.h +++ b/BAN/include/BAN/Assert.h @@ -2,10 +2,10 @@ #if defined(__is_kernel) #include - #define ASSERT(cond) do { if (!(cond)) Kernel::panic("ASSERT("#cond") failed"); } while(false) + #define ASSERT(cond) do { if (!(cond)) Kernel::panic("ASSERT("#cond") failed"); } while (false) #define ASSERT_NOT_REACHED() Kernel::panic("ASSERT_NOT_REACHED() failed") #else #include #define ASSERT(cond) assert((cond) && "ASSERT("#cond") failed") - #define ASSERT_NOT_REACHED() assert(false && "ASSERT_NOT_REACHED() failed") + #define ASSERT_NOT_REACHED() do { assert(false && "ASSERT_NOT_REACHED() failed"); __builtin_unreachable(); } while (false) #endif \ No newline at end of file diff --git a/kernel/include/kernel/Syscall.h b/kernel/include/kernel/Syscall.h index 1dba6d1c89..2f53a5475c 100644 --- a/kernel/include/kernel/Syscall.h +++ b/kernel/include/kernel/Syscall.h @@ -1,20 +1,8 @@ #pragma once -#define SYS_EXIT 1 -#define SYS_READ 2 -#define SYS_WRITE 3 -#define SYS_TERMID 4 -#define SYS_CLOSE 5 -#define SYS_OPEN 6 -#define SYS_ALLOC 7 -#define SYS_FREE 8 -#define SYS_SEEK 9 -#define SYS_TELL 10 -#define SYS_GET_TERMIOS 11 -#define SYS_SET_TERMIOS 12 - #include #include +#include namespace Kernel { diff --git a/libc/CMakeLists.txt b/libc/CMakeLists.txt index 5fd9faba95..0483ae4a6a 100644 --- a/libc/CMakeLists.txt +++ b/libc/CMakeLists.txt @@ -3,6 +3,7 @@ cmake_minimum_required(VERSION 3.26) project(libc CXX ASM) set(LIBC_SOURCES + assert.cpp ctype.cpp fcntl.cpp printf_impl.cpp diff --git a/libc/assert.cpp b/libc/assert.cpp new file mode 100644 index 0000000000..db97182d38 --- /dev/null +++ b/libc/assert.cpp @@ -0,0 +1,9 @@ +#include +#include +#include + +void __assert_fail(const char* expr, const char* file, int line, const char* func) +{ + fprintf(stderr, "assert: %s:%d: %s: Assertion '%s' failed.\n", file, line, func, expr); + abort(); +} diff --git a/libc/include/aio.h b/libc/include/aio.h new file mode 100644 index 0000000000..cb46113dfb --- /dev/null +++ b/libc/include/aio.h @@ -0,0 +1,51 @@ +#ifndef _AIO_H +#define _AIO_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/aio.h.html + +#include + +__BEGIN_DECLS + +#include +#include +#include + +#define __need_off_t +#define __need_pthread_attr_t +#define __need_size_t +#define __need_ssize_t +#include + +struct aiocb +{ + int aio_fildes; /* File descriptor. */ + off_t aio_offset; /* File offset. */ + volatile void* aio_buf; /* Location of buffer. */ + size_t aio_nbytes; /* Length of transfer. */ + int aio_reqprio; /* Request priority offset. */ + struct sigevent aio_sigevent; /* Signal number and value. */ + int aio_lio_opcode; /* Operation to be performed. */ +}; + +#define AIO_ALLDONE 1 +#define AIO_CANCELLED 2 +#define AIO_NOTCANCELLED 3 +#define LIO_NOP 4 +#define LIO_NOWAIT 5 +#define LIO_READ 6 +#define LIO_WAIT 7 +#define LIO_WRITE 8 + +int aio_cancel(int fildes, struct aiocb* aiocbp); +int aio_error(const struct aiocb* aiocbp); +int aio_fsync(int op, struct aiocb* aiocbp); +int aio_read(struct aiocb* aiocbp); +ssize_t aio_return(struct aiocb* aiocbp); +int aio_suspend(const struct aiocb* const list[], int nent, const struct timespec* timeout); +int aio_write(struct aiocb* aiocbp); +int lio_listio(int mode, struct aiocb* __restrict const list[__restrict], int nent, struct sigevent* __restrict sig); + +__END_DECLS + +#endif diff --git a/libc/include/arpa/inet.h b/libc/include/arpa/inet.h new file mode 100644 index 0000000000..b4bd04d8f1 --- /dev/null +++ b/libc/include/arpa/inet.h @@ -0,0 +1,25 @@ +#ifndef _INET_H +#define _INET_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/arpa_inet.h.html + +#include + +__BEGIN_DECLS + +#include +#include + +uint32_t htonl(uint32_t); +uint16_t htons(uint16_t); +uint32_t ntohl(uint32_t); +uint16_t ntohs(uint16_t); + +in_addr_t inet_addr(const char* cp); +char* inet_ntoa(struct in_addr in); +const char* inet_ntop(int af, const void* __restrict src, char* __restrict dst, socklen_t size); +int inet_pton(int af, const char* __restrict src, void* __restrict dst); + +__END_DECLS + +#endif diff --git a/libc/include/assert.h b/libc/include/assert.h index bcacd8d31b..ae9059bc78 100644 --- a/libc/include/assert.h +++ b/libc/include/assert.h @@ -1,5 +1,20 @@ -#pragma once +#ifndef __ASSERT_H +#define _ASSERT_H 1 -#include +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/assert.h.html -#define assert(expr) { if (!(expr)) abort(); } +#include + +#ifdef NDEBUG + #define assert(ignore)((void) 0) +#else + #define assert(expr) do { if (!(expr)) __assert_fail(#expr, __FILE__, __LINE__, __func__); } while (0) +#endif + +__BEGIN_DECLS + +void __assert_fail(const char*, const char*, int, const char*); + +__END_DECLS + +#endif diff --git a/libc/include/printf_impl.h b/libc/include/bits/printf.h similarity index 76% rename from libc/include/printf_impl.h rename to libc/include/bits/printf.h index feaeea0327..e7fde7491a 100644 --- a/libc/include/printf_impl.h +++ b/libc/include/bits/printf.h @@ -1,11 +1,15 @@ -#pragma once +#ifndef _BITS_PRINTF_H +#define _BITS_PRINTF_H 1 #include -#include -#include __BEGIN_DECLS +#include +#include + int printf_impl(const char* format, va_list arguments, int (*putc_fun)(int, void*), void* data); __END_DECLS + +#endif diff --git a/libc/include/bits/pthread_types.h b/libc/include/bits/pthread_types.h new file mode 100644 index 0000000000..44242090f8 --- /dev/null +++ b/libc/include/bits/pthread_types.h @@ -0,0 +1,85 @@ +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_types.h.html + +#include + +__BEGIN_DECLS + +#if !defined(__pthread_attr_t_defined) && (defined(__need_all_types) || defined(__need_pthread_attr_t)) + #define __pthread_attr_t_defined 1 + typedef int pthread_attr_t; +#endif +#undef __need_pthread_attr_t + +#if !defined(__pthread_barrier_t_defined) && (defined(__need_all_types) || defined(__need_pthread_barrier_t)) + #define __pthread_barrier_t_defined 1 + typedef int pthread_barrier_t; +#endif +#undef __need_pthread_barrier_t + +#if !defined(__pthread_barrierattr_t_defined) && (defined(__need_all_types) || defined(__need_pthread_barrierattr_t)) + #define __pthread_barrierattr_t_defined 1 + typedef int pthread_barrierattr_t; +#endif +#undef __need_pthread_barrierattr_t + +#if !defined(__pthread_cond_t_defined) && (defined(__need_all_types) || defined(__need_pthread_cond_t)) + #define __pthread_cond_t_defined 1 + typedef int pthread_cond_t; +#endif +#undef __need_pthread_cond_t + +#if !defined(__pthread_condattr_t_defined) && (defined(__need_all_types) || defined(__need_pthread_condattr_t)) + #define __pthread_condattr_t_defined 1 + typedef int pthread_condattr_t; +#endif +#undef __need_pthread_condattr_t + +#if !defined(__pthread_key_t_defined) && (defined(__need_all_types) || defined(__need_pthread_key_t)) + #define __pthread_key_t_defined 1 + typedef int pthread_key_t; +#endif +#undef __need_pthread_key_t + +#if !defined(__pthread_mutex_t_defined) && (defined(__need_all_types) || defined(__need_pthread_mutex_t)) + #define __pthread_mutex_t_defined 1 + typedef int pthread_mutex_t; +#endif +#undef __need_pthread_mutex_t + +#if !defined(__pthread_mutexattr_t_defined) && (defined(__need_all_types) || defined(__need_pthread_mutexattr_t)) + #define __pthread_mutexattr_t_defined 1 + typedef int pthread_mutexattr_t; +#endif +#undef __need_pthread_mutexattr_t + +#if !defined(__pthread_once_t_defined) && (defined(__need_all_types) || defined(__need_pthread_once_t)) + #define __pthread_once_t_defined 1 + typedef int pthread_once_t; +#endif +#undef __need_pthread_once_t + +#if !defined(__pthread_rwlock_t_defined) && (defined(__need_all_types) || defined(__need_pthread_rwlock_t)) + #define __pthread_rwlock_t_defined 1 + typedef int pthread_rwlock_t; +#endif +#undef __need_pthread_rwlock_t + +#if !defined(__pthread_rwlockattr_t_defined) && (defined(__need_all_types) || defined(__need_pthread_rwlockattr_t)) + #define __pthread_rwlockattr_t_defined 1 + typedef int pthread_rwlockattr_t; +#endif +#undef __need_pthread_rwlockattr_t + +#if !defined(__pthread_spinlock_t_defined) && (defined(__need_all_types) || defined(__need_pthread_spinlock_t)) + #define __pthread_spinlock_t_defined 1 + typedef int pthread_spinlock_t; +#endif +#undef __need_pthread_spinlock_t + +#if !defined(__pthread_t_defined) && (defined(__need_all_types) || defined(__need_pthread_t)) + #define __pthread_t_defined 1 + typedef int pthread_t; +#endif +#undef __need_pthread_t + +__END_DECLS diff --git a/libc/include/bits/types/FILE.h b/libc/include/bits/types/FILE.h new file mode 100644 index 0000000000..b161a74e5b --- /dev/null +++ b/libc/include/bits/types/FILE.h @@ -0,0 +1,18 @@ +#ifndef _BITS_TYPES_FILE_H +#define _BITS_TYPES_FILE_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/stdio.h.html + +#include + +__BEGIN_DECLS + +#ifndef __FILE_defined + #define __FILE_defined 1 + struct FILE; + typedef struct FILE FILE; +#endif + +__END_DECLS + +#endif diff --git a/libc/include/bits/types/locale_t.h b/libc/include/bits/types/locale_t.h new file mode 100644 index 0000000000..a19779c0d6 --- /dev/null +++ b/libc/include/bits/types/locale_t.h @@ -0,0 +1,17 @@ +#ifndef _BITS_LOCALE_T_H +#define _BITS_LOCALE_T_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/locale.h.html + +#include + +__BEGIN_DECLS + +#ifndef __locale_t_defined + #define __locale_t_defined 1 + typedef int locale_t; +#endif + +__END_DECLS + +#endif diff --git a/libc/include/bits/types/sa_family_t.h b/libc/include/bits/types/sa_family_t.h new file mode 100644 index 0000000000..2700bf1b19 --- /dev/null +++ b/libc/include/bits/types/sa_family_t.h @@ -0,0 +1,17 @@ +#ifndef _BITS_TYPES_SA_FAMILY_T_H +#define _BITS_TYPES_SA_FAMILY_T_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_select.h.html + +#include + +__BEGIN_DECLS + +#ifndef __sa_family_t_defined + #define __sa_family_t_defined 1 + typedef unsigned int sa_family_t; +#endif + +__END_DECLS + +#endif diff --git a/libc/include/complex.h b/libc/include/complex.h new file mode 100644 index 0000000000..c9a9308906 --- /dev/null +++ b/libc/include/complex.h @@ -0,0 +1,83 @@ +#ifndef _COMPLEX_H +#define _COMPLEX_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/complex.h.html + +#include + +#define complex _Complex +#define _Complex_I (__extension__ 1.0iF) +#define I _Complex_I + +__BEGIN_DECLS + +double cabs(double complex); +float cabsf(float complex); +long double cabsl(long double complex); +double complex cacos(double complex); +float complex cacosf(float complex); +double complex cacosh(double complex); +float complex cacoshf(float complex); +long double complex cacoshl(long double complex); +long double complex cacosl(long double complex); +double carg(double complex); +float cargf(float complex); +long double cargl(long double complex); +double complex casin(double complex); +float complex casinf(float complex); +double complex casinh(double complex); +float complex casinhf(float complex); +long double complex casinhl(long double complex); +long double complex casinl(long double complex); +double complex catan(double complex); +float complex catanf(float complex); +double complex catanh(double complex); +float complex catanhf(float complex); +long double complex catanhl(long double complex); +long double complex catanl(long double complex); +double complex ccos(double complex); +float complex ccosf(float complex); +double complex ccosh(double complex); +float complex ccoshf(float complex); +long double complex ccoshl(long double complex); +long double complex ccosl(long double complex); +double complex cexp(double complex); +float complex cexpf(float complex); +long double complex cexpl(long double complex); +double cimag(double complex); +float cimagf(float complex); +long double cimagl(long double complex); +double complex clog(double complex); +float complex clogf(float complex); +long double complex clogl(long double complex); +double complex conj(double complex); +float complex conjf(float complex); +long double complex conjl(long double complex); +double complex cpow(double complex, double complex); +float complex cpowf(float complex, float complex); +long double complex cpowl(long double complex, long double complex); +double complex cproj(double complex); +float complex cprojf(float complex); +long double complex cprojl(long double complex); +double creal(double complex); +float crealf(float complex); +long double creall(long double complex); +double complex csin(double complex); +float complex csinf(float complex); +double complex csinh(double complex); +float complex csinhf(float complex); +long double complex csinhl(long double complex); +long double complex csinl(long double complex); +double complex csqrt(double complex); +float complex csqrtf(float complex); +long double complex csqrtl(long double complex); +double complex ctan(double complex); +float complex ctanf(float complex); +double complex ctanh(double complex); +float complex ctanhf(float complex); +long double complex ctanhl(long double complex); +long double complex ctanl(long double complex); + +__END_DECLS + +#endif diff --git a/libc/include/cpio.h b/libc/include/cpio.h new file mode 100644 index 0000000000..3b8ba63d9c --- /dev/null +++ b/libc/include/cpio.h @@ -0,0 +1,35 @@ +#ifndef _CPIO_H +#define _CPIO_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/cpio.h.html + +#include + +__BEGIN_DECLS + +#define C_IRUSR 0000400 +#define C_IWUSR 0000200 +#define C_IXUSR 0000100 +#define C_IRGRP 0000040 +#define C_IWGRP 0000020 +#define C_IXGRP 0000010 +#define C_IROTH 0000004 +#define C_IWOTH 0000002 +#define C_IXOTH 0000001 +#define C_ISUID 0004000 +#define C_ISGID 0002000 +#define C_ISVTX 0001000 +#define C_ISDIR 0040000 +#define C_ISFIFO 0010000 +#define C_ISREG 0100000 +#define C_ISBLK 0060000 +#define C_ISCHR 0020000 +#define C_ISCTG 0110000 +#define C_ISLNK 0120000 +#define C_ISSOCK 0140000 + +#define MAGIC "070707" + +__END_DECLS + +#endif diff --git a/libc/include/ctype.h b/libc/include/ctype.h index e569165cba..b7ea45c1eb 100644 --- a/libc/include/ctype.h +++ b/libc/include/ctype.h @@ -1,24 +1,48 @@ -#pragma once +#ifndef _CTYPE_H +#define _CTYPE_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/ctype.h.html #include +#include + __BEGIN_DECLS int isalnum(int); +int isalnum_l(int, locale_t); int isalpha(int); +int isalpha_l(int, locale_t); int isascii(int); int isblank(int); +int isblank_l(int, locale_t); int iscntrl(int); +int iscntrl_l(int, locale_t); int isdigit(int); +int isdigit_l(int, locale_t); int isgraph(int); +int isgraph_l(int, locale_t); int islower(int); +int islower_l(int, locale_t); int isprint(int); +int isprint_l(int, locale_t); int ispunct(int); +int ispunct_l(int, locale_t); int isspace(int); +int isspace_l(int, locale_t); int isupper(int); +int isupper_l(int, locale_t); int isxdigit(int); - -int toupper(int); +int isxdigit_l(int, locale_t); +int toascii(int); int tolower(int); +int tolower_l(int, locale_t); +int toupper(int); +int toupper_l(int, locale_t); -__END_DECLS \ No newline at end of file +#define _toupper(val) ::toupper(val) +#define _tolower(val) ::tolower(val) + +__END_DECLS + +#endif diff --git a/libc/include/dirent.h b/libc/include/dirent.h index 94e742ac18..2711e1ea42 100644 --- a/libc/include/dirent.h +++ b/libc/include/dirent.h @@ -1,27 +1,36 @@ -#pragma once +#ifndef _DIRENT_H +#define _DIRENT_H 1 -#include +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/dirent.h.html + +#include __BEGIN_DECLS +#define __need_ino_t +#include + struct DIR; +typedef DIR DIR; struct dirent { - ino_t d_ino; - char d_name[]; + ino_t d_ino; /* File serial number. */ + char d_name[]; /* Filename string of entry. */ }; -int alphasort(const struct dirent**, const struct dirent**); -int closedir(DIR*); -int dirfd(DIR*); -DIR* fdopendir(int); -DIR* opendir(const char*); -struct dirent* readdir(DIR*); -int readdir_r(DIR*, struct dirent*, struct dirent**); -void rewinddir(DIR*); -int scandir(const char*, struct dirent***, int (*)(const struct dirent*), int (*)(const struct dirent**, const struct dirent**)); -void seekdir(DIR*, long); -long telldir(DIR*); +int alphasort(const struct dirent** d1, const struct dirent** d2); +int closedir(DIR* dirp); +int dirfd(DIR* dirp); +DIR* fdopendir(int fd); +DIR* opendir(const char* dirname); +struct dirent* readdir(DIR* dirp); +int readdir_r(DIR* __restrict dirp, struct dirent* __restrict entry, struct dirent** __restrict result); +void rewinddir(DIR* dirp); +int scandir(const char* dir, struct dirent*** namelist, int (*sel)(const struct dirent*), int (*compar)(const struct dirent**, const struct dirent**)); +void seekdir(DIR* dirp, long loc); +long telldir(DIR* dirp); -__END_DECLS \ No newline at end of file +__END_DECLS + +#endif diff --git a/libc/include/dlfcn.h b/libc/include/dlfcn.h new file mode 100644 index 0000000000..8da41c6a19 --- /dev/null +++ b/libc/include/dlfcn.h @@ -0,0 +1,22 @@ +#ifndef _DLFCN_H +#define _DLFCN_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/dlfcn.h.html + +#include + +__BEGIN_DECLS + +#define RTLD_LAZY 1 +#define RTLD_NOW 2 +#define RTLD_GLOBAL 3 +#define RTLD_LOCAL 4 + +int dlclose(void* handle); +char* dlerror(void); +void* dlopen(const char* file, int mode); +void* dlsym(void* __restrict handle, const char* __restrict name); + +__END_DECLS + +#endif diff --git a/libc/include/errno.h b/libc/include/errno.h index 7958d19471..a2408110db 100644 --- a/libc/include/errno.h +++ b/libc/include/errno.h @@ -1,7 +1,12 @@ -#pragma once +#ifndef _ERRNO_H +#define _ERRNO_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/errno.h.html #include +__BEGIN_DECLS + #define E2BIG 1 #define EACCES 2 #define EADDRINUSE 3 @@ -83,13 +88,13 @@ #define ETXTBSY 79 #define EWOULDBLOCK 80 #define EXDEV 81 -#define EEXISTS 82 -#define ENOTBLK 83 +#define ENOTBLK 82 +#define EEXISTS 83 -#define errno errno +#define errno __errno -__BEGIN_DECLS +extern int __errno; -extern int errno; +__END_DECLS -__END_DECLS \ No newline at end of file +#endif diff --git a/libc/include/fcntl.h b/libc/include/fcntl.h index 80e27900c1..401f0099db 100644 --- a/libc/include/fcntl.h +++ b/libc/include/fcntl.h @@ -1,18 +1,106 @@ -#pragma once +#ifndef _FCNTL_H +#define _FCNTL_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/fcntl.h.html #include -#define O_RDONLY (1 << 0) -#define O_WRONLY (1 << 1) -#define O_RDWR (O_RDONLY | O_WRONLY) -#define O_ACCMODE (O_RDONLY | O_WRONLY) -#define O_EXCL (1 << 2) -#define O_CREAT (1 << 3) -#define O_TRUNC (1 << 4) -#define O_APPEND (1 << 5) - __BEGIN_DECLS -int open(const char*, int, ...); +#include +#include + +#define __need_mode_t +#define __need_off_t +#define __need_pid_t +#include + +#define F_DUPFD 1 +#define F_DUPFD_CLOEXEC 2 +#define F_GETFD 3 +#define F_SETFD 4 +#define F_GETFL 5 +#define F_SETFL 6 +#define F_GETLK 7 +#define F_SETLK 8 +#define F_SETLKW 9 +#define F_GETOWN 10 +#define F_SETOWN 11 + +#define FD_CLOEXEC 1 + +#define F_RDLCK 1 +#define F_UNLCK 2 +#define F_WRLCK 3 + +// NOTE: also defined in stdio.h +#define SEEK_SET 1 +#define SEEK_CUR 2 +#define SEEK_END 3 + +/* bits 4-11 */ +#define O_CLOEXEC 0x00010 +#define O_CREAT 0x00020 +#define O_DIRECTORY 0x00040 +#define O_EXCL 0x00080 +#define O_NOCTTY 0x00100 +#define O_NOFOLLOW 0x00200 +#define O_TRUNC 0x00400 +#define O_TTY_INIT 0x00800 + +/* bits 12-16 */ +#define O_APPEND 0x01000 +#define O_DSYNC 0x02000 +#define O_NONBLOCK 0x04000 +#define O_RSYNC 0x08000 +#define O_SYNC 0x10000 + +#define O_ACCMODE 0x00003 + +/* bits 0-1 */ +#define O_RDONLY 0x00001 +#define O_WRONLY 0x00002 +#define O_RDWR (O_RDONLY | O_WRONLY) + +/* bit 17 */ +#define AT_FDCWD 0x20000 + +/* bit 18 */ +#define AT_EACCESS 0x40000 + +/* bit 19 */ +#define AT_SYMLINK_NOFOLLOW 0x80000 + +/* bit 20 */ +#define AT_SYMLINK_FOLLOW 0x100000 + +/* bit 21 */ +#define AT_REMOVEDIR 0x200000 + +/* bits 22-27 */ +#define POSIX_FADV_DONTNEED 0x0400000 +#define POSIX_FADV_NOREUSE 0x0800000 +#define POSIX_FADV_NORMAL 0x1000000 +#define POSIX_FADV_RANDOM 0x2000000 +#define POSIX_FADV_SEQUENTIAL 0x4000000 +#define POSIX_FADV_WILLNEED 0x8000000 + +struct flock +{ + short l_type; /* Type of lock; F_RDLCK, F_WRLCK, F_UNLCK. */ + short l_whence; /* Flag for starting offset. */ + off_t l_start; /* Relative offset in bytes. */ + off_t l_len; /* Size; if 0 then until EOF. */ + pid_t l_pid; /* Process ID of the process holding the lock; returned with F_GETLK. */ +}; + +int creat(const char* path, mode_t mode); +int fcntl(int fildes, int cmd, ...); +int open(const char* path, int oflag, ...); +int openat(int fd, const char* path, int oflag, ...); +int posix_fadvise(int fd, off_t offset, off_t len, int advice); +int posix_fallocate(int fd, off_t offset, off_t len); __END_DECLS + +#endif diff --git a/libc/include/fenv.h b/libc/include/fenv.h new file mode 100644 index 0000000000..3dfaf0fdc9 --- /dev/null +++ b/libc/include/fenv.h @@ -0,0 +1,14 @@ +#ifndef _FENV_H +#define _FENV_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/fenv.h.html + +#include + +__BEGIN_DECLS + +// FIXME + +__END_DECLS + +#endif diff --git a/libc/include/fmtmsg.h b/libc/include/fmtmsg.h new file mode 100644 index 0000000000..0073aaccab --- /dev/null +++ b/libc/include/fmtmsg.h @@ -0,0 +1,42 @@ +#ifndef _FMTMSG_H +#define _FMTMSG_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/fmtmsg.h.html + +#include + +__BEGIN_DECLS + +#define MM_HARD 1 +#define MM_SOFT 2 +#define MM_FIRM 3 +#define MM_APPL 4 +#define MM_UTIL 5 +#define MM_OPSYS 6 +#define MM_RECOVER 7 +#define MM_NRECOV 8 +#define MM_HALT 9 +#define MM_ERROR 10 +#define MM_WARNING 11 +#define MM_INFO 12 +#define MM_NOSEV 13 +#define MM_PRINT 14 +#define MM_CONSOLE 15 + +#define MM_NULLLBL (char*)0 +#define MM_NULLSEV 0 +#define MM_NULLMC 0L +#define MM_NULLTXT (char*)0 +#define MM_NULLACL (char*)0 +#define MM_NULLTAG (char*)0 + +#define MM_OK 0 +#define MM_NOTOK 1 +#define MM_NOMSG 2 +#define MM_NOCON 3 + +int fmtmsg(long classification, const char* label, int severity, const char* text, const char* action, const char* tag); + +__END_DECLS + +#endif diff --git a/libc/include/fnmatch.h b/libc/include/fnmatch.h new file mode 100644 index 0000000000..54fbfd11e8 --- /dev/null +++ b/libc/include/fnmatch.h @@ -0,0 +1,19 @@ +#ifndef _FNMATCH_H +#define _FNMATCH_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/fnmatch.h.html + +#include + +__BEGIN_DECLS + +#define FNM_NOMATCH 1 +#define FNM_PATHNAME 0x01 +#define FNM_PERIOD 0x02 +#define FNM_NOESCAPE 0x04 + +int fnmatch(const char* pattern, const char* string, int flags); + +__END_DECLS + +#endif diff --git a/libc/include/ftw.h b/libc/include/ftw.h new file mode 100644 index 0000000000..56dbc7d531 --- /dev/null +++ b/libc/include/ftw.h @@ -0,0 +1,36 @@ +#ifndef _FTW_H +#define _FTW_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/ftw.h.html + +#include + +__BEGIN_DECLS + +#include + +struct FTW +{ + int base; + int level; +}; + +#define FTW_F 1 +#define FTW_D 2 +#define FTW_DNR 3 +#define FTW_DP 4 +#define FTW_NS 5 +#define FTW_SL 6 +#define FTW_SLN 7 + +#define FTW_PHYS 1 +#define FTW_MOUNT 2 +#define FTW_DEPTH 3 +#define FTW_CHDIR 4 + +int ftw(const char* path, int (*fn)(const char*, const struct stat* ptr, int flag), int ndirs); +int nftw(const char* path, int (*fn)(const char*, const struct stat*, int, struct FTW*), int fd_limit, int flags); + +__END_DECLS + +#endif diff --git a/libc/include/glob.h b/libc/include/glob.h new file mode 100644 index 0000000000..60462d2a34 --- /dev/null +++ b/libc/include/glob.h @@ -0,0 +1,37 @@ +#ifndef _GLOB_H +#define _GLOB_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/glob.h.html + +#include + +__BEGIN_DECLS + +#define __need_size_t +#include + +#define GLOB_APPEND 0x01 +#define GLOB_DOOFFS 0x02 +#define GLOB_ERR 0x04 +#define GLOB_MARK 0x08 +#define GLOB_NOCHECK 0x10 +#define GLOB_NOESCAPE 0x20 +#define GLOB_NOSORT 0x40 + +#define GLOB_ABORTED 1 +#define GLOB_NOMATCH 2 +#define GLOB_NOSPACE 3 + +struct glob_t +{ + size_t gl_pathc; /* Count of paths matched by pattern. */ + char** gl_pathv; /* Pointer to a list of matched pathnames. */ + size_t gl_offs; /* Slots to reserve at the beginning of gl_pathv. */ +}; + +int glob(const char* __restrict pattern, int flags, int (*errfunc)(const char* epath, int eerrno), glob_t* __restrict pglob); +void globfree(glob_t* pglob); + +__END_DECLS + +#endif diff --git a/libc/include/grp.h b/libc/include/grp.h new file mode 100644 index 0000000000..9d04e2ed66 --- /dev/null +++ b/libc/include/grp.h @@ -0,0 +1,31 @@ +#ifndef _GRP_H +#define _GRP_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/grp.h.html + +#include + +__BEGIN_DECLS + +#define __need_gid_t +#define __need_size_t +#include + +struct group +{ + char* gr_name; /* The name of the group. */ + gid_t gr_gid; /* Numerical group ID. */ + char** gr_mem; /* Pointer to a null-terminated array of character pointers to member names. */ +}; + +void endgrent(void); +struct group* getgrent(void); +struct group* getgrgid(gid_t gid); +int getgrgit_r(gid_t gid, struct group* grp, char* buffer, size_t bufsize, struct group** result); +struct group* getgrnam(const char* name); +int getgrnam_r(const char* name, struct group* grp, char* buffer, size_t bufsize, struct group** result); +void setgrent(void); + +__END_DECLS + +#endif diff --git a/libc/include/iconv.h b/libc/include/iconv.h new file mode 100644 index 0000000000..587a7d2b4a --- /dev/null +++ b/libc/include/iconv.h @@ -0,0 +1,21 @@ +#ifndef _ICONV_H +#define _ICONV_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/iconv.h.html + +#include + +__BEGIN_DECLS + +#define __need_size_t +#include + +typedef void* iconv_t; + +size_t iconv(iconv_t cd, char** __restrict inbuf, size_t* __restrict inbytesleft, char** __restrict outbuf, size_t* __restrict outbytesleft); +int iconv_close(iconv_t cd); +iconv_t iconv_open(const char* tocode, const char* fromcode); + +__END_DECLS + +#endif diff --git a/libc/include/inttypes.h b/libc/include/inttypes.h new file mode 100644 index 0000000000..ca901ea21b --- /dev/null +++ b/libc/include/inttypes.h @@ -0,0 +1,206 @@ +#ifndef _INTTYPES_H +#define _INTTYPES_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/inttypes.h.html + +#include + +__BEGIN_DECLS + +#include + +#define __need_wchar_t +#include + +typedef struct +{ + intmax_t quot; + intmax_t rem; +} imaxdiv_t; + +#ifdef __x86_64__ + #define __PRI64_PREFIX "l" + #define __PRIPTR_PREFIX "l" +#else + #define __PRI64_PREFIX "ll" + #define __PRIPTR_PREFIX +#endif + +#define PRId8 "d" +#define PRId16 "d" +#define PRId32 "d" +#define PRId64 __PRI64_PREFIX "d" +#define PRIdLEAST8 "d" +#define PRIdLEAST16 "d" +#define PRIdLEAST32 "d" +#define PRIdLEAST64 __PRI64_PREFIX "d" +#define PRIdFAST8 "d" +#define PRIdFAST16 __PRIPTR_PREFIX "d" +#define PRIdFAST32 __PRIPTR_PREFIX "d" +#define PRIdFAST64 __PRI64_PREFIX "d" +#define PRIdMAX __PRI64_PREFIX "d" +#define PRIdPTR __PRIPTR_PREFIX "d" + +#define PRIi8 "i" +#define PRIi16 "i" +#define PRIi32 "i" +#define PRIi64 __PRI64_PREFIX "i" +#define PRIiLEAST8 "i" +#define PRIiLEAST16 "i" +#define PRIiLEAST32 "i" +#define PRIiLEAST64 __PRI64_PREFIX "i" +#define PRIiFAST8 "i" +#define PRIiFAST16 __PRIPTR_PREFIX "i" +#define PRIiFAST32 __PRIPTR_PREFIX "i" +#define PRIiFAST64 __PRI64_PREFIX "i" +#define PRIiMAX __PRI64_PREFIX "i" +#define PRIiPTR __PRIPTR_PREFIX "i" + +#define PRIo8 "o" +#define PRIo16 "o" +#define PRIo32 "o" +#define PRIo64 __PRI64_PREFIX "o" +#define PRIoLEAST8 "o" +#define PRIoLEAST16 "o" +#define PRIoLEAST32 "o" +#define PRIoLEAST64 __PRI64_PREFIX "o" +#define PRIoFAST8 "o" +#define PRIoFAST16 __PRIPTR_PREFIX "o" +#define PRIoFAST32 __PRIPTR_PREFIX "o" +#define PRIoFAST64 __PRI64_PREFIX "o" +#define PRIoMAX __PRI64_PREFIX "o" +#define PRIoPTR __PRIPTR_PREFIX "o" + +#define PRIu8 "u" +#define PRIu16 "u" +#define PRIu32 "u" +#define PRIu64 __PRI64_PREFIX "u" +#define PRIuLEAST8 "u" +#define PRIuLEAST16 "u" +#define PRIuLEAST32 "u" +#define PRIuLEAST64 __PRI64_PREFIX "u" +#define PRIuFAST8 "u" +#define PRIuFAST16 __PRIPTR_PREFIX "u" +#define PRIuFAST32 __PRIPTR_PREFIX "u" +#define PRIuFAST64 __PRI64_PREFIX "u" +#define PRIuMAX __PRI64_PREFIX "u" +#define PRIuPTR __PRIPTR_PREFIX "u" + +#define PRIx8 "x" +#define PRIx16 "x" +#define PRIx32 "x" +#define PRIx64 __PRI64_PREFIX "x" +#define PRIxLEAST8 "x" +#define PRIxLEAST16 "x" +#define PRIxLEAST32 "x" +#define PRIxLEAST64 __PRI64_PREFIX "x" +#define PRIxFAST8 "x" +#define PRIxFAST16 __PRIPTR_PREFIX "x" +#define PRIxFAST32 __PRIPTR_PREFIX "x" +#define PRIxFAST64 __PRI64_PREFIX "x" +#define PRIxMAX __PRI64_PREFIX "x" +#define PRIxPTR __PRIPTR_PREFIX "x" + +#define PRIX8 "X" +#define PRIX16 "X" +#define PRIX32 "X" +#define PRIX64 __PRI64_PREFIX "X" +#define PRIXLEAST8 "X" +#define PRIXLEAST16 "X" +#define PRIXLEAST32 "X" +#define PRIXLEAST64 __PRI64_PREFIX "X" +#define PRIXFAST8 "X" +#define PRIXFAST16 __PRIPTR_PREFIX "X" +#define PRIXFAST32 __PRIPTR_PREFIX "X" +#define PRIXFAST64 __PRI64_PREFIX "X" +#define PRIXMAX __PRI64_PREFIX "X" +#define PRIXPTR __PRIPTR_PREFIX "X" + +#define SCNd8 "hhd" +#define SCNd16 "hd" +#define SCNd32 "d" +#define SCNd64 __PRI64_PREFIX "d" +#define SCNdLEAST8 "hhd" +#define SCNdLEAST16 "hd" +#define SCNdLEAST32 "d" +#define SCNdLEAST64 __PRI64_PREFIX "d" +#define SCNdFAST8 "hhd" +#define SCNdFAST16 __PRIPTR_PREFIX "d" +#define SCNdFAST32 __PRIPTR_PREFIX "d" +#define SCNdFAST64 __PRI64_PREFIX "d" +#define SCNdMAX __PRI64_PREFIX "d" +#define SCNdPTR __PRIPTR_PREFIX "d" + +#define SCNi8 "hhi" +#define SCNi16 "hi" +#define SCNi32 "i" +#define SCNi64 __PRI64_PREFIX "i" +#define SCNiLEAST8 "hhi" +#define SCNiLEAST16 "hi" +#define SCNiLEAST32 "i" +#define SCNiLEAST64 __PRI64_PREFIX "i" +#define SCNiFAST8 "hhi" +#define SCNiFAST16 __PRIPTR_PREFIX "i" +#define SCNiFAST32 __PRIPTR_PREFIX "i" +#define SCNiFAST64 __PRI64_PREFIX "i" +#define SCNiMAX __PRI64_PREFIX "i" +#define SCNiPTR __PRIPTR_PREFIX "i" + +#define SCNo8 "hho" +#define SCNo16 "ho" +#define SCNo32 "o" +#define SCNo64 __PRI64_PREFIX "o" +#define SCNoLEAST8 "hho" +#define SCNoLEAST16 "ho" +#define SCNoLEAST32 "o" +#define SCNoLEAST64 __PRI64_PREFIX "o" +#define SCNoFAST8 "hho" +#define SCNoFAST16 __PRIPTR_PREFIX "o" +#define SCNoFAST32 __PRIPTR_PREFIX "o" +#define SCNoFAST64 __PRI64_PREFIX "o" +#define SCNoMAX __PRI64_PREFIX "o" +#define SCNoPTR __PRIPTR_PREFIX "o" + +#define SCNu8 "hhu" +#define SCNu16 "hu" +#define SCNu32 "u" +#define SCNu64 __PRI64_PREFIX "u" +#define SCNuLEAST8 "hhu" +#define SCNuLEAST16 "hu" +#define SCNuLEAST32 "u" +#define SCNuLEAST64 __PRI64_PREFIX "u" +#define SCNuFAST8 "hhu" +#define SCNuFAST16 __PRIPTR_PREFIX "u" +#define SCNuFAST32 __PRIPTR_PREFIX "u" +#define SCNuFAST64 __PRI64_PREFIX "u" +#define SCNuMAX __PRI64_PREFIX "u" +#define SCNuPTR __PRIPTR_PREFIX "u" + +#define SCNx8 "hhx" +#define SCNx16 "hx" +#define SCNx32 "x" +#define SCNx64 __PRI64_PREFIX "x" +#define SCNxLEAST8 "hhx" +#define SCNxLEAST16 "hx" +#define SCNxLEAST32 "x" +#define SCNxLEAST64 __PRI64_PREFIX "x" +#define SCNxFAST8 "hhx" +#define SCNxFAST16 __PRIPTR_PREFIX "x" +#define SCNxFAST32 __PRIPTR_PREFIX "x" +#define SCNxFAST64 __PRI64_PREFIX "x" +#define SCNxMAX __PRI64_PREFIX "x" +#define SCNxPTR __PRIPTR_PREFIX "x" + +#undef __PRI64_PREFIX +#undef __PRIPTR_PREFIX + +intmax_t imaxabs(intmax_t); +imaxdiv_t imaxdiv(intmax_t, intmax_t); +intmax_t strtoimax(const char* __restrict nptr, char** __restrict endptr, int base); +uintmax_t strtoumax(const char* __restrict nptr, char** __restrict endptr, int base); +intmax_t wcstoimax(const wchar_t* __restrict nptr, wchar_t** __restrict endptr, int base); +uintmax_t wcstoumax(const wchar_t* __restrict nptr, wchar_t** __restrict endptr, int base); + +__END_DECLS + +#endif diff --git a/libc/include/langinfo.h b/libc/include/langinfo.h new file mode 100644 index 0000000000..8da226264e --- /dev/null +++ b/libc/include/langinfo.h @@ -0,0 +1,74 @@ +#ifndef _LANGINFO_H +#define _LANGINFO_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/langinfo.h.html + +#include + +__BEGIN_DECLS + +#include +#include + +#define CODESET 0 +#define D_T_FMT 1 +#define D_FMT 2 +#define T_FMT 3 +#define T_FMT_AMPM 4 +#define AM_STR 5 +#define PM_STR 6 +#define DAY_1 7 +#define DAY_2 8 +#define DAY_3 9 +#define DAY_4 10 +#define DAY_5 11 +#define DAY_6 12 +#define DAY_7 13 +#define ABDAY_1 14 +#define ABDAY_2 15 +#define ABDAY_3 16 +#define ABDAY_4 17 +#define ABDAY_5 18 +#define ABDAY_6 19 +#define ABDAY_7 20 +#define MON_1 21 +#define MON_2 22 +#define MON_3 23 +#define MON_4 24 +#define MON_5 25 +#define MON_6 26 +#define MON_7 27 +#define MON_8 28 +#define MON_9 29 +#define MON_10 30 +#define MON_11 31 +#define MON_12 32 +#define ABMON_1 33 +#define ABMON_2 34 +#define ABMON_3 35 +#define ABMON_4 36 +#define ABMON_5 37 +#define ABMON_6 38 +#define ABMON_7 39 +#define ABMON_8 40 +#define ABMON_9 41 +#define ABMON_10 42 +#define ABMON_11 43 +#define ABMON_12 44 +#define ERA 45 +#define ERA_D_FMT 46 +#define ERA_D_T_FMT 47 +#define ERA_T_FMT 48 +#define ALT_DIGITS 49 +#define RADIXCHAR 50 +#define THOUSEP 51 +#define YESEXPR 52 +#define NOEXPR 53 +#define CRNCYSTR 54 + +char* nl_langinfo(nl_item item); +char* nl_landinfo_l(nl_item item, locale_t locale); + +__END_DECLS + +#endif diff --git a/libc/include/libgen.h b/libc/include/libgen.h new file mode 100644 index 0000000000..9210aa9591 --- /dev/null +++ b/libc/include/libgen.h @@ -0,0 +1,15 @@ +#ifndef _LIBGEN_H +#define _LIBGEN_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/ligen.h.html + +#include + +__BEGIN_DECLS + +char* basename(char* path); +char* dirname(char* path); + +__END_DECLS + +#endif diff --git a/libc/include/limits.h b/libc/include/limits.h new file mode 100644 index 0000000000..c32ec46aae --- /dev/null +++ b/libc/include/limits.h @@ -0,0 +1,22 @@ +#ifndef _LIMITS_H +#define _LIMITS_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/limits.h.html + +#include + +__BEGIN_DECLS + +// FIXME: What do I have to define here? +// glibc seems to only define numerical +// and posix constants + +#if defined __GNUC__ && !defined _GCC_LIMITS_H_ + #include_next +#else + #error "unsupported compiler" +#endif + +__END_DECLS + +#endif diff --git a/libc/include/locale.h b/libc/include/locale.h index 74c82cb7fd..52c930bd6c 100644 --- a/libc/include/locale.h +++ b/libc/include/locale.h @@ -1,25 +1,35 @@ -#pragma once +#ifndef _LOCALE_H +#define _LOCALE_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/locale.h.html -#include #include -// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/locale.h.html#tag_13_24 +#include -#define LC_ALL 1 -#define LC_COLLATE 2 -#define LC_CTYPE 3 -#define LC_MESSAGES 4 -#define LC_MONETARY 5 -#define LC_NUMERIC 6 -#define LC_TIME 7 +#define __need_NULL +#include -#define LC_COLLATE_MASK 0x01 -#define LC_CTYPE_MASK 0x02 -#define LC_MESSAGES_MASK 0x04 -#define LC_MONETARY_MASK 0x08 -#define LC_NUMERIC_MASK 0x10 -#define LC_TIME_MASK 0x20 -#define LC_ALL_MASK 0x3F +#define LC_COLLATE 0 +#define LC_CTYPE 1 +#define LC_MESSAGES 2 +#define LC_MONETARY 3 +#define LC_NUMERIC 4 +#define LC_TIME 5 +#define LC_ALL 6 + +#define LC_COLLATE_MASK (1 << LC_COLLATE) +#define LC_CTYPE_MASK (1 << LC_CTYPE) +#define LC_MESSAGES_MASK (1 << LC_MESSAGES) +#define LC_MONETARY_MASK (1 << LC_MONETARY) +#define LC_NUMERIC_MASK (1 << LC_NUMERIC) +#define LC_TIME_MASK (1 << LC_TIME) +#define LC_ALL_MASK LC_COLLATE_MASK \ + | LC_CTYPE_MASK \ + | LC_MESSAGES_MASK \ + | LC_MONETARY_MASK \ + | LC_NUMERIC_MASK \ + | LC_TIME_MASK __BEGIN_DECLS @@ -30,34 +40,34 @@ struct lconv char frac_digits; char* grouping; char* int_curr_symbol; - char int_frac_digits; - char int_n_cs_precedes; - char int_n_sep_by_space; - char int_n_sign_posn; - char int_p_cs_precedes; - char int_p_sep_by_space; - char int_p_sign_posn; + char int_frac_digits; + char int_n_cs_precedes; + char int_n_sep_by_space; + char int_n_sign_posn; + char int_p_cs_precedes; + char int_p_sep_by_space; + char int_p_sign_posn; char* mon_decimal_point; char* mon_grouping; char* mon_thousands_sep; char* negative_sign; - char n_cs_precedes; - char n_sep_by_space; - char n_sign_posn; + char n_cs_precedes; + char n_sep_by_space; + char n_sign_posn; char* positive_sign; - char p_cs_precedes; - char p_sep_by_space; - char p_sign_posn; + char p_cs_precedes; + char p_sep_by_space; + char p_sign_posn; char* thousands_sep; }; -typedef int locale_t; - -locale_t duplocale(locale_t); -void freelocale(locale_t); -struct lconv localeconv(void); -locale_t newlocale(int, const char*, locale_t); -char* setlocale(int, const char*); -locale_t uselocale(locale_t); +locale_t duplocale(locale_t locobj); +void freelocale(locale_t locobj); +struct lconv* localeconv(void); +locale_t newlocale(int category_mask, const char* locale, locale_t base); +char* setlocale(int category, const char* locale); +locale_t uselocale(locale_t newloc); __END_DECLS + +#endif diff --git a/libc/include/math.h b/libc/include/math.h index 4dbb92986f..48794cd6b5 100644 --- a/libc/include/math.h +++ b/libc/include/math.h @@ -1,16 +1,76 @@ -#pragma once +#ifndef _MATH_H +#define _MATH_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/math.h.html #include -#define FP_INFINITE 1 -#define FP_NAN 2 -#define FP_NORMAL 3 -#define FP_SUBNORMAL 4 -#define FP_ZERO 5 - __BEGIN_DECLS -extern int signgam; +#ifndef FLT_EVAL_METHOD + #define FLT_EVAL_METHOD 0 +#endif + +#if FLT_EVAL_METHOD == 0 + typedef float float_t; + typedef double double_t; +#elif FLT_EVAL_METHOD == 1 + typedef double float_t; + typedef double double_t; +#elif FLT_EVAL_METHOD == 2 + typedef long double float_t; + typedef long double double_t; +#endif + +// FIXME: define these +#if 0 +int fpclassify(real-floating x); +int isfinite(real-floating x); +int isgreater(real-floating x, real-floating y); +int isgreaterequal(real-floating x, real-floating y); +int isinf(real-floating x); +int isless(real-floating x, real-floating y); +int islessequal(real-floating x, real-floating y); +int islessgreater(real-floating x, real-floating y); +int isnan(real-floating x); +int isnormal(real-floating x); +int isunordered(real-floating x, real-floating y); +int signbit(real-floating x); +#endif + +#define M_E 2.7182818284590452354 +#define M_LOG2E 1.4426950408889634074 +#define M_LOG10E 0.43429448190325182765 +#define M_LN2 0.69314718055994530942 +#define M_LN10 2.30258509299404568402 +#define M_PI 3.14159265358979323846 +#define M_PI_2 1.57079632679489661923 +#define M_PI_4 0.78539816339744830962 +#define M_1_PI 0.31830988618379067154 +#define M_2_PI 0.63661977236758134308 +#define M_2_SQRTPI 1.12837916709551257390 +#define M_SQRT2 1.41421356237309504880 +#define M_SQRT1_2 0.70710678118654752440 + +#define HUGE_VAL 1e10000 +#define HUGE_VALF 1e10000f +#define HUGE_VALL 1e10000L +#define INFINITY HUGE_VALf +#define NAN (0.0f / 0.0f) + +#define FP_INFINITE 0 +#define FP_NAN 1 +#define FP_NORMAL 2 +#define FP_SUBNORMAL 3 +#define FP_ZERO 4 + +#define FP_ILOGB0 -2147483647 +#define FP_ILOGBNAN +2147483647 + +#define MATH_ERRNO 1 +#define MATH_ERREXCEPT 2 + +#define math_errhandling (MATH_ERRNO | MATH_ERREXCEPT) double acos(double); float acosf(float); @@ -190,4 +250,8 @@ double y0(double); double y1(double); double yn(int, double); +extern int signgam; + __END_DECLS + +#endif diff --git a/libc/include/monetary.h b/libc/include/monetary.h new file mode 100644 index 0000000000..ccdba869e3 --- /dev/null +++ b/libc/include/monetary.h @@ -0,0 +1,23 @@ +#ifndef _MONETARY_H +#define _MONETARY_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/monetary.h.html + +#include + +__BEGIN_DECLS + +#include + +#define __need_size_t +#include + +#define __need_ssize_t +#include + +ssize_t strfmon(char* __restrict s, size_t maxsize, const char* __restrict format, ...); +ssize_t strfmon_l(char* __restrict s, size_t maxsize, locale_t locale, const char* __restrict format, ...); + +__END_DECLS + +#endif diff --git a/libc/include/mqueue.h b/libc/include/mqueue.h new file mode 100644 index 0000000000..5d96826b42 --- /dev/null +++ b/libc/include/mqueue.h @@ -0,0 +1,41 @@ +#ifndef _MQUEUE_H +#define _MQUEUE_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/mqueue.h.html + +#include + +__BEGIN_DECLS + +#include +#include + +#define __need_pthread_attr_t +#define __need_size_t +#define __need_ssize_t +#include + +typedef int mqd_t; + +struct mq_attr +{ + long mq_flags; /* Message queue flags. */ + long mq_maxmsg; /* Maximum number of messages. */ + long mq_msgsize; /* Maximum message size. */ + long mq_curmsgs; /* Number of messages currently queued. */ +}; + +int mq_close(mqd_t mqdes); +int mq_getattr(mqd_t mqdes, struct mq_attr* mqstat); +int mq_notify(mqd_t mqdes, const struct sigevent* notification); +mqd_t mq_open(const char* name, int oflag, ...); +ssize_t mq_receive(mqd_t mqdes, char* msq_ptr, size_t msq_len, unsigned* msg_prio); +int mq_send(mqd_t mqdes, const char* msg_ptr, size_t msg_len, unsigned msg_prio); +int mq_setattr(mqd_t mqdes, const struct mq_attr* __restrict mqstat, struct mq_attr* __restrict omqstat); +ssize_t mq_timedreceive(mqd_t mqdes, char* __restrict msg_ptr, size_t msg_len, unsigned* __restrict msg_prio, const struct timespec* __restrict abstime); +int mq_timedsend(mqd_t mqdes, const char* msg_ptr, size_t msg_len, unsigned msg_prio, const struct timespec* abstime); +int mq_unlink(const char* name); + +__END_DECLS + +#endif diff --git a/libc/include/ndbm.h b/libc/include/ndbm.h new file mode 100644 index 0000000000..6586b87997 --- /dev/null +++ b/libc/include/ndbm.h @@ -0,0 +1,39 @@ +#ifndef _NDBM_H +#define _NDBM_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/ndbm.h.html + +#include + +__BEGIN_DECLS + +#define DBM_REPLACE 1 +#define DBM_INSERT 0 + +#define __need_size_t +#include + +#define __need_mode_t +#include + +typedef struct +{ + void* dptr; /* A pointer to the application's data. */ + size_t dsize; /* The size of the object pointed to by dptr */ +} datum; + +typedef int DBM; + +int dbm_clearerr(DBM* db); +void dbm_close(DBM* db); +int dbm_delete(DBM* db, datum key); +int dbm_error(DBM* db); +datum dbm_fetch(DBM* db, datum key); +datum dbm_firstkey(DBM* db); +datum dbm_nextkey(DBM* db); +DBM* dbm_open(const char* file, int open_flags, mode_t file_mode); +int dbm_store(DBM* db, datum key, datum content, int store_mode); + +__END_DECLS + +#endif diff --git a/libc/include/net/if.h b/libc/include/net/if.h new file mode 100644 index 0000000000..8a2664f416 --- /dev/null +++ b/libc/include/net/if.h @@ -0,0 +1,25 @@ +#ifndef _NET_IF_H +#define _NET_IF_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/net_if.h.html + +#include + +#define IF_NAMESIZE 16 + +__BEGIN_DECLS + +struct if_nameindex +{ + unsigned if_index; /* Numeric index of the interface. */ + char* if_name; /* Null-terminated name of the interface. */ +}; + +void if_freenameindex(struct if_nameindex* ptr); +char* if_indextoname(unsigned ifindex, char* ifname); +struct if_nameindex* if_nameindex(void); +unsigned if_nametoindex(const char* ifname); + +__END_DECLS + +#endif diff --git a/libc/include/netdb.h b/libc/include/netdb.h new file mode 100644 index 0000000000..315c61fb68 --- /dev/null +++ b/libc/include/netdb.h @@ -0,0 +1,111 @@ +#ifndef _NETDB_H +#define _NETDB_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/netdb.h.html + +#include + +__BEGIN_DECLS + +#include +#include +#include + +#define IPPORT_RESERVED 1024 + +#define AI_PASSIVE 0x01 +#define AI_CANONNAME 0x02 +#define AI_NUMERICHOST 0x04 +#define AI_NUMERICSERV 0x08 +#define AI_V4MAPPED 0x10 +#define AI_ALL 0x20 +#define AI_ADDRCONFIG 0x40 + +#define NI_NOFQDN 0x01 +#define NI_NUMERICHOST 0x02 +#define NI_NAMEREQD 0x04 +#define NI_NUMERICSERV 0x08 +#define NI_NUMERICSCOPE 0x10 +#define NI_DGRAM 0x20 + +#define EAI_AGAIN 1 +#define EAI_BADFLAGS 2 +#define EAI_FAIL 3 +#define EAI_FAMILY 4 +#define EAI_MEMORY 5 +#define EAI_NONAME 6 +#define EAI_SERVICE 7 +#define EAI_SOCKTYPE 8 +#define EAI_SYSTEM 9 +#define EAI_OVERFLOW 10 + +struct hostent +{ + char* h_name; /* Official name of the host. */ + char** h_aliases; /* A pointer to an array of pointers to alternative host names, terminated by a null pointer. */ + int h_addrtype; /* Address type. */ + int h_length; /* The length, in bytes, of the address. */ + char** h_addr_list; /* A pointer to an array of pointers to network addresses (in network byte order) for the host, terminated by a null pointer. */ +}; + +struct netent +{ + char* n_name; /* Official, fully-qualified (including the domain) name of the host. */ + char** n_aliases; /* A pointer to an array of pointers to alternative network names, terminated by a null pointer. */ + int n_addrtype; /* The address type of the network. */ + uint32_t n_net; /* The network number, in host byte order. */ +}; + +struct protoent +{ + char* p_name; /* Official name of the protocol. */ + char** p_aliases; /* A pointer to an array of pointers to alternative protocol names, terminated by a null pointer. */ + int p_proto; /* The protocol number. */ +}; + +struct servent +{ + char* s_name; /* Official name of the service. */ + char** s_aliases; /* A pointer to an array of pointers to alternative service names, terminated by a null pointer. */ + int s_port; /* A value which, when converted to uint16_t, yields the port number in network byte order at which the service resides. */ + char* s_proto; /* The name of the protocol to use when contacting the service. */ +}; + +struct addrinfo +{ + int ai_flags; /* Input flags. */ + int ai_family; /* Address family of socket. */ + int ai_socktype; /* Socket type. */ + int ai_protocol; /* Protocol of socket. */ + socklen_t ai_addrlen; /* Length of socket address. */ + struct sockaddr* ai_addr; /* Socket address of socket. */ + char* ai_canonname; /* Canonical name of service location. */ + struct addrinfo* ai_next; /* Pointer to next in list. */ +}; + +void endhostent(void); +void endnetent(void); +void endprotoent(void); +void endservent(void); +void freeaddrinfo(struct addrinfo* ai); +const char* gai_strerror(int ecode); +int getaddrinfo(const char* __restrict nodename, const char* __restrict servname, const struct addrinfo* __restrict hints, struct addrinfo** __restrict res); +struct hostent* gethostent(void); +int getnameinfo(const struct sockaddr* __restrict sa, socklen_t salen, char* __restrict node, socklen_t nodelen, char* __restrict service, socklen_t servicelen, int flags); +struct netent* getnetbyaddr(uint32_t net, int type); +struct netent* getnetbyname(const char* name); +struct netent* getnetent(void); +struct protoent* getprotobyname(const char* name); +struct protoent* getprotobynumber(int proto); +struct protoent* getprotoent(void); +struct servent* getservbyname(const char* name, const char* proto); +struct servent* getservbyport(int port, const char* proto); +struct servent* getservent(void); +void sethostent(int stayopen); +void setnetent(int stayopen); +void setprotoent(int stayopen); +void setservent(int stayopen); + +__END_DECLS + +#endif diff --git a/libc/include/netinet/in.h b/libc/include/netinet/in.h new file mode 100644 index 0000000000..c28f07baad --- /dev/null +++ b/libc/include/netinet/in.h @@ -0,0 +1,92 @@ +#ifndef _NETINET_IN_H +#define _NETINET_IN_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/netinet_in.h.html + +#include + +__BEGIN_DECLS + +#include +#include + +#define IPPROTO_IP 1 +#define IPPROTO_IPV6 2 +#define IPPROTO_ICMP 3 +#define IPPROTO_RAW 4 +#define IPPROTO_TCP 5 +#define IPPROTO_UDP 6 + +#define IPV6_JOIN_GROUP 1 +#define IPV6_LEAVE_GROUP 2 +#define IPV6_MULTICAST_HOPS 3 +#define IPV6_MULTICAST_IF 4 +#define IPV6_MULTICAST_LOOP 5 +#define IPV6_UNICAST_HOPS 6 +#define IPV6_V6ONLY 7 + +#define INADDR_ANY 0 +#define INADDR_BROADCAST UINT32_MAX + +#define INET_ADDRSTRLEN 16 +#define INET6_ADDRSTRLEN 46 + +#define IN6ADDR_ANY_INIT { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } } } +#define IN6ADDR_LOOPBACK_INIT { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 } } } + +#if 0 +#define IN6_IS_ADDR_UNSPECIFIED(addr) +#define IN6_IS_ADDR_LOOPBACK(addr) +#define IN6_IS_ADDR_MULTICAST(addr) +#define IN6_IS_ADDR_LINKLOCAL(addr) +#define IN6_IS_ADDR_SITELOCAL(addr) +#define IN6_IS_ADDR_V4MAPPED(addr) +#define IN6_IS_ADDR_V4COMPAT(addr) +#define IN6_IS_ADDR_MC_NODELOCAL(addr) +#define IN6_IS_ADDR_MC_LINKLOCAL(addr) +#define IN6_IS_ADDR_MC_SITELOCAL(addr) +#define IN6_IS_ADDR_MC_ORGLOCAL(addr) +#define IN6_IS_ADDR_MC_GLOBAL(addr) +#endif + +typedef uint16_t in_port_t; +typedef uint32_t in_addr_t; + +struct in_addr +{ + in_addr_t s_addr; +}; + +struct sockaddr_in +{ + sa_family_t sin_family; /* AF_INET. */ + in_port_t sin_port; /* Port number. */ + struct in_addr sin_addr; /* IP address. */ +}; + +struct in6_addr +{ + uint8_t s6_addr[16]; +}; + +struct sockaddr_in6 +{ + sa_family_t sin6_family; /* AF_INET6. */ + in_port_t sin6_port; /* Port number. */ + uint32_t sin6_flowinfo; /* IPv6 traffic class and flow information. */ + struct in6_addr sin6_addr; /* IPv6 address. */ + uint32_t sin6_scope_id; /* Set of interfaces for a scope. */ +}; + +extern const struct in6_addr in6addr_any; +extern const struct in6_addr in6addr_loopback; + +struct ipv6_mreq +{ + struct in6_addr ipv6mr_multiaddr; /* IPv6 multicast address. */ + unsigned ipv6mr_interface; /* Interface index. */ +}; + +__END_DECLS + +#endif diff --git a/libc/include/netinet/tcp.h b/libc/include/netinet/tcp.h new file mode 100644 index 0000000000..3bdfc09cb8 --- /dev/null +++ b/libc/include/netinet/tcp.h @@ -0,0 +1,14 @@ +#ifndef __NETINET_TCP_H +#define __NETINET_TCP_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/netinet_tcp.h.html + +#include + +__BEGIN_DECLS + +#define TCP_NODELAY 1 + +__END_DECLS + +#endif diff --git a/libc/include/nl_types.h b/libc/include/nl_types.h new file mode 100644 index 0000000000..ac4aa8c64d --- /dev/null +++ b/libc/include/nl_types.h @@ -0,0 +1,22 @@ +#ifndef _NL_TYPES_H +#define _NL_TYPES_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/nl_types.h.html + +#include + +__BEGIN_DECLS + +typedef void* nl_catd; +typedef int nl_item; + +#define NL_SETD 1 +#define NL_CAT_LOCALE 1 + +int charclose(nl_catd catd); +char* catgets(nl_catd catd, int set_id, int msg_id, const char* s); +nl_catd catopen(const char* name, int oflag); + +__END_DECLS + +#endif diff --git a/libc/include/poll.h b/libc/include/poll.h new file mode 100644 index 0000000000..5bd3570621 --- /dev/null +++ b/libc/include/poll.h @@ -0,0 +1,34 @@ +#ifndef _POLL_H +#define _POLL_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/poll.h.html + +#include + +__BEGIN_DECLS + +struct pollfd +{ + int fd; /* The following descriptor being polled. */ + short events; /* The input event flags. */ + short revents; /* The output event flags. */ +}; + +typedef unsigned long nfds_t; + +#define POLLIN 0x001 +#define POLLRDNORM 0x002 +#define POLLRDBAND 0x004 +#define POLLPRI 0x008 +#define POLLOUT 0x010 +#define POLLWRNORM 0x020 +#define POLLWRBAND 0x040 +#define POLLERR 0x080 +#define POLLHUP 0x100 +#define POLLNVAL 0x200 + +int poll(struct pollfd fds[], nfds_t nfds, int timeout); + +__END_DECLS + +#endif diff --git a/libc/include/pthread.h b/libc/include/pthread.h new file mode 100644 index 0000000000..9cee94d69c --- /dev/null +++ b/libc/include/pthread.h @@ -0,0 +1,165 @@ +#ifndef _PTHREAD_H +#define _PTHREAD_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/pthread.h.html + +#include + +__BEGIN_DECLS + +#include +#include + +#define __need_size_t +#define __need_clockid_t +#define __need_pthread_attr_t +#define __need_pthread_barrier_t +#define __need_pthread_barrierattr_t +#define __need_pthread_cond_t +#define __need_pthread_condattr_t +#define __need_pthread_key_t +#define __need_pthread_mutex_t +#define __need_pthread_mutexattr_t +#define __need_pthread_once_t +#define __need_pthread_rwlock_t +#define __need_pthread_rwlockattr_t +#define __need_pthread_spinlock_t +#define __need_pthread_t +#include + +#define PTHREAD_BARRIER_SERIAL_THREAD 1 +#define PTHREAD_CANCEL_ASYNCHRONOUS 2 +#define PTHREAD_CANCEL_ENABLE 3 +#define PTHREAD_CANCEL_DEFERRED 4 +#define PTHREAD_CANCEL_DISABLE 5 +#define PTHREAD_CANCELED 6 +#define PTHREAD_CREATE_DETACHED 7 +#define PTHREAD_CREATE_JOINABLE 8 +#define PTHREAD_EXPLICIT_SCHED 9 +#define PTHREAD_INHERIT_SCHED 10 +#define PTHREAD_MUTEX_DEFAULT 11 +#define PTHREAD_MUTEX_ERRORCHECK 12 +#define PTHREAD_MUTEX_NORMAL 13 +#define PTHREAD_MUTEX_RECURSIVE 14 +#define PTHREAD_MUTEX_ROBUST 15 +#define PTHREAD_MUTEX_STALLED 16 +#define PTHREAD_ONCE_INIT 17 +#define PTHREAD_PRIO_INHERIT 18 +#define PTHREAD_PRIO_NONE 19 +#define PTHREAD_PRIO_PROTECT 20 +#define PTHREAD_PROCESS_SHARED 21 +#define PTHREAD_PROCESS_PRIVATE 22 +#define PTHREAD_SCOPE_PROCESS 23 +#define PTHREAD_SCOPE_SYSTEM 24 + +#if 0 +#define PTHREAD_COND_INITIALIZER +#define PTHREAD_MUTEX_INITIALIZER +#define PTHREAD_RWLOCK_INITIALIZER +#endif + +int pthread_atfork(void (*prepare)(void), void (*parent)(void), void(*child)(void)); +int pthread_attr_destroy(pthread_attr_t* attr); +int pthread_attr_getdetachstate(const pthread_attr_t* attr, int* detachstate); +int pthread_attr_getguardsize(const pthread_attr_t* __restrict attr, size_t* __restrict guardsize); +int pthread_attr_getinheritsched(const pthread_attr_t* __restrict attr, int* __restrict inheritsched); +int pthread_attr_getschedparam(const pthread_attr_t* __restrict attr, struct sched_param* __restrict param); +int pthread_attr_getschedpolicy(const pthread_attr_t* __restrict attr, int* __restrict policy); +int pthread_attr_getscope(const pthread_attr_t* __restrict attr, int* __restrict contentionscope); +int pthread_attr_getstack(const pthread_attr_t* __restrict attr, void** __restrict stackaddr, size_t* __restrict stacksize); +int pthread_attr_getstacksize(const pthread_attr_t* __restrict attr, size_t* __restrict stacksize); +int pthread_attr_init(pthread_attr_t* attr); +int pthread_attr_setdetachstate(pthread_attr_t* attr, int detachstate); +int pthread_attr_setguardsize(pthread_attr_t* attr, size_t guardsize); +int pthread_attr_setinheritsched(pthread_attr_t* attr, int inheritsched); +int pthread_attr_setschedparam(pthread_attr_t* __restrict attr, const struct sched_param* __restrict param); +int pthread_attr_setschedpolicy(pthread_attr_t* attr, int policy); +int pthread_attr_setscope(pthread_attr_t* attr, int contentionscope); +int pthread_attr_setstack(pthread_attr_t* attr, void* stackaddr, size_t stacksize); +int pthread_attr_setstacksize(pthread_attr_t* attr, size_t stacksize); +int pthread_barrier_destroy(pthread_barrier_t* barrier); +int pthread_barrier_init(pthread_barrier_t* __restrict barrier, const pthread_barrierattr_t* __restrict attr, unsigned count); +int pthread_barrier_wait(pthread_barrier_t* barrier); +int pthread_barrierattr_destroy(pthread_barrierattr_t* attr); +int pthread_barrierattr_getpshared( const pthread_barrierattr_t* __restrict attr, int* __restrict pshared); +int pthread_barrierattr_init(pthread_barrierattr_t* attr); +int pthread_barrierattr_setpshared(pthread_barrierattr_t* attr, int pshared); +int pthread_cancel(pthread_t thread); +int pthread_cond_broadcast(pthread_cond_t* cond); +int pthread_cond_destroy(pthread_cond_t* cond); +int pthread_cond_init(pthread_cond_t* __restrict cond, const pthread_condattr_t* __restrict attr); +int pthread_cond_signal(pthread_cond_t* cond); +int pthread_cond_timedwait(pthread_cond_t* __restrict cond, pthread_mutex_t* __restrict mutex, const struct timespec* __restrict abstime); +int pthread_cond_wait(pthread_cond_t* __restrict cond, pthread_mutex_t* __restrict mutex); +int pthread_condattr_destroy(pthread_condattr_t* attr); +int pthread_condattr_getclock(const pthread_condattr_t* __restrict attr, clockid_t* __restrict clock_id); +int pthread_condattr_getpshared(const pthread_condattr_t* __restrict attr, int* __restrict pshared); +int pthread_condattr_init(pthread_condattr_t* attr); +int pthread_condattr_setclock(pthread_condattr_t* attr, clockid_t clock_id); +int pthread_condattr_setpshared(pthread_condattr_t* attr, int pshared); +int pthread_create(pthread_t* __restrict thread, const pthread_attr_t* __restrict attr, void *(*start_routine)(void*), void* __restrict arg); +int pthread_detach(pthread_t thread); +int pthread_equal(pthread_t t1, pthread_t t2); +void pthread_exit(void* value_ptr); +int pthread_getconcurrency(void); +int pthread_getcpuclockid(pthread_t thread_id, clockid_t* clock_id); +int pthread_getschedparam(pthread_t thread, int* __restrict policy, struct sched_param* __restrict param); +void* pthread_getspecific(pthread_key_t key); +int pthread_join(pthread_t thread, void** value_ptr); +int pthread_key_create(pthread_key_t* key, void (*destructor)(void*)); +int pthread_key_delete(pthread_key_t key); +int pthread_mutex_consistent(pthread_mutex_t* mutex); +int pthread_mutex_destroy(pthread_mutex_t* mutex); +int pthread_mutex_getprioceiling(const pthread_mutex_t* __restrict mutex, int* __restrict prioceiling); +int pthread_mutex_init(pthread_mutex_t* __restrict mutex, const pthread_mutexattr_t* __restrict attr); +int pthread_mutex_lock(pthread_mutex_t* mutex); +int pthread_mutex_setprioceiling(pthread_mutex_t* __restrict mutex, int prioceiling, int* __restrict old_ceiling); +int pthread_mutex_timedlock(pthread_mutex_t* __restrict mutex, const struct timespec* __restrict abstime); +int pthread_mutex_trylock(pthread_mutex_t* mutex); +int pthread_mutex_unlock(pthread_mutex_t* mutex); +int pthread_mutexattr_destroy(pthread_mutexattr_t* attr); +int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t* __restrict attr, int* __restrict prioceiling); +int pthread_mutexattr_getprotocol(const pthread_mutexattr_t* __restrict attr, int* __restrict protocol); +int pthread_mutexattr_getpshared(const pthread_mutexattr_t* __restrict attr, int* __restrict pshared); +int pthread_mutexattr_getrobust(const pthread_mutexattr_t* __restrict attr, int* __restrict robust); +int pthread_mutexattr_gettype(const pthread_mutexattr_t* __restrict attr, int* __restrict type); +int pthread_mutexattr_init(pthread_mutexattr_t* attr); +int pthread_mutexattr_setprioceiling(pthread_mutexattr_t* attr, int prioceiling); +int pthread_mutexattr_setprotocol(pthread_mutexattr_t* attr, int protocol); +int pthread_mutexattr_setpshared(pthread_mutexattr_t* attr, int pshared); +int pthread_mutexattr_setrobust(pthread_mutexattr_t* attr, int robust); +int pthread_mutexattr_settype(pthread_mutexattr_t* attr, int type); +int pthread_once(pthread_once_t* once_control, void (*init_routine)(void)); +int pthread_rwlock_destroy(pthread_rwlock_t* rwlock); +int pthread_rwlock_init(pthread_rwlock_t* __restrict rwlock, const pthread_rwlockattr_t* __restrict attr); +int pthread_rwlock_rdlock(pthread_rwlock_t* rwlock); +int pthread_rwlock_timedrdlock(pthread_rwlock_t* __restrict rwlock, const struct timespec* __restrict abstime); +int pthread_rwlock_timedwrlock(pthread_rwlock_t* __restrict rwlock, const struct timespec* __restrict abstime); +int pthread_rwlock_tryrdlock(pthread_rwlock_t* rwlock); +int pthread_rwlock_trywrlock(pthread_rwlock_t* rwlock); +int pthread_rwlock_unlock(pthread_rwlock_t* rwlock); +int pthread_rwlock_wrlock(pthread_rwlock_t* rwlock); +int pthread_rwlockattr_destroy(pthread_rwlockattr_t* attr); +int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t* __restrict attr, int* __restrict pshared); +int pthread_rwlockattr_init(pthread_rwlockattr_t* attr); +int pthread_rwlockattr_setpshared(pthread_rwlockattr_t* attr, int pshared); +pthread_t pthread_self(void); +int pthread_setcancelstate(int state, int* oldstate); +int pthread_setcanceltype(int type, int* oldtype); +int pthread_setconcurrency(int new_level); +int pthread_setschedparam(pthread_t thread, int policy, const struct sched_param* param); +int pthread_setschedprio(pthread_t thread, int prio); +int pthread_setspecific(pthread_key_t key, const void* value); +int pthread_spin_destroy(pthread_spinlock_t* lock); +int pthread_spin_init(pthread_spinlock_t* lock, int pshared); +int pthread_spin_lock(pthread_spinlock_t* lock); +int pthread_spin_trylock(pthread_spinlock_t* lock); +int pthread_spin_unlock(pthread_spinlock_t* lock); +void pthread_testcancel(void); + +void pthread_cleanup_pop(int execute); +void pthread_cleanup_push(void (*routine)(void*), void* arg); + +__END_DECLS + +#endif diff --git a/libc/include/pwd.h b/libc/include/pwd.h new file mode 100644 index 0000000000..20e9105898 --- /dev/null +++ b/libc/include/pwd.h @@ -0,0 +1,34 @@ +#ifndef _PWD_H +#define _PWD_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/pwd.h.html + +#include + +__BEGIN_DECLS + +#define __need_gid_t +#define __need_uid_t +#define __need_size_t +#include + +struct passwd +{ + char* pw_name; /* User's login name. */ + uid_t pw_uid; /* Numerical user ID. */ + gid_t pw_gid; /* Numerical group ID. */ + char* pw_dir; /* Initial working directory. */ + char* pw_shell; /* Program to use as shell. */ +}; + +void endpwent(void); +struct passwd* getpwent(void); +struct passwd* getpwnam(const char* name); +int getpwnam_r(const char* name, struct passwd* pwd, char* buffer, size_t bufsize, struct passwd** result); +struct passwd* getpwuid(uid_t uid); +int getpwuid_r(uid_t uid, struct passwd* pwd, char* buffer, size_t bufsize, struct passwd** result); +void setpwent(void); + +__END_DECLS + +#endif diff --git a/libc/include/regex.h b/libc/include/regex.h new file mode 100644 index 0000000000..f84badf8a2 --- /dev/null +++ b/libc/include/regex.h @@ -0,0 +1,54 @@ +#ifndef _REGEX_H +#define _REGEX_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/regex.h.html + +#include + +__BEGIN_DECLS + +#define __need_size_t +#include + +typedef struct +{ + size_t re_nsub; +} regex_t; + +typedef __PTRDIFF_TYPE__ regoff_t; + +typedef struct +{ + regoff_t rm_so; /* Byte offset from start of string to start of substring. */ + regoff_t rm_eo; /* Byte offset from start of string of the first character after the end of substring. */ +} regmatch_t; + +#define REG_EXTENDED 0x01 +#define REG_ICASE 0x02 +#define REG_NOSUB 0x04 +#define REG_NEWLINE 0x80 + +#define REG_NOTBOL 0x0001 +#define REG_NOTEOL 0x0002 +#define REG_NOMATCH 0x0004 +#define REG_BADPAT 0x0008 +#define REG_ECOLLATE 0x0010 +#define REG_ECTYPE 0x0020 +#define REG_EESCAPE 0x0040 +#define REG_ESUBREG 0x0080 +#define REG_EBRACK 0x0100 +#define REG_EPAREN 0x0200 +#define REG_EBRACE 0x0400 +#define REG_BADBR 0x0800 +#define REG_ERANGE 0x1000 +#define REG_ESPACE 0x2000 +#define REG_BADRPT 0x4000 + +int regcomp(regex_t* __restrict preg, const char* __restrict pattern, int cflags); +size_t regerror(int errcode, const regex_t* __restrict preg, char* __restrict errbuf, size_t errbuf_size); +int regexec(const regex_t* __restrict preg, const char* __restrict string, size_t nmatch, regmatch_t pmatch[__restrict], int eflags); +void regfree(regex_t* preg); + +__END_DECLS + +#endif diff --git a/libc/include/sched.h b/libc/include/sched.h new file mode 100644 index 0000000000..05935b6db7 --- /dev/null +++ b/libc/include/sched.h @@ -0,0 +1,40 @@ +#ifndef _SCHED_H +#define _SCHED_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sched.h.html + +#include + +__BEGIN_DECLS + +#include + +#define __need_pid_t +#include + +struct sched_param +{ + int sched_priority; /* Process or thread execution scheduling priority. */ + int sched_ss_low_priority; /* Low scheduling priority for sporadic server. */ + struct timespec sched_ss_repl_period; /* Replenishment period for sporadic server. */ + struct timespec sched_ss_init_budget; /* Initial budget for sporadic server. */ + int sched_ss_max_repl; /* Maximum pending replenishments for sporadic server. */ +}; + +#define SCHED_FIFO 1 +#define SCHED_RR 2 +#define SCHED_SPORADIC 3 +#define SCHED_OTHER 4 + +int sched_get_priority_max(int policy); +int sched_get_priority_min(int policy); +int sched_getparam(pid_t pid, struct sched_param* param); +int sched_getscheduler(pid_t pid); +int sched_rr_get_interval(pid_t pid, struct timespec* interval); +int sched_setparam(pid_t pid, const struct sched_param* param); +int sched_setscheduler(pid_t pid, int, const struct sched_param* param); +int sched_yield(void); + +__END_DECLS + +#endif diff --git a/libc/include/search.h b/libc/include/search.h new file mode 100644 index 0000000000..b7e893ea32 --- /dev/null +++ b/libc/include/search.h @@ -0,0 +1,36 @@ +#ifndef _SEARCH_H +#define _SEARCH_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/search.h.html + +#include + +__BEGIN_DECLS + +#define __need_size_t +#include + +typedef struct +{ + char* key; + void* data; +} ENTRY; + +typedef enum { FIND, ENTER } ACTION; +typedef enum { preorder, postorder, endorder, leaf } VISIT; + +int hcreate(size_t nel); +void hdestroy(void); +ENTRY* hsearch(ENTRY item, ACTION action); +void insque(void* element, void* pred); +void* lfind(const void* key, const void* base, size_t* nelp, size_t width, int (*compar)(const void*, const void*)); +void* lsearch(const void* key, void* base, size_t* nelp, size_t width, int (*compar)(const void*, const void*)); +void remque(void* element); +void* tdelete(const void* __restrict key, void** __restrict rootp, int(*compar)(const void*, const void*)); +void* tfind(const void* key, void* const* rootp, int(*compar)(const void*, const void*)); +void* tsearch(const void* key, void** rootp, int(*compar)(const void*, const void*)); +void twalk(const void* root, void (*action)(const void*, VISIT, int)); + +__END_DECLS + +#endif diff --git a/libc/include/semaphore.h b/libc/include/semaphore.h new file mode 100644 index 0000000000..15c343f4d1 --- /dev/null +++ b/libc/include/semaphore.h @@ -0,0 +1,30 @@ +#ifndef _SEMAPHORE_H +#define _SEMAPHORE_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/semaphore.h.html + +#include + +__BEGIN_DECLS + +#include +#include + +typedef void* sem_t; + +#define SEM_FAILED ((sem_t*)0) + +int sem_close(sem_t* sem); +int sem_destroy(sem_t* sem); +int sem_getvalue(sem_t* __restrict sem, int* __restrict sval); +int sem_init(sem_t* sem, int pshared, unsigned value); +sem_t* sem_open(const char* name, int oflag, ...); +int sem_post(sem_t* sem); +int sem_timedwait(sem_t* __restrict sem, const struct timespec* __restrict abstime); +int sem_trywait(sem_t* sem); +int sem_unlink(const char* name); +int sem_wait(sem_t* sem); + +__END_DECLS + +#endif diff --git a/libc/include/setjmp.h b/libc/include/setjmp.h index 12394f6741..20f76ea80f 100644 --- a/libc/include/setjmp.h +++ b/libc/include/setjmp.h @@ -1,19 +1,20 @@ -#pragma once - -#include +#ifndef _SETJMP_H +#define _SETJMP_H 1 // https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/setjmp.h.html +#include + __BEGIN_DECLS -typedef int* jmp_buf; -typedef int* sigjmp_buf; +typedef int jmp_buf[1]; +typedef int sigjmp_buf[1]; -void _longjmp(jmp_buf, int); -void longjmp(jmp_buf, int); -void siglongjmp(sigjmp_buf, int); -int _setjmp(jmp_buf); -int setjmp(jmp_buf); -int sigsetjmp(sigjmp_buf, int); +void longjmp(jmp_buf env, int val); +void siglongjmp(sigjmp_buf env, int val); +int setjmp(jmp_buf env); +int sigsetjmp(sigjmp_buf env, int savemask); __END_DECLS + +#endif diff --git a/libc/include/signal.h b/libc/include/signal.h index a4ca9127c5..931607c46a 100644 --- a/libc/include/signal.h +++ b/libc/include/signal.h @@ -1,12 +1,167 @@ -#pragma onces +#ifndef _SIGNAL_H +#define _SIGNAL_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/signal.h.html #include __BEGIN_DECLS -typedef int sig_atomic_t; +#include -int raise(int); -void (*signal(int, void (*)(int)))(int); +#define SIG_DFL 1 +#define SIG_ERR 2 +#define SIG_HOLD 3 +#define SIG_IGN 4 + +#define __need_pthread_t +#define __need_size_t +#define __need_uid_t +#define __need_pid_t +#define __need_pthread_attr_t +#include + +typedef int sigatomic_t; +typedef void* sigset_t; + +union sigval +{ + int sival_int; /* Integer signal value. */ + void* sival_ptr; /* Pointer signal value. */ +}; + +struct sigevent +{ + int sigev_notify; /* Notification type. */ + int sigev_signo; /* Signal number. */ + union sigval sigev_value; /* Signal value. */ + void (*sigev_notify_function)(union sigval); /* Notification function. */ + pthread_attr_t* sigev_notify_attributes; /* Notification attributes. */ +}; + +#define SIGEV_NONE 1 +#define SIGEV_SIGNAL 2 +#define SIGEV_THREAD 3 + +#define SIGABRT 1 +#define SIGALRM 2 +#define SIGBUS 3 +#define SIGCHLD 4 +#define SIGCONT 5 +#define SIGFPE 6 +#define SIGHUP 7 +#define SIGILL 8 +#define SIGINT 9 +#define SIGKILL 10 +#define SIGPIPE 11 +#define SIGQUIT 12 +#define SIGSEGV 13 +#define SIGSTOP 14 +#define SIGTERM 15 +#define SIGTSTP 16 +#define SIGTTIN 17 +#define SIGTTOU 18 +#define SIGUSR1 19 +#define SIGUSR2 20 +#define SIGPOLL 21 +#define SIGPROF 22 +#define SIGSYS 23 +#define SIGTRAP 24 +#define SIGURG 25 +#define SIGVTALRM 26 +#define SIGXCPU 27 +#define SIGXFSZ 28 +#define SIGRTMIN 29 +#define SIGRTMAX (SIGRTMIN+32) + +#define SIG_BLOCK 1 +#define SIG_UNBLOCK 2 +#define SIG_SETMASK 3 + +#define SA_NOCLDSTOP 0x001 +#define SA_ONSTACK 0x002 +#define SA_RESETHAND 0x004 +#define SA_RESTART 0x008 +#define SA_SIGINFO 0x010 +#define SA_NOCLDWAIT 0x020 +#define SA_NODEFER 0x040 +#define SS_ONSTACK 0x080 +#define SS_DISABLE 0x100 +#define MINSIGSTKSZ 0x200 +#define SIGSTKSZ 0x400 + +typedef struct +{ + void** ss_sp; /* Stack base or pointer. */ + size_t ss_size; /* Stack size. */ + int ss_flags; /* Flags. */ +} stack_t; + +typedef struct {} mcontext_t; + +typedef struct __ucontext_t +{ + struct __ucontext_t* uc_link; /* Pointer to the context that is resumed when this context returns. */ + sigset_t uc_sigmask; /* The set of signals that are blocked when this context is active. */ + stack_t uc_stack; /* The stack used by this context. */ + mcontext_t uc_mcontext; /* A machine-specific representation of the saved context. */ +} ucontext_t; + +typedef struct +{ + int si_signo; /* Signal number. */ + int si_code; /* Signal code. */ + int si_errno; /* If non-zero, an errno value associated with this signal, as described in . */ + pid_t si_pid; /* Sending process ID. */ + uid_t si_uid; /* Real user ID of sending process. */ + void* si_addr; /* Address of faulting instruction. */ + int si_status; /* Exit value or signal. */ + long si_band; /* Band event for SIGPOLL. */ + union sigval si_value; /* Signal value. */ +} siginfo_t; + +struct sigaction +{ + void (*sa_handler)(int); /* Pointer to a signal-catching function or one of the SIG_IGN or SIG_DFL. */ + sigset_t sa_mask; /* Set of signals to be blocked during execution of the signal handling function. */ + int sa_flags; /* Special flags. */ + void (*sa_sigaction)(int, siginfo_t*, void*); /* Pointer to a signal-catching function. */ +}; + +// TODO: The header shall define the symbolic constants in the +// Code column of the following table for use as values of si_code +// that are signal-specific or non-signal-specific reasons why the +// signal was generated. + +int kill(pid_t pid, int sig); +int killpg(pid_t pgpr, int sig); +void psiginfo(const siginfo_t* pinfo, const char* message); +void psignal(int signum, const char* message); +int pthread_kill(pthread_t thread, int sig); +int pthread_sigmask(int how, const sigset_t* __restrict set, sigset_t* __restrict oset); +int raise(int sig); +int sigaction(int sig, const struct sigaction* __restrict act, struct sigaction* __restrict oact); +int sigaddset(sigset_t* set, int signo); +int sigaltstack(const stack_t* __restrict ss, stack_t* __restrict oss); +int sigdelset(sigset_t* set, int signo); +int sigemptyset(sigset_t* set); +int sigfillset(sigset_t* set); +int sighold(int sig); +int sigignore(int sig); +int siginterrupt(int sig, int flag); +int sigismember(const sigset_t* set, int signo); +void (*signal(int sig, void (*func)(int)))(int); +int sigpause(int sig); +int sigpending(sigset_t* set); +int sigprocmask(int how, const sigset_t* __restrict set, sigset_t* __restrict oset); +int sigqueue(pid_t pid, int signo, union sigval value); +int sigrelse(int sig); +void (*sigset(int sig, void (*disp)(int)))(int); +int sigsuspend(const sigset_t* sigmask); +int sigtimedwait(const sigset_t* __restrict set, siginfo_t* __restrict info, const struct timespec* __restrict timeout); +int sigwait(const sigset_t* __restrict set, int* __restrict sig); +int sigwaitinfo(const sigset_t* __restrict set, siginfo_t* __restrict info); __END_DECLS + +#endif diff --git a/libc/include/spawn.h b/libc/include/spawn.h new file mode 100644 index 0000000000..8319cf2dca --- /dev/null +++ b/libc/include/spawn.h @@ -0,0 +1,51 @@ +#ifndef _SPAWN_H +#define _SPAWN_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/spawn.h.html + +#include + +__BEGIN_DECLS + +#include +#include + +#define __need_mode_t +#define __need_pid_t +#include + +typedef int posix_spawnattr_t; +typedef int posix_spawn_file_actions_t; + +#define POSIX_SPAWN_RESETIDS 0x01 +#define POSIX_SPAWN_SETPGROUP 0x02 +#define POSIX_SPAWN_SETSCHEDPARAM 0x04 +#define POSIX_SPAWN_SETSCHEDULER 0x08 +#define POSIX_SPAWN_SETSIGDEF 0x10 +#define POSIX_SPAWN_SETSIGMASK 0x20 + +int posix_spawn(pid_t* __restrict pid, const char* __restrict path, const posix_spawn_file_actions_t* file_actions, const posix_spawnattr_t* __restrict attrp, char* const argv[__restrict], char* const envp[__restrict]); +int posix_spawn_file_actions_addclose(posix_spawn_file_actions_t* file_actions, int fildes); +int posix_spawn_file_actions_adddup2(posix_spawn_file_actions_t* file_actions, int fildes, int newfildes); +int posix_spawn_file_actions_addopen(posix_spawn_file_actions_t* __restrict file_actions, int fildes, const char* __restrict path, int oflag, mode_t mode); +int posix_spawn_file_actions_destroy(posix_spawn_file_actions_t* file_actions); +int posix_spawn_file_actions_init(posix_spawn_file_actions_t* file_actions); +int posix_spawnattr_destroy(posix_spawnattr_t* attr); +int posix_spawnattr_getflags(const posix_spawnattr_t* __restrict attr, short* __restrict flags); +int posix_spawnattr_getpgroup(const posix_spawnattr_t* __restrict attr, pid_t* __restrict pgroup); +int posix_spawnattr_getschedparam(const posix_spawnattr_t* __restrict attr, struct sched_param* __restrict schedparam); +int posix_spawnattr_getschedpolicy(const posix_spawnattr_t* __restrict attr, int* __restrict schedpolicy); +int posix_spawnattr_getsigdefault(const posix_spawnattr_t* __restrict attr, sigset_t* __restrict sigdefault); +int posix_spawnattr_getsigmask(const posix_spawnattr_t* __restrict attr, sigset_t* __restrict sigmask); +int posix_spawnattr_init(posix_spawnattr_t* attr); +int posix_spawnattr_setflags(posix_spawnattr_t* attr, short flags); +int posix_spawnattr_setpgroup(posix_spawnattr_t* attr, pid_t pgroup); +int posix_spawnattr_setschedparam(posix_spawnattr_t* __restrict attr, const struct sched_param* __restrict schedparam); +int posix_spawnattr_setschedpolicy(posix_spawnattr_t* attr, int schedpolicy); +int posix_spawnattr_setsigdefault(posix_spawnattr_t* __restrict attr, const sigset_t* __restrict sigdefault); +int posix_spawnattr_setsigmask(posix_spawnattr_t* __restrict attr, const sigset_t* __restrict sigmask); +int posix_spawnp(pid_t* __restrict pid, const char* __restrict file, const posix_spawn_file_actions_t* file_actions, const posix_spawnattr_t* __restrict attrp, char* const argc[__restrict], char* const envp[__restrict]); + +__END_DECLS + +#endif diff --git a/libc/include/stdint.h b/libc/include/stdint.h new file mode 100644 index 0000000000..85b5390ca8 --- /dev/null +++ b/libc/include/stdint.h @@ -0,0 +1,117 @@ +#ifndef _STDINT_H +#define _STDINT_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/stdint.h.html + +#include + +__BEGIN_DECLS + +typedef __INT8_TYPE__ int8_t; +typedef __INT16_TYPE__ int16_t; +typedef __INT32_TYPE__ int32_t; +typedef __INT64_TYPE__ int64_t; + +typedef __UINT8_TYPE__ uint8_t; +typedef __UINT16_TYPE__ uint16_t; +typedef __UINT32_TYPE__ uint32_t; +typedef __UINT64_TYPE__ uint64_t; + +typedef __INT_LEAST8_TYPE__ int_least8_t; +typedef __INT_LEAST16_TYPE__ int_least16_t; +typedef __INT_LEAST32_TYPE__ int_least32_t; +typedef __INT_LEAST64_TYPE__ int_least64_t; + +typedef __UINT_LEAST8_TYPE__ uint_least8_t; +typedef __UINT_LEAST16_TYPE__ uint_least16_t; +typedef __UINT_LEAST32_TYPE__ uint_least32_t; +typedef __UINT_LEAST64_TYPE__ uint_least64_t; + +typedef __INT_FAST8_TYPE__ int_fast8_t; +typedef __INT_FAST16_TYPE__ int_fast16_t; +typedef __INT_FAST32_TYPE__ int_fast32_t; +typedef __INT_FAST64_TYPE__ int_fast64_t; + +typedef __UINT_FAST8_TYPE__ uint_fast8_t; +typedef __UINT_FAST16_TYPE__ uint_fast16_t; +typedef __UINT_FAST32_TYPE__ uint_fast32_t; +typedef __UINT_FAST64_TYPE__ uint_fast64_t; + +typedef __INTPTR_TYPE__ intptr_t; +typedef __UINTPTR_TYPE__ uintptr_t; + +// FIXME: is this the correct? +typedef int64_t intmax_t; +typedef uint64_t uintmax_t; + +#define INT8_MIN (-INT8_MAX - 1) +#define INT16_MIN (-INT16_MAX - 1) +#define INT32_MIN (-INT32_MAX - 1) +#define INT64_MIN (-INT64_MAX - 1) + +#define INT8_MAX __INT8_MAX__ +#define INT16_MAX __INT16_MAX__ +#define INT32_MAX __INT32_MAX__ +#define INT64_MAX __INT64_MAX__ + +#define UINT8_MAX __UINT8_MAX__ +#define UINT16_MAX __UINT16_MAX__ +#define UINT32_MAX __UINT32_MAX__ +#define UINT64_MAX __UINT64_MAX__ + +#define INT_LEAST8_MIN (-INT_LEAST8_MAX - 1) +#define INT_LEAST16_MIN (-INT_LEAST16_MAX - 1) +#define INT_LEAST32_MIN (-INT_LEAST32_MAX - 1) +#define INT_LEAST64_MIN (-INT_LEAST64_MAX - 1) + +#define INT_LEAST8_MAX __INT_LEAST8_MAX__ +#define INT_LEAST16_MAX __INT_LEAST16_MAX__ +#define INT_LEAST32_MAX __INT_LEAST32_MAX__ +#define INT_LEAST64_MAX __INT_LEAST64_MAX__ + +#define UINT_LEAST8_MAX __UINT_LEAST8_MAX__ +#define UINT_LEAST16_MAX __UINT_LEAST16_MAX__ +#define UINT_LEAST32_MAX __UINT_LEAST32_MAX__ +#define UINT_LEAST64_MAX __UINT_LEAST64_MAX__ + +#define INT_FAST8_MIN (-INT_FAST8_MAX - 1) +#define INT_FAST16_MIN (-INT_FAST16_MAX - 1) +#define INT_FAST32_MIN (-INT_FAST32_MAX - 1) +#define INT_FAST64_MIN (-INT_FAST64_MAX - 1) + +#define INT_FAST8_MAX __INT_FAST8_MAX__ +#define INT_FAST16_MAX __INT_FAST16_MAX__ +#define INT_FAST32_MAX __INT_FAST32_MAX__ +#define INT_FAST64_MAX __INT_FAST64_MAX__ + +#define UINT_FAST8_MAX __UINT_FAST8_MAX__ +#define UINT_FAST16_MAX __UINT_FAST16_MAX__ +#define UINT_FAST32_MAX __UINT_FAST32_MAX__ +#define UINT_FAST64_MAX __UINT_FAST64_MAX__ + +#define INTPTR_MIN (-INTPTR_MAX - 1) +#define INTPTR_MAX __INTPTR_MAX__ +#define UINPTR_MAX __UINTPTR_MAX__ + +// FIXME: is this the correct? +#define INTMAX_MIN INT64_MIN +#define INTMAX_MAX INT64_MAX +#define UINTMAX_MAX UINT64_MAX + +#define PTRDIFF_MIN -65535 +#define PTRDIFF_MAX +65535 + +#define SIG_ATOMIC_MIN __SIG_ATOMIC_MIN__ +#define SIG_ATOMIC_MAX __SIG_ATOMIC_MAX__ + +#define SIZE_MAX __SIZE_MAX__ + +#define WCHAR_MIN __WCHAR_MIN__ +#define WCHAR_MAX __WCHAR_MAX__ + +#define WINT_MIN __WINT_MIN__ +#define WINT_MAX __WINT_MAX__ + +__END_DECLS + +#endif diff --git a/libc/include/stdio.h b/libc/include/stdio.h index 5ba7ebbd7c..bf3a37db04 100644 --- a/libc/include/stdio.h +++ b/libc/include/stdio.h @@ -1,106 +1,128 @@ -#pragma once +#ifndef _STDIO_H +#define _STDIO_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/stdio.h.html -#include -#include #include + +__BEGIN_DECLS + +#define __need_off_t +#define __need_ssize_t #include -#define EOF (-1) +#ifndef __va_list_defined + #define __va_list_defined + #define __need___va_list + #include + typedef __gnuc_va_list va_list; +#endif -#define stdin stdin -#define stdout stdout -#define stderr stderr +#define __need_size_t +#define __need_NULL +#include -#define SEEK_CUR 1 -#define SEEK_END 2 -#define SEEK_SET 3 +#include + +typedef off_t fpos_t; + +#define BUFSIZ 1024 +#define L_ctermid 20 +#define L_tmpnam 20 #define _IOFBF 1 #define _IOLBF 2 #define _IONBF 3 -#define EXIT_FAILURE 1 -#define EXIT_SUCCESS 0 - -#define L_ctermid 50 - -#define BUFSIZ 128 +// NOTE: also defined in fcntl.h +#define SEEK_SET 1 +#define SEEK_CUR 2 +#define SEEK_END 3 +#define FILENAME_MAX 256 #define FOPEN_MAX 16 +#define TMP_MAX 10000 -__BEGIN_DECLS +#define EOF (-1) -struct FILE; -typedef struct FILE FILE; +#define P_tmpdir "/tmp" -typedef uint64_t fpos_t; +extern FILE* __stdin; +#define stdin __stdin +extern FILE* __stdout; +#define stdout __stdout +extern FILE* __stderr; +#define stderr __stderr -extern FILE* stdin; -extern FILE* stdout; -extern FILE* stderr; - - -// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/stdio.h.html -void clearerr(FILE*); -char* ctermid(char*); -int fclose(FILE*); -FILE* fdopen(int, const char*); -int feof(FILE*); -int ferror(FILE*); -int fflush(FILE*); -int fgetc(FILE*); -int fgetpos(FILE*, fpos_t*); -char* fgets(char*, int, FILE*); -int fileno(FILE*); -void flockfile(FILE*); -FILE* fopen(const char*, const char*); -int fprintf(FILE*, const char*, ...); -int fputc(int, FILE*); -int fputs(const char*, FILE*); -size_t fread(void*, size_t, size_t, FILE*); -FILE* freopen(const char*, const char*, FILE*); -int fscanf(FILE*, const char*, ...); -int fseek(FILE*, long, int); -int fseeko(FILE*, off_t, int); -int fsetpos(FILE*, const fpos_t*); -long ftell(FILE*); -off_t ftello(FILE*); -int ftrylockfile(FILE*); -void funlockfile(FILE*); -size_t fwrite(const void*, size_t, size_t, FILE*); -int getc(FILE*); +void clearerr(FILE* stream); +char* ctermid(char* s); +int dprintf(int fildes, const char* __restrict format, ...); +int fclose(FILE* stream); +FILE* fdopen(int fildes, const char* mode); +int feof(FILE* stream); +int ferror(FILE* stream); +int fflush(FILE* stream); +int fgetc(FILE* stream); +int fgetpos(FILE* __restrict stream, fpos_t* __restrict pos); +char* fgets(char* __restrict s, int n, FILE* __restrict stream); +int fileno(FILE* stream); +void flockfile(FILE* stream); +FILE* fmemopen(void* __restrict buf, size_t size, const char* __restrict mode); +FILE* fopen(const char* __restrict pathname, const char* __restrict mode); +int fprintf(FILE* __restrict stream, const char* __restrict format, ...); +int fputc(int c, FILE* stream); +int fputs(const char* __restrict s, FILE* __restrict stream); +size_t fread(void* __restrict buf, size_t size, size_t nitems, FILE* __restrict stream); +FILE* freopen(const char* __restrict pathname, const char* __restrict mode, FILE* __restrict stream); +int fscanf(FILE* __restrict stream, const char* __restrict format, ...); +int fseek(FILE* stream, long offset, int whence); +int fseeko(FILE* stream, off_t offset, int whence); +int fsetpos(FILE* stream, const fpos_t* pos); +long ftell(FILE* stream); +off_t ftello(FILE* stream); +int ftrylockfile(FILE* stream); +void funlockfile(FILE* stream); +size_t fwrite(const void* __restrict ptr, size_t size, size_t nitems, FILE* __restrict stream); +int getc(FILE* stream); int getchar(void); -int getc_unlocked(FILE*); +int getc_unlocked(FILE* stream); int getchar_unlocked(void); -char* gets(char*); -int pclose(FILE*); -void perror(const char*); -FILE* popen(const char*, const char*); -int printf(const char*, ...); -int putc(int, FILE*); -int putchar(int); -int putc_unlocked(int, FILE*); -int putchar_unlocked(int); -int puts(const char*); -int remove(const char*); -int rename(const char*, const char*); -void rewind(FILE*); -int scanf(const char*, ...); -void setbuf(FILE*, char*); -int setvbuf(FILE*, char*, int, size_t); -int snprintf(char*, size_t, const char*, ...); -int sprintf(char*, const char*, ...); -int sscanf(const char*, const char*, ...); -char* tempnam(const char*, const char*); +ssize_t getdelim(char** __restrict lineptr, size_t* __restrict n, int delimeter, FILE* __restrict stream); +ssize_t getline(char** __restrict lineptr, size_t* __restrict n, FILE* __restrict stream); +char* gets(char* s); +FILE* open_memstream(char** bufp, size_t* sizep); +int pclose(FILE* stream); +void perror(const char* s); +FILE* popen(const char* command, const char* mode); +int printf(const char* __restrict format, ...); +int putc(int c, FILE* stream); +int putchar(int c); +int putc_unlocked(int c, FILE* stream); +int putchar_unlocked(int c); +int puts(const char* s); +int remove(const char* path); +int rename(const char* old, const char* _new); +int renameat(int oldfd, const char* old, int newfd, const char* _new); +void rewind(FILE* stream); +int scanf(const char* __restrict format, ...); +void setbuf(FILE* __restrict stream, char* __restrict buf); +int setvbuf(FILE* __restrict stream, char* __restrict buf, int type, size_t size); +int snprintf(char* __restrict s, size_t n, const char* __restrict format, ...); +int sprintf(char* __restrict s, const char* __restrict format, ...); +int sscanf(const char* __restrict s, const char* __restrict format, ...); +char* tempnam(const char* dir, const char* pfx); FILE* tmpfile(void); -char* tmpnam(char*); -int ungetc(int, FILE*); -int vfprintf(FILE*, const char*, va_list); -int vfscanf(FILE*, const char*, va_list); -int vprintf(const char*, va_list); -int vscanf(const char*, va_list); -int vsnprintf(char*, size_t, const char*, va_list); -int vsprintf(char*, const char*, va_list); -int vsscanf(const char*, const char*, va_list); +char* tmpnam(char* s); +int ungetc(int c, FILE* stream); +int vdprintf(int fildes, const char* __restrict format, va_list ap); +int vfprintf(FILE* __restrict stream, const char* __restrict format, va_list ap); +int vfscanf(FILE* __restrict stream, const char* __restrict format, va_list arg); +int vprintf(const char* __restrict format, va_list ap); +int vscanf(const char* __restrict format, va_list arg); +int vsnprintf(char* __restrict s, size_t n, const char* __restrict format, va_list ap); +int vsprintf(char* __restrict s, const char* __restrict format, va_list ap); +int vsscanf(const char* __restrict s, const char* __restrict format, va_list arg); __END_DECLS + +#endif diff --git a/libc/include/stdlib.h b/libc/include/stdlib.h index b189c4a670..b2d6702dcb 100644 --- a/libc/include/stdlib.h +++ b/libc/include/stdlib.h @@ -1,93 +1,108 @@ -#pragma once +#ifndef _STDLIB_H +#define _STDLIB_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/stdlib.h.html -#include #include __BEGIN_DECLS +#include +#include +#include +#include + +#define EXIT_FAILURE 1 +#define EXIT_SUCCESS 0 + +#define RAND_MAX INT32_MAX + +#define MB_CUR_MAX ((size_t)4) + typedef struct { - int quot; - int rem; + int quot; /* quotient */ + int rem; /* remainder */ } div_t; typedef struct { - long quot; - long rem; + long quot; /* quotient */ + long rem; /* remainder */ } ldiv_t; typedef struct { - long long quot; - long long rem; + long long quot; /* quotient */ + long long rem; /* remainder */ } lldiv_t; -// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/stdlib.h.html -void _Exit(int); -long a64l(const char*); -void abort(void); -int abs(int); -int atexit(void (*)(void)); -double atof(const char*); -int atoi(const char*); -long atol(const char*); -long long atoll(const char*); -void* bsearch(const void*, const void*, size_t, size_t, int (*)(const void*, const void*)); -void* calloc(size_t, size_t); -div_t div(int, int); -double drand48(void); -double erand48(unsigned short[3]); -void exit(int); -void free(void*); -char* getenv(const char*); -int getsubopt(char**, char* const*, char**); -int grantpt(int); -char* initstate(unsigned, char*, size_t); -long jrand48(unsigned short[3]); -char* l64a(long); -long labs(long); -void lcong48(unsigned short[7]); -ldiv_t ldiv(long, long); -long long llabs(long long); -lldiv_t lldiv(long long, long long); -long lrand48(void); -void* malloc(size_t); -int mblen(const char*, size_t); -size_t mbstowcs(wchar_t*, const char*, size_t); -int mbtowc(wchar_t*, const char*, size_t); -char* mkdtemp(char*); -int mkstemp(char*); -long mrand48(void); -long nrand48(unsigned short[3]); -int posix_memalign(void**, size_t, size_t); -int posix_openpt(int); -char* ptsname(int); -int putenv(char*); -void qsort(void*, size_t, size_t, int (*)(const void*, const void*)); -int rand(void); -int rand_r(unsigned*); -long random(void); -void* realloc(void*, size_t); -char* realpath(const char*, char*); -unsigned short* seed48(unsigned short[3]); -int setenv(const char*, const char*, int); -void setkey(const char*); -char* setstate(char*); -void srand(unsigned); -void srand48(long); -void srandom(unsigned); -double strtod(const char*, char**); -float strtof(const char*, char**); -long strtol(const char*, char**, int); -long double strtold(const char*, char**); -long long strtoll(const char*, char**, int); -unsigned long strtoul(const char*, char**, int); -unsigned long long strtoull(const char*, char**, int); -int system(const char*); -int unlockpt(int); -int unsetenv(const char*); -size_t wcstombs(char*, const wchar_t*, size_t); -int wctomb(char*, wchar_t); +[[noreturn]] void _Exit(int status); +long a64l(const char* s); +[[noreturn]] void abort(void); +int abs(int i); +int atexit(void (*func)(void)); +double atof(const char* str); +int atoi(const char* str); +long atol(const char* str); +long long atoll(const char* str); +void* bsearch(const void* key, const void* base, size_t nel, size_t width, int (*compar)(const void*, const void*)); +void* calloc(size_t nelem, size_t elsize); +div_t div(int numer, int denom); +double drand48(void); +double erand48(unsigned short xsubi[3]); +void exit(int status); +void free(void* ptr); +char* getenv(const char* name); +int getsubopt(char** optionp, char* const* keylistp, char** valuep); +int grantpt(int fildes); +char* initstate(unsigned seed, char* state, size_t size); +long jrand48(unsigned short xsubi[3]); +char* l64a(long value); +long labs(long i); +void lcong48(unsigned short param[7]); +ldiv_t ldiv(long numer, long denom); +long long llabs(long long i); +lldiv_t lldiv(long long numer, long long denom); +long lrand48(void); +void* malloc(size_t size); +int mblen(const char* s, size_t n); +size_t mbstowcs(wchar_t* __restrict pwcs, const char* __restrict s, size_t n); +int mbtowc(wchar_t* __restrict pwc, const char* __restrict s, size_t n); +char* mkdtemp(char* _template); +int mkstemp(char* _template); +long mrand48(void); +long nrand48(unsigned short xsubi[3]); +int posix_memalign(void** memptr, size_t alignment, size_t size); +int posix_openpt(int oflag); +char* ptsname(int fildes); +int putenv(char* string); +void qsort(void* base, size_t nel, size_t width, int (*compar)(const void*, const void*)); +int rand(void); +int rand_r(unsigned* seed); +long random(void); +void* realloc(void* ptr, size_t size); +char* realpath(const char* __restrict file_name, char* __restrict resolved_name); +unsigned short* seed48(unsigned short seed16v[3]); +int setenv(const char* envname, const char* envval, int overwrite); +void setkey(const char* key); +char* setstate(char* state); +void srand(unsigned seed); +void srand48(long seedval); +void srandom(unsigned seed); +double strtod(const char* __restrict nptr, char** __restrict endptr); +float strtof(const char* __restrict nptr, char** __restrict endptr); +long strtol(const char* __restrict nptr, char** __restrict endptr, int base); +long double strtold(const char* __restrict nptr, char** __restrict endptr); +long long strtoll(const char* __restrict nptr, char** __restrict endptr, int base); +unsigned long strtoul(const char* __restrict nptr, char** __restrict endptr, int base); +unsigned long long strtoull(const char* __restrict nptr, char** __restrict endptr, int base); +int system(const char* command); +int unlockpt(int fildes); +int unsetenv(const char* name); +size_t wcstombs(char* __restrict s, const wchar_t* __restrict pwcs, size_t n); +int wctomb(char* s, wchar_t wchar); -__END_DECLS \ No newline at end of file +__END_DECLS + +#endif diff --git a/libc/include/string.h b/libc/include/string.h index e71ce4e5d9..b9c386cb18 100644 --- a/libc/include/string.h +++ b/libc/include/string.h @@ -1,47 +1,54 @@ -#pragma once +#ifndef _STRING_H +#define _STRING_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/string.h.html -#include -#include #include __BEGIN_DECLS -void* memccpy(void*, const void*, int, size_t); -void* memchr(const void*, int, size_t); -int memcmp(const void*, const void*, size_t); -void* memcpy(void*, const void*, size_t); -void* memmove(void*, const void*, size_t); -void* memset(void*, int, size_t); -char* stpcpy(char*, const char*); -char* stpncpy(char*, const char*, size_t); -char* strcat(char*, const char*); -char* strchr(const char*, int); -int strcmp(const char*, const char*); -int strcoll(const char*, const char*); -int strcoll_l(const char*, const char*, locale_t); -char* strcpy(char*, const char*); -size_t strcspn(const char*, const char*); -char* strdup(const char*); -char* strerror(int); -char* strerror_l(int, locale_t); -int strerror_r(int, char*, size_t); -size_t strlen(const char*); -char* strncat(char*, const char*, size_t); -int strncmp(const char*, const char*, size_t); -char* strncpy(char*, const char*, size_t); -char* strndup(const char*, size_t); -size_t strnlen(const char*, size_t); -char* strpbrk(const char*, const char*); -char* strrchr(const char*, int); -char* strsignal(int); -size_t strspn(const char*, const char*); -char* strstr(const char*, const char*); -char* strtok(char*, const char*); -char* strtok_r(char*, const char*, char**); -size_t strxfrm(char*, const char*, size_t); -size_t strxfrm_l(char*, const char*, size_t, locale_t); +#include +#include -const char* strerrorname_np(int); -const char* strerrordesc_np(int); +void* memccpy(void* __restrict s1, const void* __restrict s2, int c, size_t n); +void* memchr(const void* s, int c, size_t n); +int memcmp(const void* s1, const void* s2, size_t n); +void* memcpy(void* __restrict s1, const void* __restrict s2, size_t n); +void* memmove(void* s1, const void* s2, size_t n); +void* memset(void* s, int c, size_t n); +char* stpcpy(char* __restrict s1, const char* __restrict s2); +char* stpncpy(char* __restrict s1, const char* __restrict s2, size_t n); +char* strcat(char* __restrict s1, const char* __restrict s2); +char* strchr(const char* s, int c); +int strcmp(const char* s1, const char* s2); +int strcoll(const char* s1, const char* s2); +int strcoll_l(const char* s1, const char* s2, locale_t locale); +char* strcpy(char* __restrict s1, const char* __restrict s2); +size_t strcspn(const char* , const char* ); +char* strdup(const char* s); +char* strerror(int errnum); +char* strerror_l(int errnum, locale_t locale); +int strerror_r(int errnum, char* strerrbuf, size_t buflen); +size_t strlen(const char* s); +char* strncat(char* __restrict s1, const char* __restrict s2, size_t n); +int strncmp(const char* s1, const char* s2, size_t n); +char* strncpy(char* __restrict s1, const char* __restrict s2, size_t n); +char* strndup(const char* s, size_t n); +size_t strnlen(const char* s, size_t maxlen); +char* strpbrk(const char* s1, const char* s2); +char* strrchr(const char* s, int c); +char* strsignal(int signum); +size_t strspn(const char* s1, const char* s2); +char* strstr(const char* s1, const char* s2); +char* strtok(char* __restrict s, const char* __restrict sep); +char* strtok_r(char* __restrict s, const char* __restrict sep, char** __restrict state); +size_t strxfrm(char* __restrict s1, const char* __restrict s2, size_t n); +size_t strxfrm_l(char* __restrict s1, const char* __restrict s2, size_t n, locale_t locale); -__END_DECLS \ No newline at end of file +const char* strerrorname_np(int error); +const char* strerrordesc_np(int error); + + +__END_DECLS + +#endif diff --git a/libc/include/strings.h b/libc/include/strings.h new file mode 100644 index 0000000000..66758885bb --- /dev/null +++ b/libc/include/strings.h @@ -0,0 +1,23 @@ +#ifndef _STRINGS_H +#define _STRINGS_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/strings.h.html + +#include + +__BEGIN_DECLS + +#include + +#define __need_size_t +#include + +int ffs(int i); +int strcasecmp(const char* s1, const char* s2); +int strcasecmp_l(const char* s1, const char* s2, locale_t locale); +int strncasecmp(const char* s1, const char* s2, size_t n); +int strncasecmp_l(const char* s1, const char* s2, size_t n, locale_t locale); + +__END_DECLS + +#endif diff --git a/libc/include/sys/cdefs.h b/libc/include/sys/cdefs.h index 42958855be..de7eee182c 100644 --- a/libc/include/sys/cdefs.h +++ b/libc/include/sys/cdefs.h @@ -1,11 +1,14 @@ -#pragma once +#ifndef _SYS_CDEFS_H +#define _SYS_CDEFS_H 1 #define __banan_libc 1 #ifdef __cplusplus -#define __BEGIN_DECLS extern "C" { -#define __END_DECLS } + #define __BEGIN_DECLS extern "C" { + #define __END_DECLS } #else -#define __BEGIN_DECLS -#define __END_DECLS + #define __BEGIN_DECLS + #define __END_DECLS +#endif + #endif \ No newline at end of file diff --git a/libc/include/sys/ipc.h b/libc/include/sys/ipc.h new file mode 100644 index 0000000000..e35a169e85 --- /dev/null +++ b/libc/include/sys/ipc.h @@ -0,0 +1,37 @@ +#ifndef _SYS_IPC_H +#define _SYS_IPC_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_ipc.h.html + +#include + +__BEGIN_DECLS + +#define __need_uid_t +#define __need_gid_t +#define __need_mode_t +#define __need_key_t +#include + +struct ipc_perm +{ + uid_t uid; /* Owner's user ID. */ + gid_t gid; /* Owner's group ID. */ + uid_t cuid; /* Creator's user ID. */ + gid_t cgid; /* Creator's group ID. */ + mode_t mode; /* Read/write permission. */ +}; + +#define IPC_CREAT 0x01 +#define IPC_EXCL 0x02 +#define IPC_NOWAIT 0x04 +#define IPC_PRIVATE 0x08 +#define IPC_RMID 0x10 +#define IPC_SET 0x20 +#define IPC_STAT 0x40 + +key_t ftok(const char* path, int id); + +__END_DECLS + +#endif diff --git a/libc/include/sys/mman.h b/libc/include/sys/mman.h new file mode 100644 index 0000000000..48292cf377 --- /dev/null +++ b/libc/include/sys/mman.h @@ -0,0 +1,65 @@ +#ifndef _SYS_MMAN_H +#define _SYS_MMAN_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_mman.h.html + +#include + +__BEGIN_DECLS + +#define PROT_EXEC 0x01 +#define PROT_NONE 0x02 +#define PROT_READ 0x04 +#define PROT_WRITE 0x08 + +#define MAP_FIXED 0x01 +#define MAP_PRIVATE 0x02 +#define MAP_SHARED 0x04 + +#define MS_ASYNC 0x01 +#define MS_INVALIDATE 0x02 +#define MS_SYNC 0x04 + +#define MCL_CURRENT 0x01 +#define MCL_FUTURE 0x01 + +#define MAP_FAILED ((void*)0) + +#define POSIX_MADV_DONTNEED 1 +#define POSIX_MADV_NORMAL 2 +#define POSIX_MADV_RANDOM 3 +#define POSIX_MADV_SEQUENTIAL 4 +#define POSIX_MADV_WILLNEED 5 + +#define POSIX_TYPED_MEM_ALLOCATE 0x01 +#define POSIX_TYPED_MEM_ALLOCATE_CONTIG 0x02 +#define POSIX_TYPED_MEM_MAP_ALLOCATABLE 0x04 + +#define __need_mode_t +#define __need_off_t +#define __need_size_t +#include + +struct posix_typed_mem_info +{ + size_t posix_tmi_length; /* Maximum length which may be allocated from a typed memory object. */ +}; + +int mlock(const void* addr, size_t len); +int mlockall(int flags); +void* mmap(void* addr, size_t len, int prot, int flags, int fildes, off_t off); +int mprotect(void* addr, size_t len, int prot); +int msync(void* addr, size_t len, int flags); +int munlock(const void* addr, size_t len); +int munlockall(void); +int munmap(void* addr, size_t len); +int posix_madvise(void* addr, size_t len, int advice); +int posix_mem_offset(const void* __restrict addr, size_t len, off_t* __restrict off, size_t* __restrict contig_len, int* __restrict fildes); +int posix_typed_mem_get_info(int fildes, struct posix_typed_mem_info* info); +int posix_typed_mem_open(const char* name, int oflag, int tflag); +int shm_open(const char* name, int oflag, mode_t mode); +int shm_unlink(const char* name); + +__END_DECLS + +#endif diff --git a/libc/include/sys/msg.h b/libc/include/sys/msg.h new file mode 100644 index 0000000000..d3545df6f8 --- /dev/null +++ b/libc/include/sys/msg.h @@ -0,0 +1,42 @@ +#ifndef _SYS_MSG_H +#define _SYS_MSG_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_msg.h.html + +#include + +__BEGIN_DECLS + +#define __need_pid_t +#define __need_size_t +#define __need_ssize_t +#define __need_time_t +#include + +#include + +typedef unsigned int msgqnum_t; +typedef unsigned int msglen_t; + +#define MSG_NOERROR 0 + +struct msqid_ds +{ + struct ipc_perm msg_perm; /* Operation permission structure. */ + msgqnum_t msg_qnum; /* Number of messages currently on queue. */ + msglen_t msg_qbytes; /* Maximum number of bytes allowed on queue. */ + pid_t msg_lspid; /* Process ID of last msgsnd(). */ + pid_t msg_lrpid; /* Process ID of last msgrcv(). */ + time_t msg_stime; /* Time of last msgsnd(). */ + time_t msg_rtime; /* Time of last msgrcv(). */ + time_t msg_ctime; /* Time of last change. */ +}; + +int msgctl(int msqid, int cmd, struct msqid_ds* buf); +int msgget(key_t key, int msgflg); +ssize_t msgrcv(int msqid, void* msgp, size_t msgsz, long msgtyp, int msgflg); +int msgsnd(int msqid, const void* msgp, size_t msgsz, int msgflg); + +__END_DECLS + +#endif diff --git a/libc/include/sys/param.h b/libc/include/sys/param.h deleted file mode 100644 index 4ec5550a2c..0000000000 --- a/libc/include/sys/param.h +++ /dev/null @@ -1,4 +0,0 @@ -#pragma once - -#define MIN(a, b) ((a) < (b) ? (a) : (b)) -#define MAX(a, b) ((a) > (b) ? (a) : (b)) diff --git a/libc/include/sys/resource.h b/libc/include/sys/resource.h new file mode 100644 index 0000000000..8d980a4a03 --- /dev/null +++ b/libc/include/sys/resource.h @@ -0,0 +1,56 @@ +#ifndef _SYS_RESOURCE_H +#define _SYS_RESOURCE_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_resource.h.html + +#include + +__BEGIN_DECLS + +#define __need_id_t +#include + +#include + +#define PRIO_PROCESS 0 +#define PRIO_PGRP 1 +#define PRIO_USER 2 + +typedef unsigned int rlim_t; + +#define RLIM_INFINITY ((rlim_t)-1) +#define RLIM_SAVED_MAX RLIM_INFINITY +#define RLIM_SAVED_CUR RLIM_INFINITY + +#define RUSAGE_SELF 0 +#define RUSAGE_CHILDREN 1 + +struct rlimit +{ + rlim_t rlim_cur; /* The current (soft) limit. */ + rlim_t rlim_max; /* The hard limit. */ +}; + +struct rusage +{ + struct timeval ru_utime; /* User time used. */ + struct timeval ru_stime; /* System time used. */ +}; + +#define RLIMIT_CORE 0 +#define RLIMIT_CPU 1 +#define RLIMIT_DATA 2 +#define RLIMIT_FSIZE 3 +#define RLIMIT_NOFILE 4 +#define RLIMIT_STACK 5 +#define RLIMIT_AS 6 + +int getpriority(int which, id_t who); +int getrlimit(int resource, struct rlimit* rlp); +int getrusage(int who, struct rusage* r_usage); +int setpriority(int which, id_t who, int value); +int setrlimit(int resource, const struct rlimit* rlp); + +__END_DECLS + +#endif diff --git a/libc/include/sys/select.h b/libc/include/sys/select.h new file mode 100644 index 0000000000..ae55e86fb3 --- /dev/null +++ b/libc/include/sys/select.h @@ -0,0 +1,58 @@ +#ifndef _SYS_SELECT_H +#define _SYS_SELECT_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_select.h.html + +#include + +__BEGIN_DECLS + +#define __need_time_t +#define __need_suseconds_t +#include + +#include +#include + +#define FD_SETSIZE 1024 + +typedef unsigned long __fd_mask; +#define __FD_MASK_SIZE (8 * sizeof(__fd_mask)) + +typedef struct { + __fd_mask __bits[FD_SETSIZE / __FD_MASK_SIZE]; +} fd_set; + +#define FD_CLR(fd, setp) \ + do { \ + __fd_mask off = (fd) / __FD_MASK_SIZE; \ + __fd_mask bit = (fd) % __FD_MASK_SIZE; \ + (setp)->__bits[off] &= ~((__fd_mask)1 << bit); \ + } while (0) + +#define FD_ISSET(fd, setp) \ + ({ \ + __fd_mask off = (fd) / __FD_MASK_SIZE; \ + __fd_mask bit = (fd) % __FD_MASK_SIZE; \ + (setp)->__bits[off] & ((__fd_mask)1 << bit); \ + }) + +#define FD_SET(fd, setp) \ + do { \ + __fd_mask off = (fd) / __FD_MASK_SIZE; \ + __fd_mask bit = (fd) % __FD_MASK_SIZE; \ + (setp)->__bits[off] |= ((__fd_mask)1 << bit); \ + } while (0) + +#define FD_ZERO(setp) \ + do { \ + for (int i = 0; i < FD_SETSIZE / __FD_MASK_SIZE; i++) \ + (setp)->__bits[i] = (__fd_mask)0; \ + } while (0) + +int pselect(int nfds, fd_set* __restrict readfds, fd_set* __restrict writefds, fd_set* __restrict errorfds, const struct timespec* __restrict timeout, const sigset_t* __restrict sigmask); +int select(int nfds, fd_set* __restrict readfds, fd_set* __restrict writefds, fd_set* __restrict errorfds, struct timeval* __restrict timeout); + +__END_DECLS + +#endif diff --git a/libc/include/sys/sem.h b/libc/include/sys/sem.h new file mode 100644 index 0000000000..88c8427044 --- /dev/null +++ b/libc/include/sys/sem.h @@ -0,0 +1,54 @@ +#ifndef _SYS_SEM_H +#define _SYS_SEM_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_sem.h.html + +#include + +__BEGIN_DECLS + +#define __need_pid_t +#define __need_size_t +#define __need_time_t +#include + +#include + +#define SEM_UNDO 1 + +#define GETNCNT 0 +#define GETPID 1 +#define GETVAL 2 +#define GETALL 3 +#define GETZCNT 4 +#define SETVAL 5 +#define SETALL 6 + +struct semid_ds +{ + struct ipc_perm sem_perm; /* Operation permission structure. */ + unsigned short sem_nsems; /* Number of semaphores in set. */ + time_t sem_otime; /* Last semop() time. */ + time_t sem_ctime; /* Last time changed by semctl(). */ +}; + +// FIXME: A semaphore shall be represented by an anonymous structure, which shall include the following members: +// unsigned short semval; /* Semaphore value. */ +// pid_t sempid; /* Process ID of last operation. */ +// unsigned short semncnt; /* Number of processes waiting for semval to become greater than current value. */ +// unsigned short semzcnt; /* Number of processes waiting for semval to become 0. */ + +struct sembuf +{ + unsigned short sem_num; /* Semaphore number. */ + short sem_op; /* Semaphore operation. */ + short sem_flg; /* Operation flags. */ +}; + +int semctl(int, int, int, ...); +int semget(key_t, int, int); +int semop(int, struct sembuf *, size_t); + +__END_DECLS + +#endif diff --git a/libc/include/sys/shm.h b/libc/include/sys/shm.h new file mode 100644 index 0000000000..1ec705a845 --- /dev/null +++ b/libc/include/sys/shm.h @@ -0,0 +1,42 @@ +#ifndef _SYS_SHM_H +#define _SYS_SHM_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_shm.h.html + +#include + +__BEGIN_DECLS + +#define __need_pid_t +#define __need_size_t +#define __need_time_t +#include + +#include + +#define SHM_RDONLY 0x01 +#define SHM_RDONLY 0x02 +#define SHM_RDONLY 0x04 + +typedef unsigned int shmatt_t; + +struct shmid_ds +{ + struct ipc_perm shm_perm; /* Operation permission structure. */ + size_t shm_segsz; /* Size of segment in bytes. */ + pid_t shm_lpid; /* Process ID of last shared memory operation. */ + pid_t shm_cpid; /* Process ID of creator. */ + shmatt_t shm_nattch; /* Number of current attaches. */ + time_t shm_atime; /* Time of last shmat(). */ + time_t shm_dtime; /* Time of last shmdt(). */ + time_t shm_ctime; /* Time of last change by shmctl().*/ +}; + +void* shmat(int shmid, const void* shmaddr, int shmflg); +int shmctl(int shmid, int cmd, struct shmid_ds* buf); +int shmdt(const void* shmaddr); +int shmget(key_t key, size_t size, int shmflg); + +__END_DECLS + +#endif diff --git a/libc/include/sys/socket.h b/libc/include/sys/socket.h new file mode 100644 index 0000000000..5c9208a4a7 --- /dev/null +++ b/libc/include/sys/socket.h @@ -0,0 +1,129 @@ +#ifndef _SYS_SOCKET_H +#define _SYS_SOCKET_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_socket.h.html + +#include + +__BEGIN_DECLS + +#define __need_size_t +#define __need_ssize_t +#include + +#include + +#include +typedef long socklen_t; + +struct sockaddr +{ + sa_family_t sa_family; /* Address family. */ + char sa_data[]; /* Socket address (variable-length data). */ +}; + +struct sockaddr_storage +{ + // FIXME + sa_family_t ss_family; +}; + +struct msghdr +{ + void* msg_name; /* Optional address. */ + socklen_t msg_namelen; /* Size of address. */ + struct iovec* msg_iov; /* Scatter/gather array. */ + int msg_iovlen; /* Members in msg_iov. */ + void* msg_control; /* Ancillary data; see below. */ + socklen_t msg_controllen; /* Ancillary data buffer len. */ + int msg_flags; /* Flags on received message. */ +}; + +struct cmsghdr +{ + socklen_t cmsg_len; /* Data byte count, including the cmsghdr. */ + int cmsg_level; /* Originating protocol. */ + int cmsg_type; /* Protocol-specific type. */ +}; + +// FIXME +#if 0 +#define SCM_RIGHTS + +#define CMSG_DATA(cmsg) +#define CMSG_NXTHDR(mhdr, cmsg) +#define CMSG_FIRSTHDR(mhdr) +#endif + +struct linger +{ + int l_onoff; /* Indicates wheter linger option is enabled. */ + int l_linger; /* Linger time, in seconds. */ +}; + +#define SOCK_DGRAM 0 +#define SOCK_RAW 1 +#define SOCK_SEQPACKET 2 +#define SOCK_STREAM 3 + +#define SOL_SOCKET 1 + +#define SO_ACCEPTCONN 0 +#define SO_BROADCAST 1 +#define SO_DEBUG 2 +#define SO_DONTROUTE 3 +#define SO_ERROR 4 +#define SO_KEEPALIVE 5 +#define SO_LINGER 6 +#define SO_OOBINLINE 7 +#define SO_RCVBUF 8 +#define SO_RCVLOWAT 9 +#define SO_RCVTIMEO 10 +#define SO_REUSEADDR 11 +#define SO_SNDBUF 12 +#define SO_SNDLOWAT 13 +#define SO_SNDTIMEO 14 +#define SO_TYPE 15 + +#define SOMAXCONN 4096 + +#define MSG_CTRUNC 0x01 +#define MSG_DONTROUTE 0x02 +#define MSG_EOR 0x04 +#define MSG_OOB 0x08 +#define MSG_NOSIGNAL 0x10 +#define MSG_PEEK 0x20 +#define MSG_TRUNC 0x40 +#define MSG_WAITALL 0x80 + +#define AF_UNSPEC 0 +#define AF_INET 1 +#define AF_INET6 2 +#define AF_UNIX 3 + +#define SHUT_RD 0x01 +#define SHUT_WR 0x02 +#define SHUT_RDWR (SHUT_RD | SHUT_WR) + +int accept(int socket, struct sockaddr* __restrict address, socklen_t* __restrict address_len); +int bind(int socket, const struct sockaddr* address, socklen_t address_len); +int connect(int socket, const struct sockaddr* address, socklen_t address_len); +int getpeername(int socket, struct sockaddr* __restrict address, socklen_t* __restrict address_len); +int getsockname(int socket, struct sockaddr* __restrict address, socklen_t* __restrict address_len); +int getsockopt(int socket, int level, int option_name, void* __restrict option_value, socklen_t* __restrict option_len); +int listen(int socket, int backlog); +ssize_t recv(int socket, void* buffer, size_t length, int flags); +ssize_t recvfrom(int socket, void* __restrict buffer, size_t length, int flags, struct sockaddr* __restrict address, socklen_t* __restrict address_len); +ssize_t recvmsg(int socket, struct msghdr* message, int flags); +ssize_t send(int socket, const void* buffer, size_t length, int flags); +ssize_t sendmsg(int socket, const struct msghdr* message, int flags); +ssize_t sendto(int socket, const void* message, size_t length, int flags, const struct sockaddr* dest_addr, socklen_t dest_len); +int setsockopt(int socket, int level, int option_name, const void* option_value, socklen_t option_len); +int shutdown(int socket, int how); +int sockatmark(int s); +int socket(int domain, int type, int protocol); +int socketpair(int domain, int type, int protocol, int socket_vector[2]); + +__END_DECLS + +#endif diff --git a/libc/include/sys/stat.h b/libc/include/sys/stat.h index 2113dc1c7f..5ce8e8020a 100644 --- a/libc/include/sys/stat.h +++ b/libc/include/sys/stat.h @@ -1,46 +1,108 @@ -#pragma once +#ifndef _SYS_STAT_H +#define _SYS_STAT_H 1 +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_stat.h.html + +#include + +__BEGIN_DECLS + +#define __need_blkcnt_t +#define __need_blksize_t +#define __need_dev_t +#define __need_ino_t +#define __need_mode_t +#define __need_nlink_t +#define __need_uid_t +#define __need_gid_t +#define __need_off_t +#define __need_time_t #include + #include +struct stat +{ + dev_t st_dev; /* Device ID of device containing file. */ + ino_t st_ino; /* File serial number. */ + mode_t st_mode; /* Mode of file (see below). */ + nlink_t st_nlink; /* Number of hard links to the file. */ + uid_t st_uid; /* User ID of file. */ + gid_t st_gid; /* Group ID of file. */ + dev_t st_rdev; /* Device ID (if file is character or block special). */ + off_t st_size; /* For regular files, the file size in bytes. For symbolic links, the length in bytes of the pathname contained in the symbolic link. For a shared memory object, the length in bytes. For a typed memory object, the length in bytes. For other file types, the use of this field is unspecified. */ + struct timespec st_atim; /* Last data access timestamp. */ + struct timespec st_mtim; /* Last data modification timestamp. */ + struct timespec st_ctim; /* Last file status change timestamp. */ + blksize_t st_blksize; /* A file system-specific preferred I/O block size for this object. In some file system types, this may vary from file to file. */ + blkcnt_t st_blocks; /* Number of blocks allocated for this object. */ +}; + #define st_atime st_atim.tv_sec #define st_ctime st_ctim.tv_sec #define st_mtime st_mtim.tv_sec -__BEGIN_DECLS +#define S_IRWXU ((mode_t)00700) +#define S_IRUSR ((mode_t)00400) +#define S_IWUSR ((mode_t)00200) +#define S_IXUSR ((mode_t)00100) +#define S_IRWXG ((mode_t)00070) +#define S_IRGRP ((mode_t)00040) +#define S_IWGRP ((mode_t)00020) +#define S_IXGRP ((mode_t)00010) +#define S_IRWXO ((mode_t)00007) +#define S_IROTH ((mode_t)00004) +#define S_IWOTH ((mode_t)00002) +#define S_IXOTH ((mode_t)00001) +#define S_ISUID ((mode_t)04000) +#define S_ISGID ((mode_t)02000) +#define S_ISVTX ((mode_t)01000) -struct stat -{ - dev_t st_dev; - ino_t st_ino; - mode_t st_mode; - nlink_t st_nlink; - uid_t st_uid; - gid_t st_gid; - dev_t st_rdev; - off_t st_size; - timespec st_atim; - timespec st_mtim; - timespec st_ctim; - blksize_t st_blksize; - blkcnt_t st_blocks; -}; +#define S_IFIFO ((mode_t)0010000) +#define S_IFCHR ((mode_t)0020000) +#define S_IFDIR ((mode_t)0040000) +#define S_IFBLK ((mode_t)0060000) +#define S_IFREG ((mode_t)0100000) +#define S_IFLNK ((mode_t)0120000) +#define S_IFSOCK ((mode_t)0140000) -int chmod(const char*, mode_t); -int fchmod(int, mode_t); -int fchmodat(int, const char*, mode_t, int); -int fstat(int, struct stat*); -int fstatat(int, const char*, struct stat*, int); -int futimens(int, const struct timespec[2]); -int lstat(const char*, struct stat*); -int mkdir(const char*, mode_t); -int mkdirat(int, const char*, mode_t); -int mkfifo(const char*, mode_t); -int mkfifoat(int, const char*, mode_t); -int mknod(const char*, mode_t, dev_t); -int mknodat(int, const char*, mode_t, dev_t); -int stat(const char*, struct stat*); -mode_t umask(mode_t); -int utimensat(int, const char*, const struct timespec[2], int); +#define S_ISBLK(mode) (mode & S_IFBLK) +#define S_ISCHR(mode) (mode & S_IFCHR) +#define S_ISDIR(mode) (mode & S_IFDIR) +#define S_ISFIFO(mode) (mode & S_IFIFO) +#define S_ISREG(mode) (mode & S_IFREG) +#define S_ISLNK(mode) (mode & S_IFLNK) +#define S_ISSOCK(mode) (mode & S_IFSOCK) + +// FIXME +#if 0 +#define S_TYPEISMQ(buf) +#define S_TYPEISSEM(buf) +#define S_TYPEISSHM(buf) +#define S_TYPEISTMO(buf) +#endif + +#define UTIME_NOW 1000000001 +#define UTIME_OMIT 1000000002 + + +int chmod(const char* path, mode_t mode); +int fchmod(int fildes, mode_t mode); +int fchmodat(int fd, const char* path, mode_t mode, int flag); +int fstat(int fildes, struct stat* buf); +int fstatat(int fd, const char* __restrict path, struct stat* __restrict buf, int flag); +int futimens(int fd, const struct timespec times[2]); +int lstat(const char* __restrict path, struct stat* __restrict buf); +int mkdir(const char* path, mode_t mode); +int mkdirat(int fd, const char* path, mode_t mode); +int mkfifo(const char* path, mode_t mode); +int mkfifoat(int fd, const char* path, mode_t mode); +int mknod(const char* path, mode_t mode, dev_t dev); +int mknodat(int fd, const char* path, mode_t mode, dev_t dev); +int stat(const char* __restrict path, struct stat* __restrict buf); +mode_t umask(mode_t cmask); +int utimensat(int fd, const char* path, const struct timespec times[2], int flag); __END_DECLS + +#endif diff --git a/libc/include/sys/statvfs.h b/libc/include/sys/statvfs.h new file mode 100644 index 0000000000..9a47379f88 --- /dev/null +++ b/libc/include/sys/statvfs.h @@ -0,0 +1,37 @@ +#ifndef _SYS_STATVFS_H +#define _SYS_STATVFS_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_statvfs.h.html + +#include + +__BEGIN_DECLS + +#define __need_fsblkcnt_t +#define __need_fsfilcnt_t +#include + +struct statvfs +{ + unsigned long f_bsize; /* File system block size. */ + unsigned long f_frsize; /* Fundamental file system block size. */ + fsblkcnt_t f_blocks; /* Total number of blocks on file system in units of f_frsize. */ + fsblkcnt_t f_bfree; /* Total number of free blocks. */ + fsblkcnt_t f_bavail; /* Number of free blocks available to non-privileged process. */ + fsfilcnt_t f_files; /* Total number of file serial numbers. */ + fsfilcnt_t f_ffree; /* Total number of free file serial numbers. */ + fsfilcnt_t f_favail; /* Number of file serial numbers available to non-privileged process. */ + unsigned long f_fsid; /* File system ID. */ + unsigned long f_flag; /* Bit mask of f_flag values. */ + unsigned long f_namemax; /* Maximum filename length. */ +}; + +#define ST_RDONLY 0x01 +#define ST_NOSUID 0x02 + +int fstatvfs(int fildes, struct statvfs* buf); +int statvfs(const char* __restrict path, struct statvfs* __restrict buf); + +__END_DECLS + +#endif diff --git a/libc/include/sys/syscall.h b/libc/include/sys/syscall.h index 767850e931..4391796057 100644 --- a/libc/include/sys/syscall.h +++ b/libc/include/sys/syscall.h @@ -1,3 +1,23 @@ -#pragma once +#ifndef _SYS_SYSCALL_H +#define _SYS_SYSCALL_H 1 -#include +#include + +__BEGIN_DECLS + +#define SYS_EXIT 1 +#define SYS_READ 2 +#define SYS_WRITE 3 +#define SYS_TERMID 4 +#define SYS_CLOSE 5 +#define SYS_OPEN 6 +#define SYS_ALLOC 7 +#define SYS_FREE 8 +#define SYS_SEEK 9 +#define SYS_TELL 10 +#define SYS_GET_TERMIOS 11 +#define SYS_SET_TERMIOS 12 + +__END_DECLS + +#endif diff --git a/libc/include/sys/sysmacros.h b/libc/include/sys/sysmacros.h index 7d17574a13..e27047a2a3 100644 --- a/libc/include/sys/sysmacros.h +++ b/libc/include/sys/sysmacros.h @@ -1,8 +1,18 @@ -#pragma once +#ifndef _SYS_SYSMACROS_H +#define _SYS_SYSMACROS_H 1 +#include + +__BEGIN_DECLS + +#define __need_pid_t #include #define makedev(maj, min) ((dev_t)(maj) << 32 | (dev_t)(min)) #define major(dev) (((dev) >> 32) & 0xFFFFFFFF) #define minor(dev) ( (dev) & 0xFFFFFFFF) + +__END_DECLS + +#endif \ No newline at end of file diff --git a/libc/include/sys/time.h b/libc/include/sys/time.h new file mode 100644 index 0000000000..704bf63acd --- /dev/null +++ b/libc/include/sys/time.h @@ -0,0 +1,40 @@ +#ifndef _SYS_TIME_H +#define _SYS_TIME_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_time.h.html + +#include + +__BEGIN_DECLS + +#define __need_time_t +#define __need_suseconds_t +#include + +#include + +struct timeval +{ + time_t tv_sec; /* Seconds. */ + suseconds_t tc_usec; /* Microseconds. */ +}; + +struct itimerval +{ + struct timeval it_interval; /* Timer interval. */ + struct timeval it_value; /* Current value. */ +}; + +#define ITIMER_REAL 0 +#define ITIMER_VIRTUAL 1 +#define ITIMER_PROF 2 + +int getitimer(int which, struct itimerval* value); +int gettimeofday(struct timeval* __restrict tp, void* __restrict tzp); +int setitimer(int which, const struct itimerval* __restrict value, struct itimerval* __restrict ovalue); +int select(int nfds, fd_set* __restrict readfds, fd_set* __restrict writefds, fd_set* __restrict errorfds, struct timeval* __restrict timeout); +int utimes(const char* path, const struct timeval times[2]); + +__END_DECLS + +#endif diff --git a/libc/include/sys/times.h b/libc/include/sys/times.h new file mode 100644 index 0000000000..09b2568cd5 --- /dev/null +++ b/libc/include/sys/times.h @@ -0,0 +1,25 @@ +#ifndef _SYS_TIMES_H +#define _SYS_TIMES_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_times.h.html + +#include + +__BEGIN_DECLS + +#define __need_clock_t +#include + +struct tms +{ + clock_t tms_utime; /* User CPU time. */ + clock_t tms_stime; /* System CPU time. */ + clock_t tms_cutime; /* User CPU time of terminated child processes. */ + clock_t tms_cstime; /* System CPU time of terminated child processes. */ +}; + +clock_t times(struct tms* buffer); + +__END_DECLS + +#endif diff --git a/libc/include/sys/types.h b/libc/include/sys/types.h index 87a0d591e6..1f3908ddf8 100644 --- a/libc/include/sys/types.h +++ b/libc/include/sys/types.h @@ -1,26 +1,196 @@ -#pragma once +#ifndef _SYS_TYPES_H + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_types.h.html -#include -#include #include __BEGIN_DECLS -typedef int32_t blkcnt_t; -typedef int32_t blksize_t; -typedef uint64_t clock_t; -typedef int32_t clockid_t; -typedef uint64_t dev_t; -typedef uint32_t ino_t; -typedef uint16_t mode_t; -typedef uint32_t nlink_t; -typedef int64_t off_t; -typedef uint64_t time_t; -typedef uint64_t timer_t; -typedef int32_t id_t; -typedef id_t pid_t; -typedef id_t uid_t; -typedef id_t gid_t; -typedef int64_t ssize_t; +#if !defined(__need_blkcnt_t) \ + && !defined(__need_blksize_t) \ + && !defined(__need_clock_t) \ + && !defined(__need_clockid_t) \ + && !defined(__need_dev_t) \ + && !defined(__need_fsblkcnt_t) \ + && !defined(__need_fsfilcnt_t) \ + && !defined(__need_gid_t) \ + && !defined(__need_id_t) \ + && !defined(__need_ino_t) \ + && !defined(__need_key_t) \ + && !defined(__need_mode_t) \ + && !defined(__need_nlink_t) \ + && !defined(__need_off_t) \ + && !defined(__need_pid_t) \ + && !defined(__need_pthread_attr_t) \ + && !defined(__need_pthread_barrier_t) \ + && !defined(__need_pthread_barrierattr_t) \ + && !defined(__need_pthread_cond_t) \ + && !defined(__need_pthread_condattr_t) \ + && !defined(__need_pthread_key_t) \ + && !defined(__need_pthread_mutex_t) \ + && !defined(__need_pthread_mutexattr_t) \ + && !defined(__need_pthread_once_t) \ + && !defined(__need_pthread_rwlock_t) \ + && !defined(__need_pthread_rwlockattr_t) \ + && !defined(__need_pthread_spinlock_t) \ + && !defined(__need_pthread_t) \ + && !defined(__need_size_t) \ + && !defined(__need_ssize_t) \ + && !defined(__need_suseconds_t) \ + && !defined(__need_time_t) \ + && !defined(__need_timer_t) \ + && !defined(__need_uid_t) -__END_DECLS \ No newline at end of file + #define __need_all_types +#endif + +#ifdef __need_all_types +#define _SYS_TYPES_H 1 +#endif + +#if !defined(__blkcnt_t_defined) && (defined(__need_all_types) || defined(__need_blkcnt_t)) + #define __blkcnt_defined 1 + typedef long blkcnt_t; +#endif +#undef __need_blkcnt_t + +#if !defined(__blksize_t_defined) && (defined(__need_all_types) || defined(__need_blksize_t)) + #define __blksize_t_defined 1 + typedef long blksize_t; +#endif +#undef __need_blksize_t + +#if !defined(__clock_t_defined) && (defined(__need_all_types) || defined(__need_clock_t)) + #define __clock_t_defined 1 + typedef long clock_t; +#endif +#undef __need_clock_t + +#if !defined(__clockid_t_defined) && (defined(__need_all_types) || defined(__need_clockid_t)) + #define __clockid_t_defined 1 + typedef int clockid_t; +#endif +#undef __need_clockid_t + +#if !defined(__dev_t_defined) && (defined(__need_all_types) || defined(__need_dev_t)) + #define __dev_t_defined 1 + typedef unsigned long dev_t; +#endif +#undef __need_dev_t + +#if !defined(__fsblkcnt_t_defined) && (defined(__need_all_types) || defined(__need_fsblkcnt_t)) + #define __fsblkcnt_t_defined 1 + typedef unsigned long fsblkcnt_t; +#endif +#undef __need_fsblkcnt_t + +#if !defined(__fsfilcnt_t_defined) && (defined(__need_all_types) || defined(__need_fsfilcnt_t)) + #define __fsfilcnt_t_defined 1 + typedef unsigned long fsfilcnt_t; +#endif +#undef __need_fsfilcnt_t + +#if !defined(__gid_t_defined) && (defined(__need_all_types) || defined(__need_gid_t)) + #define __gid_t_defined 1 + typedef unsigned int gid_t; +#endif +#undef __need_gid_t + +#if !defined(__id_t_defined) && (defined(__need_all_types) || defined(__need_id_t)) + #define __id_t_defined 1 + typedef unsigned int id_t; +#endif +#undef __need_id_t + +#if !defined(__ino_t_defined) && (defined(__need_all_types) || defined(__need_ino_t)) + #define __ino_t_defined 1 + typedef unsigned long ino_t; +#endif +#undef __need_ino_t + +#if !defined(__key_t_defined) && (defined(__need_all_types) || defined(__need_key_t)) + #define __key_t_defined 1 + typedef int key_t; +#endif +#undef __need_key_t + +#if !defined(__mode_t_defined) && (defined(__need_all_types) || defined(__need_mode_t)) + #define __mode_t_defined 1 + typedef unsigned int mode_t; +#endif +#undef __need_mode_t + +#if !defined(__nlink_t_defined) && (defined(__need_all_types) || defined(__need_nlink_t)) + #define __nlink_t_defined 1 + typedef unsigned long nlink_t; +#endif +#undef __need_nlink_t + +#if !defined(__off_t_defined) && (defined(__need_all_types) || defined(__need_off_t)) + #define __off_t_defined 1 + typedef long off_t; +#endif +#undef __need_off_t + +#if !defined(__pid_t_defined) && (defined(__need_all_types) || defined(__need_pid_t)) + #define __pid_t_defined 1 + typedef int pid_t; +#endif +#undef __need_pid_t + +#include + +#if !defined(__size_t_defined) && (defined(__need_all_types) || defined(__need_size_t)) + #define __size_t_defined 1 + #define __need_size_t + #include +#endif +#undef __need_size_t + +#if !defined(__ssize_t_defined) && (defined(__need_all_types) || defined(__need_ssize_t)) + #define __ssize_t_defined 1 + #if __SIZEOF_SIZE_T__ == __SIZEOF_INT__ + typedef int ssize_t; + #elif __SIZEOF_SIZE_T__ == __SIZEOF_LONG__ + typedef long ssize_t; + #elif __SIZEOF_SIZE_T__ == __SIZEOF_LONG_LONG__ + typedef long long ssize_t; + #else + #error "unsupported sizeof(size_t)" + #endif +#endif +#undef __need_ssize_t + +#if !defined(__suseconds_t_defined) && (defined(__need_all_types) || defined(__need_suseconds_t)) + #define __suseconds_t_defined 1 + typedef long suseconds_t; +#endif +#undef __need_suseconds_t + +#if !defined(__time_t_defined) && (defined(__need_all_types) || defined(__need_time_t)) + #define __time_t_defined 1 + typedef unsigned long long time_t; +#endif +#undef __need_time_t + +#if !defined(__timer_t_defined) && (defined(__need_all_types) || defined(__need_timer_t)) + #define __timer_t_defined 1 + typedef void* timer_t; +#endif +#undef __need_timer_t + +#if !defined(__uid_t_defined) && (defined(__need_all_types) || defined(__need_uid_t)) + #define __uid_t_defined 1 + typedef int uid_t; +#endif +#undef __need_uid_t + +#ifdef __need_all_types + #include +#endif + +#undef __need_all_types + +__END_DECLS + +#endif diff --git a/libc/include/sys/uio.h b/libc/include/sys/uio.h new file mode 100644 index 0000000000..2471d8e987 --- /dev/null +++ b/libc/include/sys/uio.h @@ -0,0 +1,25 @@ +#ifndef _SYS_UIO_H +#define _SYS_UIO_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_uio.h.html + +#include + +__BEGIN_DECLS + +#define __need_size_t +#define __need_ssize_t +#include + +struct iovec +{ + void* iov_base; /* Base address of a memory region for input or output. */ + size_t iov_len; /* The size of the memory pointed to by iov_base. */ +}; + +ssize_t readv(int fildes, const struct iovec* iov, int iovcnt); +ssize_t writev(int fildes, const struct iovec* iov, int iovcnt); + +__END_DECLS + +#endif diff --git a/libc/include/sys/un.h b/libc/include/sys/un.h new file mode 100644 index 0000000000..d1d538e67e --- /dev/null +++ b/libc/include/sys/un.h @@ -0,0 +1,20 @@ +#ifndef _SYS_UN_H +#define _SYS_UN_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_un.h.html + +#include + +__BEGIN_DECLS + +#include + +struct sockaddr_un +{ + sa_family_t sun_family; /* Address family. */ + char sun_path[]; /* Socket pathname. */ +}; + +__END_DECLS + +#endif diff --git a/libc/include/sys/utsname.h b/libc/include/sys/utsname.h new file mode 100644 index 0000000000..32ba5045bb --- /dev/null +++ b/libc/include/sys/utsname.h @@ -0,0 +1,23 @@ +#ifndef _SYS_UTSNAME_H +#define _SYS_UTSNAME_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_utsname.h.html + +#include + +__BEGIN_DECLS + +struct utsname +{ + char sysname[65]; /* Name of this implementation of the operating system. */ + char nodename[65]; /* Name of this node within the communications network to which this node is attached, if any. */ + char release[65]; /* Current release level of this implementation. */ + char version[65]; /* Current version level of this release. */ + char machine[65]; /* Name of the hardware type on which the system is running. */ +}; + +int uname(struct utsname* name); + +__END_DECLS + +#endif diff --git a/libc/include/sys/wait.h b/libc/include/sys/wait.h new file mode 100644 index 0000000000..0a9a82ffa2 --- /dev/null +++ b/libc/include/sys/wait.h @@ -0,0 +1,47 @@ +#ifndef _SYS_WAIT_H +#define _SYS_WAIT_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_wait.h.html + +#include + +__BEGIN_DECLS + +#define __need_id_t +#define __need_pid_t +#include + +#include + +#define WCONTINUED 0x01 +#define WNOHANG 0x02 +#define WUNTRACED 0x04 +#define WEXITED 0x08 +#define WNOWAIT 0x10 +#define WSTOPPED 0x20 + +// FIXME +#if 0 +#define WEXITSTATUS +#define WIFCONTINUED +#define WIFEXITED +#define WIFSIGNALED +#define WIFSTOPPED +#define WSTOPSIG +#define WTERMSIG +#endif + +typedef enum +{ + P_ALL, + P_PGID, + P_PID, +} idtype_t; + +pid_t wait(int* stat_loc); +int waitid(idtype_t idtype, id_t id, siginfo_t* infop, int options); +pid_t waitpid(pid_t pid, int* stat_loc, int options); + +__END_DECLS + +#endif diff --git a/libc/include/syslog.h b/libc/include/syslog.h new file mode 100644 index 0000000000..c4b415150a --- /dev/null +++ b/libc/include/syslog.h @@ -0,0 +1,52 @@ +#ifndef _SYSLOG_H +#define _SYSLOG_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/syslog.h.html + +#include + +__BEGIN_DECLS + +#define LOG_PID 0x01 +#define LOG_CONS 0x02 +#define LOG_NDELAY 0x04 +#define LOG_ODELAY 0x08 +#define LOG_NOWAIT 0x10 + +#define LOG_EMERG 0 +#define LOG_ALERT 1 +#define LOG_CRIT 2 +#define LOG_ERR 3 +#define LOG_WARNING 4 +#define LOG_NOTICE 5 +#define LOG_INFO 6 +#define LOG_DEBUG 7 + +#define LOG_KERN ( 0 << 3) +#define LOG_USER ( 1 << 3) +#define LOG_MAIL ( 2 << 3) +#define LOG_NEWS ( 3 << 3) +#define LOG_UUCP ( 4 << 3) +#define LOG_DAEMON ( 5 << 3) +#define LOG_AUTH ( 6 << 3) +#define LOG_CRON ( 7 << 3) +#define LOG_LPR ( 8 << 3) +#define LOG_LOCAL0 ( 9 << 3) +#define LOG_LOCAL1 (10 << 3) +#define LOG_LOCAL2 (11 << 3) +#define LOG_LOCAL3 (12 << 3) +#define LOG_LOCAL4 (13 << 3) +#define LOG_LOCAL5 (14 << 3) +#define LOG_LOCAL6 (15 << 3) +#define LOG_LOCAL7 (16 << 3) + +#define LOG_MASK(pri) (1 << (pri)) + +void closelog(void); +void openlog(const char* ident, int logopt, int facility); +int setlogmask(int maskpri); +void syslog(int priority, const char* message, ...); + +__END_DECLS + +#endif diff --git a/libc/include/tar.h b/libc/include/tar.h new file mode 100644 index 0000000000..3fcfb57c6f --- /dev/null +++ b/libc/include/tar.h @@ -0,0 +1,40 @@ +#ifndef _TAR_H +#define _TAR_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/tar.h.html + +#include + +__BEGIN_DECLS + +#define TMAGIC "ustar" +#define TMAGLEN 6 +#define TVERSION "00" +#define TVERSLEN 2 + +#define REGTYPE '0' +#define AREGTYPE '\0' +#define LNKTYPE '1' +#define SYMTYPE '2' +#define CHRTYPE '3' +#define BLKTYPE '4' +#define DIRTYPE '5' +#define FIFOTYPE '6' +#define CONTTYPE '7' + +#define TSUID 04000 +#define TSGID 02000 +#define TSVTX 01000 +#define TUREAD 00400 +#define TUWRITE 00200 +#define TUEXEC 00100 +#define TGREAD 00040 +#define TGWRITE 00020 +#define TGEXEC 00010 +#define TOREAD 00004 +#define TOWRITE 00002 +#define TOEXEC 00001 + +__END_DECLS + +#endif diff --git a/libc/include/termios.h b/libc/include/termios.h index 6def960985..2a0aac4670 100644 --- a/libc/include/termios.h +++ b/libc/include/termios.h @@ -1,11 +1,42 @@ -#pragma once +#ifndef _TERMIOS_H +#define _TERMIOS_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/termios.h.html #include + +__BEGIN_DECLS + +#define __need_pid_t #include -#define NCCS 0 +typedef unsigned int cc_t; +typedef unsigned int speed_t; +typedef unsigned int tcflag_t; + +#define VEOF 0 +#define VEOL 1 +#define VERASE 2 +#define VINTR 3 +#define VKILL 4 +#define VMIN 5 +#define VQUIT 6 +#define VSTART 7 +#define VSTOP 8 +#define VSUSP 9 +#define VTIME 10 + +#define NCCS 11 + +struct termios +{ + tcflag_t c_iflag; /* Input modes. */ + tcflag_t c_oflag; /* Output modes. */ + tcflag_t c_cflag; /* Control modes. */ + tcflag_t c_lflag; /* Local modes. */ + cc_t c_cc[NCCS]; /* Control characters. */ +}; -// c_iflag #define BRKINT 0x001 #define ICRNL 0x002 #define IGNBRK 0x004 @@ -19,51 +50,65 @@ #define IXON 0x400 #define PARMRK 0x800 -// c_oflag -#define OPOST 0x0001 -#define ONLCR 0x0002 -#define OCRNL 0x0004 -#define ONOCR 0x0008 -#define ONLRET 0x0010 -#define OFDEL 0x0020 -#define OFILL 0x0040 -#define NLDLY 0x0080 - #define NL0 0 - #define NL1 1 -#define CRDLY 0x0100 - #define CR0 0 - #define CR1 1 - #define CR2 2 - #define CR3 3 -#define TABDLY 0x0200 - #define TAB0 0 - #define TAB1 1 - #define TAB2 2 - #define TAB3 3 -#define BSDLY 0x0400 - #define BS0 0 - #define BS1 1 -#define VTDLY 0x0800 - #define VT0 0 - #define VT1 1 -#define FFDLY 0x1000 - #define FF0 0 - #define FF1 1 +#define OPOST 0x0001 +#define ONLCR 0x0002 +#define OCRNL 0x0004 +#define ONOCR 0x0008 +#define ONLRET 0x0010 +#define OFDEL 0x0020 +#define OFILL 0x0040 +#define NLDLY 0x0080 + #define NL0 0x0000 + #define NL1 0x0080 +#define CRDLY 0x0300 + #define CR0 0x0000 + #define CR1 0x0100 + #define CR2 0x0200 + #define CR3 0x0300 +#define TABDLY 0x0C00 + #define TAB0 0x0000 + #define TAB1 0x0400 + #define TAB2 0x0800 + #define TAB3 0x0C00 +#define BSDLY 0x1000 + #define BS0 0x0000 + #define BS1 0x1000 +#define VTDLY 0x2000 + #define VT0 0x0000 + #define VT1 0x2000 +#define FFDLY 0x4000 + #define FF0 0x0000 + #define FF1 0x4000 -// c_cflag -#define CSIZE 0x01 - #define CS5 5 - #define CS6 6 - #define CS7 7 - #define CS8 8 -#define CSTOPB 0x02 -#define CREAD 0x04 -#define PARENB 0x08 -#define PARODD 0x10 -#define HUPCL 0x20 -#define CLOCAL 0x40 +#define B0 0 +#define B50 1 +#define B75 2 +#define B110 3 +#define B134 4 +#define B150 5 +#define B200 6 +#define B300 7 +#define B600 8 +#define B1200 9 +#define B1800 10 +#define B2400 11 +#define B4800 12 +#define B9600 13 +#define B19200 14 +#define B38400 15 + +#define CSIZE 0x03 + #define CS5 0x00 + #define CS6 0x01 + #define CS7 0x02 + #define CS8 0x03 +#define CSTOPB 0x04 +#define CREAD 0x08 +#define PARENB 0x10 +#define PARODD 0x20 +#define HUPCL 0x40 +#define CLOCAL 0x80 -// c_lflag #define ECHO 0x001 #define ECHOE 0x002 #define ECHOK 0x004 @@ -74,47 +119,31 @@ #define NOFLSH 0x080 #define TOSTOP 0x100 -// for tcsetattr -#define TCSANOW 1 -#define TCSADRAIN 2 -#define TCSAFLUSH 3 +#define TCSANOW 0 +#define TCSADRAIN 1 +#define TCSAFLUSH 2 -// for tcflush #define TCIFLUSH 0x01 -#define TCIOFLUSH (TCIFLUSH | TCOFLUSH) #define TCOFLUSH 0x02 +#define TCIOFLUSH (TCIFLUSH | TCOFLUSH) -// for tcflow -#define TCIOFF 1 -#define TCION 2 -#define TCOOFF 3 -#define TCOON 4 +#define TCIOFF 0 +#define TCION 1 +#define TCOOFF 2 +#define TCOON 3 -__BEGIN_DECLS - -typedef int cc_t; -typedef int speed_t; -typedef int tcflag_t; - -struct termios -{ - tcflag_t c_iflag; - tcflag_t c_oflag; - tcflag_t c_cflag; - tcflag_t c_lflag; - cc_t c_cc[NCCS]; -}; - -speed_t cfgetispeed(const struct termios*); -speed_t cfgetospeed(const struct termios*); -int cfsetispeed(struct termios*, speed_t); -int cfsetospeed(struct termios*, speed_t); -int tcdrain(int); -int tcflow(int, int); -int tcflush(int, int); -int tcgetattr(int, struct termios*); -pid_t tcgetsid(int); -int tcsendbreak(int, int); -int tcsetattr(int, int, const struct termios*); +speed_t cfgetispeed(const struct termios* termios_p); +speed_t cfgetospeed(const struct termios* termios_p); +int cfsetispeed(struct termios* termios_p, speed_t speed); +int cfsetospeed(struct termios* termios_p, speed_t speed); +int tcdrain(int fildes); +int tcflow(int fildes, int action); +int tcflush(int fildes, int queue_selector); +int tcgetattr(int fildes, struct termios* termios_p); +pid_t tcgetsid(int fildes); +int tcsendbreak(int fildes, int duration); +int tcsetattr(int fildes, int optional_actions, const struct termios* termios_p); __END_DECLS + +#endif diff --git a/libc/include/tgmath.h b/libc/include/tgmath.h new file mode 100644 index 0000000000..cd722ed701 --- /dev/null +++ b/libc/include/tgmath.h @@ -0,0 +1,17 @@ +#ifndef _TGMATH_H +#define _TGMATH_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/tgmath.h.html + +#include + +__BEGIN_DECLS + +#include +#include + +// FIXME + +__END_DECLS + +#endif diff --git a/libc/include/time.h b/libc/include/time.h index 6b60fd2dd5..3fc9818d2a 100644 --- a/libc/include/time.h +++ b/libc/include/time.h @@ -1,56 +1,97 @@ -#pragma once +#ifndef _TIME_H +#define _TIME_H 1 -#include -#include +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/time.h.html + +#include __BEGIN_DECLS +#define __need_clock_t +#define __need_size_t +#define __need_time_t +#define __need_clockid_t +#define __need_timer_t +#define __need_pid_t +#include + +#define __need_NULL +#include + +#include + +#include + struct tm { - int tm_sec; - int tm_min; - int tm_hour; - int tm_mday; - int tm_mon; - int tm_year; - int tm_wday; - int tm_yday; - int tm_isdst; + int tm_sec; /* Seconds [0,60]. */ + int tm_min; /* Minutes [0,59]. */ + int tm_hour; /* Hour [0,23]. */ + int tm_mday; /* Day of month [1,31]. */ + int tm_mon; /* Month of year [0,11]. */ + int tm_year; /* Years since 1900. */ + int tm_wday; /* Day of week [0,6] (Sunday =0). */ + int tm_yday; /* Day of year [0,365]. */ + int tm_isdst; /* Daylight Savings flag. */ }; struct timespec { - time_t tv_sec; - long tv_nsec; + time_t tv_sec; /* Seconds. */ + long tv_nsec; /* Nanoseconds. */ }; -char* asctime(const struct tm*); -char* asctime_r(const struct tm*, char*); +struct itimerspec +{ + struct timespec it_interval; /* Timer period. */ + struct timespec it_value; /* Timer expiration. */ +}; + +#define CLOCKS_PER_SEC ((clock_t)1000000) + +#define CLOCK_MONOTONIC 0 +#define CLOCK_PROCESS_CPUTIME_ID 1 +#define CLOCK_REALTIME 2 +#define CLOCK_THREAD_CPUTIME_ID 3 + +#define TIMER_ABSTIME 1 + +// FIXME +// #define getdate_err(int) + +char* asctime(const struct tm* timeptr); +char* asctime_r(const struct tm* __restrict tm, char* __restrict buf); clock_t clock(void); -int clock_getcpuclockid(pid_t, clockid_t*); -int clock_getres(clockid_t, struct timespe*); -int clock_gettime(clockid_t, struct timespec*); -int clock_nanosleep(clockid_t, int, const struct timespec*, struct timespec*); -int clock_settime(clockid_t, const struct timespec*); -char* ctime(const time_t*); -char* ctime_r(const time_t*, char*); -double difftime(time_t, time_t); -struct tm* getdate(const char*); -struct tm* gmtime(const time_t*); -struct tm* gmtime_r(const time_t*, struct tm*); -struct tm* localtime(const time_t*); -struct tm* localtime_r(const time_t*, struct tm*); -time_t mktime(struct tm*); -int nanosleep(const struct timespec*, struct timespec*); -size_t strftime(char*, size_t, const char*, const struct tm*); -size_t strftime_l(char*, size_t, const char*, const struct tm*, locale_t); -char *strptime(const char*, const char*, struct tm*); -time_t time(time_t*); -int timer_create(clockid_t, struct sigevent*, timer_t*); -int timer_delete(timer_t); -int timer_getoverrun(timer_t); -int timer_gettime(timer_t, struct itimerspec*); -int timer_settime(timer_t, int, const struct itimerspec*, struct itimerspec*); +int clock_getcpuclockid(pid_t pid, clockid_t* clock_id); +int clock_getres(clockid_t clock_id, struct timespec* res); +int clock_gettime(clockid_t clock_id, struct timespec* tp); +int clock_nanosleep(clockid_t clock_id, int flags, const struct timespec* rqtp, struct timespec* rmtp); +int clock_settime(clockid_t clock_id, const struct timespec* tp); +char* ctime(const time_t* clock); +char* ctime_r(const time_t* clock, char* buf); +double difftime(time_t time1, time_t time0); +struct tm* getdate(const char* string); +struct tm* gmtime(const time_t* timer); +struct tm* gmtime_r(const time_t* __restrict timer, struct tm* __restrict result); +struct tm* localtime(const time_t* timer); +struct tm* localtime_r(const time_t* __restrict timer, struct tm* __restrict result); +time_t mktime(struct tm* timeptr); +int nanosleep(const struct timespec* rqtp, struct timespec* rmtp); +size_t strftime(char* __restrict s, size_t maxsize, const char* __restrict format, const struct tm* __restrict timeptr); +size_t strftime_l(char* __restrict s, size_t maxsize, const char* __restrict format, const struct tm* __restrict timeptr, locale_t locale); +char* strptime(const char* __restrict buf, const char* __restrict format, struct tm* __restrict tm); +time_t time(time_t* tloc); +int timer_create(clockid_t clockid, struct sigevent* __restrict evp, timer_t* __restrict timerid); +int timer_delete(timer_t timerid); +int timer_getoverrun(timer_t timerid); +int timer_gettime(timer_t timerid, struct itimerspec* value); +int timer_settime(timer_t timerid, int, const struct itimerspec* __restrict value, struct itimerspec* __restrict ovalue); void tzset(void); -__END_DECLS \ No newline at end of file +extern int daylight; +extern long timezone; +extern char* tzname[]; + +__END_DECLS + +#endif diff --git a/libc/include/ulimit.h b/libc/include/ulimit.h new file mode 100644 index 0000000000..f090ec657a --- /dev/null +++ b/libc/include/ulimit.h @@ -0,0 +1,17 @@ +#ifndef _ULIMIT_H +#define _ULIMIT_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/ulimit.h.html + +#include + +__BEGIN_DECLS + +#define UL_GETFSIZE 0 +#define UL_SETFSIZE 1 + +long ulimit(int, ...); + +__END_DECLS + +#endif diff --git a/libc/include/unistd.h b/libc/include/unistd.h index ec9f57780a..21b6f3abf6 100644 --- a/libc/include/unistd.h +++ b/libc/include/unistd.h @@ -1,96 +1,216 @@ -#pragma once +#ifndef _UNISTD_H +#define _UNISTD_H 1 +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/unistd.h.html + +#include + +__BEGIN_DECLS + +#define _POSIX_VERSION 200809L +#define _POSIX2_VERSION -1 +#define _XOPEN_VERSION 700 + +#define _POSIX_ADVISORY_INFO -1 +#define _POSIX_ASYNCHRONOUS_IO -1 +#define _POSIX_BARRIERS -1 +#define _POSIX_CHOWN_RESTRICTED -1 +#define _POSIX_CLOCK_SELECTION -1 +#define _POSIX_CPUTIME -1 +#define _POSIX_FSYNC -1 +#define _POSIX_IPV6 -1 +#define _POSIX_JOB_CONTROL -1 +#define _POSIX_MAPPED_FILES -1 +#define _POSIX_MEMLOCK -1 +#define _POSIX_MEMLOCK_RANGE -1 +#define _POSIX_MEMORY_PROTECTION -1 +#define _POSIX_MESSAGE_PASSING -1 +#define _POSIX_MONOTONIC_CLOCK -1 +#define _POSIX_NO_TRUNC -1 +#define _POSIX_PRIORITIZED_IO -1 +#define _POSIX_PRIORITY_SCHEDULING -1 +#define _POSIX_RAW_SOCKETS -1 +#define _POSIX_READER_WRITER_LOCKS -1 +#define _POSIX_REALTIME_SIGNALS -1 +#define _POSIX_REGEXP -1 +#define _POSIX_SAVED_IDS -1 +#define _POSIX_SEMAPHORES -1 +#define _POSIX_SHARED_MEMORY_OBJECTS -1 +#define _POSIX_SHELL -1 +#define _POSIX_SPAWN -1 +#define _POSIX_SPIN_LOCKS -1 +#define _POSIX_SPORADIC_SERVER -1 +#define _POSIX_SYNCHRONIZED_IO xx +#define _POSIX_THREAD_ATTR_STACKADDR -1 +#define _POSIX_THREAD_ATTR_STACKSIZE -1 +#define _POSIX_THREAD_CPUTIME -1 +#define _POSIX_THREAD_PRIO_INHERIT -1 +#define _POSIX_THREAD_PRIO_PROTECT -1 +#define _POSIX_THREAD_PRIORITY_SCHEDULING -1 +#define _POSIX_THREAD_PROCESS_SHARED -1 +#define _POSIX_THREAD_ROBUST_PRIO_INHERIT -1 +#define _POSIX_THREAD_ROBUST_PRIO_PROTECT -1 +#define _POSIX_THREAD_SAFE_FUNCTIONS -1 +#define _POSIX_THREAD_SPORADIC_SERVER -1 +#define _POSIX_THREADS -1 +#define _POSIX_TIMEOUTS -1 +#define _POSIX_TIMERS -1 +#define _POSIX_TRACE -1 +#define _POSIX_TRACE_EVENT_FILTER -1 +#define _POSIX_TRACE_INHERIT -1 +#define _POSIX_TRACE_LOG -1 +#define _POSIX_TYPED_MEMORY_OBJECTS -1 +#define _POSIX_V6_ILP32_OFF32 -1 +#define _POSIX_V6_ILP32_OFFBIG -1 +#define _POSIX_V6_LP64_OFF64 -1 +#define _POSIX_V6_LPBIG_OFFBIG -1 +#define _POSIX_V7_ILP32_OFF32 -1 +#define _POSIX_V7_ILP32_OFFBIG -1 +#define _POSIX_V7_LP64_OFF64 -1 +#define _POSIX_V7_LPBIG_OFFBIG -1 +#define _POSIX2_C_BIND -1 +#define _POSIX2_C_DEV -1 +#define _POSIX2_CHAR_TERM -1 +#define _POSIX2_FORT_DEV -1 +#define _POSIX2_FORT_RUN -1 +#define _POSIX2_LOCALEDEF -1 +#define _POSIX2_PBS -1 +#define _POSIX2_PBS_ACCOUNTING -1 +#define _POSIX2_PBS_CHECKPOINT -1 +#define _POSIX2_PBS_LOCATE -1 +#define _POSIX2_PBS_MESSAGE -1 +#define _POSIX2_PBS_TRACK -1 +#define _POSIX2_SW_DEV -1 +#define _POSIX2_UPE -1 +#define _XOPEN_CRYPT -1 +#define _XOPEN_ENH_I18N -1 +#define _XOPEN_REALTIME -1 +#define _XOPEN_REALTIME_THREADS -1 +#define _XOPEN_SHM -1 +#define _XOPEN_STREAMS -1 +#define _XOPEN_UNIX -1 +#define _XOPEN_UUCP -1 + +#include +#include +#include + +#define __need_size_t +#define __need_ssize_t +#define __need_uid_t +#define __need_gid_t +#define __need_off_t +#define __need_pid_t #include +// FIXME: _CS prefixed definitions + +// FIXME: _PC prefixed definitions + +#define F_OK 0x01 +#define R_OK 0x02 +#define W_OK 0x04 +#define X_OK 0x08 + +#define F_LOCK 0 +#define F_TEST 1 +#define F_TLOCK 2 +#define F_ULOCK 3 + #define STDIN_FILENO 0 #define STDOUT_FILENO 1 #define STDERR_FILENO 2 -__BEGIN_DECLS +#define _POSIX_VDISABLE 0 -int access(const char*, int); -unsigned alarm(unsigned); -int chdir(const char*); -int chown(const char*, uid_t, gid_t); -int close(int); -size_t confstr(int, char*, size_t); -char* crypt(const char*, const char*); -int dup(int); -int dup2(int, int); -void _exit(int); -void encrypt(char[64], int); -int execl(const char*, const char*, ...); -int execle(const char*, const char*, ...); -int execlp(const char*, const char*, ...); -int execv(const char*, char* const[]); -int execve(const char*, char* const[], char* const[]); -int execvp(const char*, char* const[]); -int faccessat(int, const char*, int, int); -int fchdir(int); -int fchown(int, uid_t, gid_t); -int fchownat(int, const char*, uid_t, gid_t, int); -int fdatasync(int); -int fexecve(int, char* const[], char* const[]); -pid_t fork(void); -long fpathconf(int, int); -int fsync(int); -int ftruncate(int, off_t); -char* getcwd(char*, size_t); -gid_t getegid(void); -uid_t geteuid(void); -gid_t getgid(void); -int getgroups(int, gid_t[]); -long gethostid(void); -int gethostname(char*, size_t); -char* getlogin(void); -int getlogin_r(char*, size_t); -int getopt(int, char* const[], const char*); -pid_t getpgid(pid_t); -pid_t getpgrp(void); -pid_t getpid(void); -pid_t getppid(void); -pid_t getsid(pid_t); -uid_t getuid(void); -int isatty(int); -int lchown(const char*, uid_t, gid_t); -int link(const char*, const char*); -int linkat(int, const char*, int, const char*, int); -int lockf(int, int, off_t); -off_t lseek(int, off_t, int); -int nice(int); -long pathconf(const char*, int); -int pause(void); -int pipe(int[2]); -ssize_t pread(int, void*, size_t, off_t); -ssize_t pwrite(int, const void*, size_t, off_t); -ssize_t read(int, void*, size_t); -ssize_t readlink(const char*, char*, size_t); -ssize_t readlinkat(int, const char*, char*, size_t); -int rmdir(const char*); -int setegid(gid_t); -int seteuid(uid_t); -int setgid(gid_t); -int setpgid(pid_t, pid_t); -pid_t setpgrp(void); -int setregid(gid_t, gid_t); -int setreuid(uid_t, uid_t); -pid_t setsid(void); -int setuid(uid_t); -unsigned sleep(unsigned); -void swab(const void*, void*, ssize_t); -int symlink(const char*, const char*); -int symlinkat(const char*, int, const char*); -void sync(void); -long sysconf(int); -pid_t tcgetpgrp(int); -int tcsetpgrp(int, pid_t); -int truncate(const char*, off_t); -char* ttyname(int); -int ttyname_r(int, char*, size_t); -int unlink(const char*); -int unlinkat(int, const char*, int); -ssize_t write(int, const void*, size_t); +int access(const char* path, int amode); +unsigned alarm(unsigned seconds); +int chdir(const char* path); +int chown(const char* path, uid_t owner, gid_t group); +int close(int fildes); +size_t confstr(int name, char* buf, size_t len); +char* crypt(const char* key, const char* salt); +int dup(int fildes); +int dup2(int fildes, int fildes2); +[[noreturn]] void _exit(int status); +void encrypt(char block[64], int edflag); +int execl(const char* path, const char* arg0, ...); +int execle(const char* path, const char* arg0, ...); +int execlp(const char* file, const char* arg0, ...); +int execv(const char* path, char* const argv[]); +int execve(const char* path, char* const argv[], char* const envp[]); +int execvp(const char* file, char* const argv[]); +int faccessat(int fd, const char* path, int amode, int flag); +int fchdir(int fildes); +int fchown(int fildes, uid_t owner, gid_t group); +int fchownat(int fd, const char* path, uid_t owner, gid_t group, int flag); +int fdatasync(int fildes); +int fexecve(int fd, char* const argv[], char* const envp[]); +pid_t fork(void); +long fpathconf(int fildes, int name); +int fsync(int fildes); +int ftruncate(int fildes, off_t length); +char* getcwd(char* buf , size_t size); +gid_t getegid(void); +uid_t geteuid(void); +gid_t getgid(void); +int getgroups(int gidsetsize, gid_t grouplist[]); +long gethostid(void); +int gethostname(char* name, size_t namelen); +char* getlogin(void); +int getlogin_r(char* name, size_t namesize); +int getopt(int argc, char* const argv[], const char* optstring); +pid_t getpgid(pid_t pid); +pid_t getpgrp(void); +pid_t getpid(void); +pid_t getppid(void); +pid_t getsid(pid_t pid); +uid_t getuid(void); +int isatty(int fildes); +int lchown(const char* path, uid_t owner, gid_t group); +int link(const char* path1, const char* path2); +int linkat(int fd1, const char* path1, int fd2, const char* path2, int flag); +int lockf(int fildes, int function, off_t size); +off_t lseek(int fildes, off_t offset, int whence); +int nice(int incr); +long pathconf(const char* path, int name); +int pause(void); +int pipe(int fildes[2]); +ssize_t pread(int fildes, void* buf, size_t nbyte, off_t offset); +ssize_t pwrite(int fildes, const void* buf, size_t nbyte, off_t offset); +ssize_t read(int fildes, void* buf, size_t nbyte); +ssize_t readlink(const char* __restrict path, char* __restrict buf, size_t bufsize); +ssize_t readlinkat(int fd, const char* __restrict path, char* __restrict buf, size_t bufsize); +int rmdir(const char* path); +int setegid(gid_t gid); +int seteuid(uid_t uid); +int setgid(gid_t gid); +int setpgid(pid_t pid, pid_t pgid); +pid_t setpgrp(void); +int setregid(gid_t rgid, gid_t egid); +int setreuid(uid_t ruid, uid_t euid); +pid_t setsid(void); +int setuid(uid_t uid); +unsigned sleep(unsigned seconds); +void swab(const void* __restrict src, void* __restrict dest, ssize_t nbytes); +int symlink(const char* path1, const char* path2); +int symlinkat(const char* path1, int fd, const char* path2); +void sync(void); +long sysconf(int name); +pid_t tcgetpgrp(int fildes); +int tcsetpgrp(int fildes, pid_t pgid_id); +int truncate(const char* path, off_t length); +char* ttyname(int fildes); +int ttyname_r(int fildes, char* name, size_t namesize); +int unlink(const char* path); +int unlinkat(int fd, const char* path, int flag); +ssize_t write(int fildes, const void* buf, size_t nbyte); -long syscall(long, ...); +extern char* optarg; +extern int opterr, optind, optopt; -__END_DECLS \ No newline at end of file +long syscall(long syscall, ...); + +__END_DECLS + +#endif diff --git a/libc/include/utime.h b/libc/include/utime.h new file mode 100644 index 0000000000..b1993eb9ad --- /dev/null +++ b/libc/include/utime.h @@ -0,0 +1,23 @@ +#ifndef _UTIME_H +#define _UTIME_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/utime.h.html + +#include + +__BEGIN_DECLS + +#define __need_time_t +#include + +struct utimbuf +{ + time_t actime; /* Access time. */ + time_t modtime; /* Modification time. */ +}; + +int utime(const char* path, const struct utimbuf* times); + +__END_DECLS + +#endif diff --git a/libc/include/utmpx.h b/libc/include/utmpx.h new file mode 100644 index 0000000000..2299e4b5bc --- /dev/null +++ b/libc/include/utmpx.h @@ -0,0 +1,43 @@ +#ifndef _UTMPX_H +#define _UTMPX_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/utmpx.h.html + +#include + +__BEGIN_DECLS + +#define __need_pid_t +#include + +#include + +struct utmpx +{ + char ut_user[32]; /* User login name. */ + char ut_id[4]; /* Unspecified initialization process identifier. */ + char ut_line[32]; /* Device name. */ + pid_t ut_pid; /* Process ID. */ + short ut_type; /* Type of entry. */ + struct timeval ut_tv; /* Time entry was made. */ +}; + +#define EMPTY 0 +#define BOOT_TIME 1 +#define OLD_TIME 2 +#define NEW_TIME 3 +#define USER_PROCESS 4 +#define INIT_PROCESS 5 +#define LOGIN_PROCESS 6 +#define DEAD_PROCESS 7 + +void endutxent(void); +struct utmpx* getutxent(void); +struct utmpx* getutxid(const struct utmpx* id); +struct utmpx* getutxline(const struct utmpx* line); +struct utmpx* pututxline(const struct utmpx* utmpx); +void setutxent(void); + +__END_DECLS + +#endif diff --git a/libc/include/wchar.h b/libc/include/wchar.h new file mode 100644 index 0000000000..93261373fc --- /dev/null +++ b/libc/include/wchar.h @@ -0,0 +1,123 @@ +#ifndef _WCHAR_H +#define _WCHAR_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/wchar.h.html + +#include + +__BEGIN_DECLS + +#include +#include +#include +#include +#include +#include +#include + +#include + +struct __mbstate_t; +typedef struct __mbstate_t mbstate_t; + +typedef int wctype_t; + +typedef __WINT_TYPE__ wint_t; + +#define WCHAR_MIN __WCHAR_MIN__ +#define WCHAR_MAX __WCHAR_MAX__ +#define WEOF ((wchar_t)-1) + +wint_t btowc(int c); +wint_t fgetwc(FILE* stream); +wchar_t* fgetws(wchar_t* __restrict ws, int n, FILE* __restrict stream); +wint_t fputwc(wchar_t c, FILE* stream); +int fputws(const wchar_t* __restrict ws, FILE* __restrict stream); +int fwide(FILE* stream, int mode); +int fwprintf(FILE* __restrict stream, const wchar_t* __restrict format, ...); +int fwscanf(FILE* __restrict stream, const wchar_t* __restrict format, ...); +wint_t getwc(FILE* stream); +wint_t getwchar(void); +int iswalnum(wint_t wc); +int iswalpha(wint_t wc); +int iswcntrl(wint_t wc); +int iswctype(wint_t wc, wctype_t charclass); +int iswdigit(wint_t wc); +int iswgraph(wint_t wc); +int iswlower(wint_t wc); +int iswprint(wint_t wc); +int iswpunct(wint_t wc); +int iswspace(wint_t wc); +int iswupper(wint_t wc); +int iswxdigit(wint_t wc); +size_t mbrlen(const char* __restrict s, size_t n, mbstate_t* __restrict ps); +size_t mbrtowc(wchar_t* __restrict pwc, const char* __restrict s, size_t n, mbstate_t* __restrict ps); +int mbsinit(const mbstate_t* ps); +size_t mbsnrtowcs(wchar_t* __restrict dst, const char** __restrict src, size_t nmc, size_t len, mbstate_t* __restrict ps); +size_t mbsrtowcs(wchar_t* __restrict dst, const char** __restrict src, size_t len, mbstate_t* __restrict ps); +FILE* open_wmemstream(wchar_t** bufp, size_t* sizep); +wint_t putwc(wchar_t wc, FILE* stream); +wint_t putwchar(wchar_t wc); +int swprintf(wchar_t* __restrict ws, size_t n, const wchar_t* __restrict format, ...); +int swscanf(const wchar_t* __restrict ws, const wchar_t* __restrict format, ...); +wint_t towlower(wint_t wc); +wint_t towupper(wint_t wc); +wint_t ungetwc(wint_t wc, FILE* stream); +int vfwprintf(FILE* __restrict stream, const wchar_t* __restrict format, va_list arg); +int vfwscanf(FILE* __restrict stream, const wchar_t* __restrict format, va_list arg); +int vswprintf(wchar_t* __restrict ws, size_t n, const wchar_t* __restrict format, va_list arg); +int vswscanf(const wchar_t* __restrict ws, const wchar_t* __restrict format, va_list arg); +int vwprintf(const wchar_t* __restrict format, va_list arg); +int vwscanf(const wchar_t* __restrict format, va_list arg); +wchar_t* wcpcpy(wchar_t* __restrict ws1, const wchar_t* __restrict ws2); +wchar_t* wcpncpy(wchar_t* __restrict ws1, const wchar_t* __restrict ws2, size_t n); +size_t wcrtomb(char* __restrict s, wchar_t ws, mbstate_t* __restrict ps); +int wcscasecmp(const wchar_t* ws1, const wchar_t* ws2); +int wcscasecmp_l(const wchar_t* ws1, const wchar_t* ws2, locale_t locale); +wchar_t* wcscat(wchar_t* __restrict ws1, const wchar_t* __restrict ws2); +wchar_t* wcschr(const wchar_t* ws, wchar_t wc); +int wcscmp(const wchar_t* ws1, const wchar_t* ws2); +int wcscoll(const wchar_t* ws1, const wchar_t* ws2); +int wcscoll_l(const wchar_t* ws1, const wchar_t* ws2, locale_t locale); +wchar_t* wcscpy(wchar_t* __restrict ws1, const wchar_t* __restrict ws2); +size_t wcscspn(const wchar_t* ws1, const wchar_t* ws2); +wchar_t* wcsdup(const wchar_t* string); +size_t wcsftime(wchar_t* __restrict wcs, size_t maxsize, const wchar_t* __restrict format, const struct tm* __restrict timeptr); +size_t wcslen(const wchar_t* ws); +int wcsncasecmp(const wchar_t* ws1, const wchar_t* ws2, size_t n); +int wcsncasecmp_l(const wchar_t* ws1, const wchar_t* ws2, size_t n, locale_t locale); +wchar_t* wcsncat(wchar_t* __restrict ws1, const wchar_t* __restrict ws2, size_t n); +int wcsncmp(const wchar_t* ws1, const wchar_t* ws2, size_t n); +wchar_t* wcsncpy(wchar_t* __restrict ws1, const wchar_t* __restrict ws2, size_t n); +size_t wcsnlen(const wchar_t* ws, size_t maxlen); +size_t wcsnrtombs(char* __restrict dst, const wchar_t** __restrict src, size_t nwc, size_t len, mbstate_t* __restrict ps); +wchar_t* wcspbrk(const wchar_t* ws1, const wchar_t* ws2); +wchar_t* wcsrchr(const wchar_t* ws, wchar_t wc); +size_t wcsrtombs(char* __restrict dst, const wchar_t** __restrict src, size_t len, mbstate_t* __restrict ps); +size_t wcsspn(const wchar_t* ws1, const wchar_t* ws2); +wchar_t* wcsstr(const wchar_t* __restrict ws1, const wchar_t* __restrict ws2); +double wcstod(const wchar_t* __restrict nptr, wchar_t** __restrict endptr); +float wcstof(const wchar_t* __restrict nptr, wchar_t** __restrict endptr); +wchar_t* wcstok(wchar_t* __restrict ws1, const wchar_t* __restrict ws2, wchar_t** __restrict ptr); +long wcstol(const wchar_t* __restrict nptr, wchar_t** __restrict endptr, int base); +long double wcstold(const wchar_t* __restrict nptr, wchar_t** __restrict endptr); +long long wcstoll(const wchar_t* __restrict nptr, wchar_t** __restrict endptr, int base); +unsigned long wcstoul(const wchar_t* __restrict nptr, wchar_t** __restrict endptr, int base); +unsigned long long wcstoull(const wchar_t* __restrict nptr, wchar_t** __restrict endptr, int base); +int wcswidth(const wchar_t* pwcs, size_t n); +size_t wcsxfrm(wchar_t* __restrict ws1, const wchar_t* __restrict ws2, size_t n); +size_t wcsxfrm_l(wchar_t* __restrict ws1, const wchar_t* __restrict ws2, size_t n, locale_t locale); +int wctob(wint_t c); +wctype_t wctype(const char* property); +int wcwidth(wchar_t wc); +wchar_t* wmemchr(const wchar_t* ws, wchar_t wc, size_t n); +int wmemcmp(const wchar_t* ws1, const wchar_t* ws2, size_t n); +wchar_t* wmemcpy(wchar_t* __restrict ws1, const wchar_t* __restrict ws2, size_t n); +wchar_t* wmemmove(wchar_t* ws1, const wchar_t* ws2, size_t n); +wchar_t* wmemset(wchar_t* ws, wchar_t wc, size_t n); +int wprintf(const wchar_t* __restrict format, ...); +int wscanf(const wchar_t* __restrict format, ...); + +__END_DECLS + +#endif diff --git a/libc/include/wctype.h b/libc/include/wctype.h new file mode 100644 index 0000000000..176a06793f --- /dev/null +++ b/libc/include/wctype.h @@ -0,0 +1,62 @@ +#ifndef _WCTYPE_H +#define _WCTYPE_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/wctype.h.html + +#include + +__BEGIN_DECLS + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +typedef int* wctrans_t; + +int iswalnum(wint_t wc); +int iswalnum_l(wint_t wc, locale_t locale); +int iswalpha(wint_t wc); +int iswalpha_l(wint_t wc, locale_t locale); +int iswblank(wint_t wc); +int iswblank_l(wint_t wc, locale_t locale); +int iswcntrl(wint_t wc); +int iswcntrl_l(wint_t wc, locale_t locale); +int iswctype(wint_t wc, wctype_t); +int iswctype_l(wint_t wc, wctype_t, locale_t locale); +int iswdigit(wint_t wc); +int iswdigit_l(wint_t wc, locale_t locale); +int iswgraph(wint_t wc); +int iswgraph_l(wint_t wc, locale_t locale); +int iswlower(wint_t wc); +int iswlower_l(wint_t wc, locale_t locale); +int iswprint(wint_t wc); +int iswprint_l(wint_t wc, locale_t locale); +int iswpunct(wint_t wc); +int iswpunct_l(wint_t wc, locale_t locale); +int iswspace(wint_t wc); +int iswspace_l(wint_t wc, locale_t locale); +int iswupper(wint_t wc); +int iswupper_l(wint_t wc, locale_t locale); +int iswxdigit(wint_t wc); +int iswxdigit_l(wint_t wc, locale_t locale); +wint_t towctrans(wint_t wc, wctrans_t); +wint_t towctrans_l(wint_t wc, wctrans_t, locale_t locale); +wint_t towlower(wint_t wc); +wint_t towlower_l(wint_t wc, locale_t locale); +wint_t towupper(wint_t wc); +wint_t towupper_l(wint_t wc, locale_t locale); +wctrans_t wctrans(const char* charclass); +wctrans_t wctrans_l(const char* charclass, locale_t locale); +wctype_t wctype(const char* property); +wctype_t wctype_l(const char* property, locale_t locale); + +__END_DECLS + +#endif diff --git a/libc/include/wordexp.h b/libc/include/wordexp.h new file mode 100644 index 0000000000..c593ea3790 --- /dev/null +++ b/libc/include/wordexp.h @@ -0,0 +1,38 @@ +#ifndef _WORDEXP_H +#define _WORDEXP_H 1 + +// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/wordexp.h.html + +#include + +__BEGIN_DECLS + +#define __need_size_t +#include + +typedef struct +{ + size_t we_wordc; /* Count of words matched by words. */ + char** we_wordv; /* Pointer to list of expanded words. */ + size_t we_offs; /* Slots to reserve at the beginning of we_wordv. */ +} wordexp_t; + +#define WRDE_APPEND 0x01 +#define WRDE_DOOFFS 0x02 +#define WRDE_NOCMD 0x04 +#define WRDE_REUSE 0x08 +#define WRDE_SHOWERR 0x10 +#define WRDE_UNDEF 0x20 + +#define WRDE_BADCHAR 1 +#define WRDE_BADVAL 2 +#define WRDE_CMDSUB 3 +#define WRDE_NOSPACE 4 +#define WRDE_SYNTAX 5 + +int wordexp(const char* __restrict words, wordexp_t* __restrict pwordexp, int flags); +void wordfree(wordexp_t* pwordexp); + +__END_DECLS + +#endif diff --git a/libc/printf_impl.cpp b/libc/printf_impl.cpp index bd059c6a07..ea25498763 100644 --- a/libc/printf_impl.cpp +++ b/libc/printf_impl.cpp @@ -1,5 +1,6 @@ #include #include +#include #include #include #include diff --git a/libc/stdio.cpp b/libc/stdio.cpp index eecfe8e810..669d6c186a 100644 --- a/libc/stdio.cpp +++ b/libc/stdio.cpp @@ -1,6 +1,6 @@ +#include #include #include -#include #include #include #include diff --git a/libc/unistd.cpp b/libc/unistd.cpp index 98236c31fb..0c697a8c85 100644 --- a/libc/unistd.cpp +++ b/libc/unistd.cpp @@ -1,4 +1,5 @@ #include +#include #include #include #include