os-k/kaleid/include/base/crtlib.h

//----------------------------------------------------------------------------//
//                           GNU GPL OS/K                                     //
//                                                                            //
//  Authors:    spectral`                                                     //
//              NeoX                                                          //
//                                                                            //
//  Desc:       Kaleid C runtime library                                      //
//----------------------------------------------------------------------------//

#ifndef _KALBASE_CRTLIB_H
#define _KALBASE_CRTLIB_H

//------------------------------------------//
//               Typedefs                   //
//------------------------------------------//

#ifndef __error_t_defined
#define __error_t_defined
typedef int                 error_t;
#endif

#ifndef __size_t_defined
#define __size_t_defined
typedef unsigned long       size_t;
#endif

#ifndef __va_list_defined
#define __va_list_defined
typedef __builtin_va_list   va_list;
#endif

#ifndef __div_t_defined
#define __div_t_defined
typedef struct { int quot, rem; }   div_t;
#endif

#ifndef __ldiv_t_defined
#define __ldiv_t_defined
typedef struct { long quot, rem; }  ldiv_t;
#endif

//------------------------------------------//
//              Global variables            //
//------------------------------------------//

#ifndef _KALEID_KERNEL

extern error_t __errno;

#ifndef errno
#define errno __errno
#endif

#define __get_errno(x) error_t x = errno;
#define __set_errno(x) (errno = (x))

#else

#define errno
#define __get_errno(x)
#define __set_errno(x)

#endif

//------------------------------------------//
//                 Macros                   //
//------------------------------------------//

#ifndef _NO_MASK
#define _NO_MASK
#endif

//------------------------------------------//
//            va_list utilities             //
//------------------------------------------//

#ifndef va_start
#define va_start    __builtin_va_start
#endif

#ifndef va_arg
#define va_arg      __builtin_va_arg
#endif

#ifndef va_copy
#define va_copy     __builtin_va_copy
#endif

#ifndef va_end
#define va_end      __builtin_va_end
#endif

//------------------------------------------//
//      Memory management utilities         //
//------------------------------------------//

#ifndef memsetb
#define memsetb  memset
#endif

#ifndef memchrb
#define memchrb  memchr
#endif

void   *memset(void *, int, size_t);
void   *memsetw(void *, int, size_t);
void   *memsetd(void *, int, size_t);
void   *memsetq(void *, long, size_t);

void   *memchr(const void *, int, size_t);
void   *memchrw(const void *, int, size_t);
void   *memchrd(const void *, int, size_t);
void   *memchrq(const void *, long, size_t);

void   *memrchr(const void *, int, size_t);

void   *memcpy(void *restrict, const void *restrict, size_t);
void   *memmove(void *, const void *, size_t);

void   *memzero(void *, size_t);
int     memcmp(const void *, const void *, size_t);

//------------------------------------------//
//      String manipulation utilities       //
//------------------------------------------//

size_t  strlen(const char *);
size_t  strspn(const char *, const char *);
size_t  strcspn(const char *, const char *);

int     strcmp(const char *, const char *);
int     strncmp(const char *, const char *, size_t);

char   *strchr(const char *, int);
char   *strrchr(const char *, int);
char   *strchrnul(const char *, int);

char   *strstr(const char *, const char *);
char   *strpbrk(const char *, const char *);

char   *strtok(char *restrict, const char *restrict);
char   *strtok_r(char *restrict, const char *restrict, char **restrict);

char   *strcpy  (char *restrict, const char *restrict);
char   *strncpy (char *restrict, const char *restrict, size_t);
size_t  strnzcpy(char *restrict, const char *restrict, size_t);

char   *strcat  (char *restrict, const char *restrict);
char   *strncat (char *restrict, const char *restrict, size_t);
size_t  strnzcat(char *restrict, const char *restrict, size_t);

char   *strrev(char *restrict, const char *restrict);
char   *strrev2(char *);

int     sprintf(char *, const char *, ...);
int     snprintf(char *, size_t, const char *, ...);
int     vsprintf(char *, const char *, va_list);
int     vsnprintf(char *, size_t, const char *, va_list);

//------------------------------------------//
//        Type conversion utilities         //
//------------------------------------------//

char    *itoa(int,  char *, int);
char    *ltoa(long, char *, int);
char    *utoa(unsigned int, char *, int);
char    *ultoa(unsigned long, char *, int);

int             atoi(const char *);
long            atol(const char *);
unsigned int    atou(const char *);
unsigned long   atoul(const char *);

long            strtol (const char *restrict, char **restrict, int);
unsigned long   strtoul(const char *restrict, char **restrict, int);

//------------------------------------------//
//              RNG utilities               //
//------------------------------------------//

int     rand(void);
void    srand(unsigned int);

//------------------------------------------//
//              Time utilities              //
//------------------------------------------//

//------------------------------------------//
//            Diverse utilities             //
//------------------------------------------//

char    *strerror(int);
char    *strsignal(int);

//------------------------------------------//
//           Arithmetical macros            //
//------------------------------------------//

#ifndef __abs
#define __abs
static inline int abs(int __x)
{
    return __x < 0 ? -__x : __x;
}
#endif

#ifndef __labs
#define __labs
static inline long labs(long __x)
{
    return __x < 0 ? -__x : __x;
}
#endif

#ifndef __div
#define __div
static inline div_t div(int __x, int __y)
{
    div_t __res;
    __res.quot = __x/__y;
    __res.rem  = __x%__y;
    return __res;
}
#endif

#ifndef __ldiv
#define __ldiv
static inline ldiv_t ldiv(long __x, long __y)
{
    ldiv_t __res;
    __res.quot = __x/__y;
    __res.rem  = __x%__y;
    return __res;
}
#endif

//------------------------------------------//
//              End of header               //
//------------------------------------------//

#endif