/*
 * stdlib.h
 *
 * Definitions for common types, variables, and functions.
 */

#ifndef _STDLIB_H_
#define _STDLIB_H_

#include <machine/ieeefp.h>
#include "_ansi.h"

#define __need_size_t
#define __need_wchar_t
#define __need_NULL
#include <stddef.h>

#include <sys/reent.h>
#include <sys/cdefs.h>
#include <machine/stdlib.h>
#ifndef __STRICT_ANSI__
#include <alloca.h>
#endif

#ifdef __CYGWIN__
#include <cygwin/stdlib.h>
#endif

#if __GNU_VISIBLE
#include <xlocale.h>
#endif

_BEGIN_STD_C

typedef struct {
    int quot; /* quotient */
    int rem;  /* remainder */
} div_t;

typedef struct {
    long quot; /* quotient */
    long rem;  /* remainder */
} ldiv_t;

#if __ISO_C_VISIBLE >= 1999
typedef struct {
    long long int quot; /* quotient */
    long long int rem;  /* remainder */
} lldiv_t;
#endif

#ifndef __compar_fn_t_defined
#define __compar_fn_t_defined
typedef int (*__compar_fn_t)(const void*, const void*);
#endif

#define EXIT_FAILURE 1
#define EXIT_SUCCESS 0

#define RAND_MAX __RAND_MAX

int __locale_mb_cur_max(void);

#define MB_CUR_MAX __locale_mb_cur_max()

void abort(void) _ATTRIBUTE((__noreturn__));
int abs(int);
#if __BSD_VISIBLE
__uint32_t arc4random(void);
__uint32_t arc4random_uniform(__uint32_t);
void arc4random_buf(void*, size_t);
#endif
int atexit(void (*__func)(void));
double atof(const char* __nptr);
#if __MISC_VISIBLE
float atoff(const char* __nptr);
#endif
int atoi(const char* __nptr);
int _atoi_r(struct _reent*, const char* __nptr);
long atol(const char* __nptr);
long _atol_r(struct _reent*, const char* __nptr);
void* bsearch(const void* __key, const void* __base, size_t __nmemb,
              size_t __size, __compar_fn_t _compar);
void* calloc(size_t __nmemb, size_t __size) _NOTHROW;
div_t div(int __numer, int __denom);
void exit(int __status) _ATTRIBUTE((__noreturn__));
void free(void*) _NOTHROW;
char* getenv(const char* __string);
char* _getenv_r(struct _reent*, const char* __string);
char* _findenv(const char*, int*);
char* _findenv_r(struct _reent*, const char*, int*);
#if __POSIX_VISIBLE >= 200809
extern char* suboptarg; /* getsubopt(3) external variable */
int getsubopt(char**, char* const*, char**);
#endif
long labs(long);
ldiv_t ldiv(long __numer, long __denom);
void* malloc(size_t __size) _NOTHROW;
int mblen(const char*, size_t);
int _mblen_r(struct _reent*, const char*, size_t, _mbstate_t*);
int mbtowc(wchar_t* __restrict, const char* __restrict, size_t);
int _mbtowc_r(struct _reent*, wchar_t* __restrict, const char* __restrict,
              size_t, _mbstate_t*);
int wctomb(char*, wchar_t);
int _wctomb_r(struct _reent*, char*, wchar_t, _mbstate_t*);
size_t mbstowcs(wchar_t* __restrict, const char* __restrict, size_t);
size_t _mbstowcs_r(struct _reent*, wchar_t* __restrict, const char* __restrict,
                   size_t, _mbstate_t*);
size_t wcstombs(char* __restrict, const wchar_t* __restrict, size_t);
size_t _wcstombs_r(struct _reent*, char* __restrict, const wchar_t* __restrict,
                   size_t, _mbstate_t*);
#ifndef _REENT_ONLY
#if __BSD_VISIBLE || __POSIX_VISIBLE >= 200809
char* mkdtemp(char*);
#endif
#if __GNU_VISIBLE
int mkostemp(char*, int);
int mkostemps(char*, int, int);
#endif
#if __MISC_VISIBLE || __POSIX_VISIBLE >= 200112 || __XSI_VISIBLE >= 4
int mkstemp(char*);
#endif
#if __MISC_VISIBLE
int mkstemps(char*, int);
#endif
#if __BSD_VISIBLE || (__XSI_VISIBLE >= 4 && __POSIX_VISIBLE < 200112)
char* mktemp(char*) _ATTRIBUTE((
    __deprecated__("the use of `mktemp' is dangerous; use `mkstemp' instead")));
#endif
#endif /* !_REENT_ONLY */
char* _mkdtemp_r(struct _reent*, char*);
int _mkostemp_r(struct _reent*, char*, int);
int _mkostemps_r(struct _reent*, char*, int, int);
int _mkstemp_r(struct _reent*, char*);
int _mkstemps_r(struct _reent*, char*, int);
char* _mktemp_r(struct _reent*, char*) _ATTRIBUTE((
    __deprecated__("the use of `mktemp' is dangerous; use `mkstemp' instead")));
void qsort(void* __base, size_t __nmemb, size_t __size, __compar_fn_t _compar);
int rand(void);
void* realloc(void* __r, size_t __size) _NOTHROW;
#if __BSD_VISIBLE
void* reallocarray(void*, size_t, size_t) __result_use_check __alloc_size(2)
    __alloc_size(3);
void* reallocf(void* __r, size_t __size);
#endif
#if __BSD_VISIBLE || __XSI_VISIBLE >= 4
char* realpath(const char* __restrict path, char* __restrict resolved_path);
#endif
#if __BSD_VISIBLE
int rpmatch(const char* response);
#endif
#if __XSI_VISIBLE
void setkey(const char* __key);
#endif
void srand(unsigned __seed);
double strtod(const char* __restrict __n, char** __restrict __end_PTR);
double _strtod_r(struct _reent*, const char* __restrict __n,
                 char** __restrict __end_PTR);
#if __ISO_C_VISIBLE >= 1999
float strtof(const char* __restrict __n, char** __restrict __end_PTR);
#endif
#if __MISC_VISIBLE
/* the following strtodf interface is deprecated...use strtof instead */
#ifndef strtodf
#define strtodf strtof
#endif
#endif
long strtol(const char* __restrict __n, char** __restrict __end_PTR,
            int __base);
long _strtol_r(struct _reent*, const char* __restrict __n,
               char** __restrict __end_PTR, int __base);
unsigned long strtoul(const char* __restrict __n, char** __restrict __end_PTR,
                      int __base);
unsigned long _strtoul_r(struct _reent*, const char* __restrict __n,
                         char** __restrict __end_PTR, int __base);

#if __GNU_VISIBLE
double strtod_l(const char* __restrict, char** __restrict, locale_t);
float strtof_l(const char* __restrict, char** __restrict, locale_t);
#ifdef _HAVE_LONG_DOUBLE
extern long double strtold_l(const char* __restrict, char** __restrict,
                             locale_t);
#endif /* _HAVE_LONG_DOUBLE */
long strtol_l(const char* __restrict, char** __restrict, int, locale_t);
unsigned long strtoul_l(const char* __restrict, char** __restrict, int,
                        locale_t __loc);
long long strtoll_l(const char* __restrict, char** __restrict, int, locale_t);
unsigned long long strtoull_l(const char* __restrict, char** __restrict, int,
                              locale_t __loc);
#endif

int system(const char* __string);

#if __SVID_VISIBLE || __XSI_VISIBLE >= 4
long a64l(const char* __input);
char* l64a(long __input);
char* _l64a_r(struct _reent*, long __input);
#endif
#if __MISC_VISIBLE
int on_exit(void (*__func)(int, void*), void* __arg);
#endif
#if __ISO_C_VISIBLE >= 1999
void _Exit(int __status) _ATTRIBUTE((__noreturn__));
#endif
#if __SVID_VISIBLE || __XSI_VISIBLE
int putenv(char* __string);
#endif
int _putenv_r(struct _reent*, char* __string);
void* _reallocf_r(struct _reent*, void*, size_t);
#if __BSD_VISIBLE || __POSIX_VISIBLE >= 200112
int setenv(const char* __string, const char* __value, int __overwrite);
#endif
int _setenv_r(struct _reent*, const char* __string, const char* __value,
              int __overwrite);

#if __XSI_VISIBLE >= 4 && __POSIX_VISIBLE < 200112
char* gcvt(double, int, char*);
char* gcvtf(float, int, char*);
char* fcvt(double, int, int*, int*);
char* fcvtf(float, int, int*, int*);
char* ecvt(double, int, int*, int*);
char* ecvtbuf(double, int, int*, int*, char*);
char* fcvtbuf(double, int, int*, int*, char*);
char* ecvtf(float, int, int*, int*);
#endif
char* __itoa(int, char*, int);
char* __utoa(unsigned, char*, int);
#if __MISC_VISIBLE
char* itoa(int, char*, int);
char* utoa(unsigned, char*, int);
#endif
#if __POSIX_VISIBLE
int rand_r(unsigned* __seed);
#endif

#if __SVID_VISIBLE || __XSI_VISIBLE
double drand48(void);
double _drand48_r(struct _reent*);
double erand48(unsigned short[3]);
double _erand48_r(struct _reent*, unsigned short[3]);
long jrand48(unsigned short[3]);
long _jrand48_r(struct _reent*, unsigned short[3]);
void lcong48(unsigned short[7]);
void _lcong48_r(struct _reent*, unsigned short[7]);
long lrand48(void);
long _lrand48_r(struct _reent*);
long mrand48(void);
long _mrand48_r(struct _reent*);
long nrand48(unsigned short[3]);
long _nrand48_r(struct _reent*, unsigned short[3]);
unsigned short* seed48(unsigned short[3]);
unsigned short* _seed48_r(struct _reent*, unsigned short[3]);
void srand48(long);
void _srand48_r(struct _reent*, long);
#endif /* __SVID_VISIBLE || __XSI_VISIBLE */
#if __SVID_VISIBLE || __XSI_VISIBLE >= 4 || __BSD_VISIBLE
char* initstate(unsigned, char*, size_t);
long random(void);
char* setstate(char*);
void srandom(unsigned);
#endif
#if __ISO_C_VISIBLE >= 1999
long long atoll(const char* __nptr);
#endif
long long _atoll_r(struct _reent*, const char* __nptr);
#if __ISO_C_VISIBLE >= 1999
long long llabs(long long);
lldiv_t lldiv(long long __numer, long long __denom);
long long strtoll(const char* __restrict __n, char** __restrict __end_PTR,
                  int __base);
#endif
long long _strtoll_r(struct _reent*, const char* __restrict __n,
                     char** __restrict __end_PTR, int __base);
#if __ISO_C_VISIBLE >= 1999
unsigned long long strtoull(const char* __restrict __n,
                            char** __restrict __end_PTR, int __base);
#endif
unsigned long long _strtoull_r(struct _reent*, const char* __restrict __n,
                               char** __restrict __end_PTR, int __base);

#ifndef __CYGWIN__
#if __MISC_VISIBLE
void cfree(void*);
#endif
#if __BSD_VISIBLE || __POSIX_VISIBLE >= 200112
int unsetenv(const char* __string);
#endif
int _unsetenv_r(struct _reent*, const char* __string);
#endif /* !__CYGWIN__ */

#if __POSIX_VISIBLE >= 200112
int __nonnull((1)) posix_memalign(void**, size_t, size_t);
#endif

char* _dtoa_r(struct _reent*, double, int, int, int*, int*, char**);
#ifndef __CYGWIN__
void* _malloc_r(struct _reent*, size_t) _NOTHROW;
void* _calloc_r(struct _reent*, size_t, size_t) _NOTHROW;
void _free_r(struct _reent*, void*) _NOTHROW;
void* _realloc_r(struct _reent*, void*, size_t) _NOTHROW;
void _mstats_r(struct _reent*, char*);
#endif
int _system_r(struct _reent*, const char*);

void __eprintf(const char*, const char*, unsigned int, const char*);

/* There are two common qsort_r variants.  If you request
   _BSD_SOURCE, you get the BSD version; otherwise you get the GNU
   version.  We want that #undef qsort_r will still let you
   invoke the underlying function, but that requires gcc support. */
#if __GNU_VISIBLE
void qsort_r(void* __base, size_t __nmemb, size_t __size,
             int (*_compar)(const void*, const void*, void*), void* __thunk);
#elif __BSD_VISIBLE
#ifdef __GNUC__
void qsort_r(void* __base, size_t __nmemb, size_t __size, void* __thunk,
             int (*_compar)(void*, const void*,
                            const void*)) __asm__(__ASMNAME("__bsd_qsort_r"));
#else
void __bsd_qsort_r(void* __base, size_t __nmemb, size_t __size, void* __thunk,
                   int (*_compar)(void*, const void*, const void*));
#define qsort_r __bsd_qsort_r
#endif
#endif

/* On platforms where long double equals double.  */
#ifdef _HAVE_LONG_DOUBLE
extern long double _strtold_r(struct _reent*, const char* __restrict,
                              char** __restrict);
#if __ISO_C_VISIBLE >= 1999
extern long double strtold(const char* __restrict, char** __restrict);
#endif
#endif /* _HAVE_LONG_DOUBLE */

/*
 * If we're in a mode greater than C99, expose C11 functions.
 */
#if __ISO_C_VISIBLE >= 2011
void* aligned_alloc(size_t, size_t) __malloc_like __alloc_align(1)
    __alloc_size(2);
int at_quick_exit(void (*)(void));
_Noreturn void quick_exit(int);
#endif /* __ISO_C_VISIBLE >= 2011 */

extern int posix_openpt(int oflag);
extern int grantpt(int fd);
extern int unlockpt(int fd);
extern char* ptsname(int fd);

#if __GNU_VISIBLE
extern int ptsname_r(int fd, char* buf, size_t buflen);
#endif

_END_STD_C

#if __SSP_FORTIFY_LEVEL > 0
#include <ssp/stdlib.h>
#endif

#endif /* _STDLIB_H_ */
