pollution: u_char pollution: uchar typedef unsigned char u_char, uchar; pollution: u_short pollution: ushort typedef unsigned short u_short, ushort; pollution: u_int pollution: uint typedef unsigned int u_int, uint; pollution: u_long pollution: ulong typedef unsigned long u_long, ulong; pollution: fd_mask typedef unsigned long fd_mask; pollution: fds_bits unsigned long fds_bits[1024 / 8 / sizeof(long)]; pollution: fd_set typedef struct { unsigned long fds_bits[1024 / 8 / sizeof(long)]; } fd_set; pollution: timeval struct timeval { time_t tv_sec; suseconds_t tv_usec; }; pollution: timeval struct timeval it_interval; pollution: timeval struct timeval it_value; pollution: itimerval struct itimerval { struct timeval it_interval; struct timeval it_value; }; pollution: tz_minuteswest int tz_minuteswest; pollution: tz_dsttime int tz_dsttime; pollution: timezone struct timezone { int tz_minuteswest; int tz_dsttime; }; pollution: which pollution: itimerval pollution: value pollution: getitimer [[deprecated]] int getitimer(int which, struct itimerval *value); pollution: timeval pollution: tp pollution: timezone pollution: tzp pollution: gettimeofday [[deprecated]] int gettimeofday(struct timeval *tp, struct timezone *tzp); pollution: which pollution: itimerval pollution: value pollution: itimerval pollution: ovalue pollution: setitimer [[deprecated]] int setitimer(int which, const struct itimerval *value, struct itimerval *ovalue); pollution: path pollution: timeval pollution: times pollution: utimes int utimes(const char *path, const struct timeval *times); pollution: siginfo typedef struct siginfo siginfo_t; pollution: ucontext typedef struct ucontext ucontext_t; pollution: mcontext typedef struct mcontext mcontext_t; pollution: TzName typedef char *TzName[2]; pollution: daylight extern int daylight; pollution: timezone extern long timezone; pollution: getdate_err extern int getdate_err; pollution: timeptr [[deprecated]] char *asctime(const struct tm *timeptr); pollution: buf pollution: asctime_r [[deprecated]] char *asctime_r(const struct tm *tm, char *buf); pollution: tp int clock_getres(clockid_t clock_id, struct timespec *tp); pollution: tp int clock_gettime(clockid_t clock_id, struct timespec *tp); pollution: tp int clock_settime(clockid_t clock_id, const struct timespec *tp); pollution: buf pollution: ctime_r [[deprecated]] char *ctime_r(const time_t *clock, char *buf); pollution: time1 pollution: time0 double difftime(time_t time1, time_t time0); pollution: timer struct tm *gmtime(const time_t *timer); pollution: result struct tm *gmtime_r(const time_t *clock, struct tm *result); pollution: t struct tm *localtime_r(const time_t *clock, struct tm *t); pollution: timeptr time_t mktime(struct tm *timeptr); pollution: rqtp pollution: rmtp int nanosleep(const struct timespec *rqtp, struct timespec *rmtp); pollution: s pollution: maxsize pollution: format pollution: timeptr size_t strftime(char *s, size_t maxsize, const char *format, const struct tm *timeptr); pollution: tloc time_t time(time_t *tloc); pollution: timegm time_t timegm(struct tm *tm); pollution: timelocal [[deprecated]] time_t timelocal(struct tm *tm); pollution: buf pollution: format char *strptime(const char *buf, const char *format, struct tm *tm); pollution: siginfo struct siginfo { int si_signo; int si_errno; int si_code; pid_t si_pid; uid_t si_uid; void *si_addr; int si_status; union sigval si_value; }; pollution: sigaltstack struct sigaltstack { void *ss_sp; int ss_flags; size_t ss_size; }; pollution: sigaltstack typedef struct sigaltstack stack_t; pollution: ymm_upper uint64_t ymm_upper[16][2]; pollution: fxsave uint64_t fxsave[29][2]; pollution: r15 uintptr_t r15; pollution: r14 uintptr_t r14; pollution: r13 uintptr_t r13; pollution: r12 uintptr_t r12; pollution: rbp uintptr_t rbp; pollution: rbx uintptr_t rbx; pollution: r11 uintptr_t r11; pollution: r10 uintptr_t r10; pollution: r9 uintptr_t r9; pollution: r8 uintptr_t r8; pollution: rax uintptr_t rax; pollution: rcx uintptr_t rcx; pollution: rdx uintptr_t rdx; pollution: rsi uintptr_t rsi; pollution: rdi uintptr_t rdi; pollution: rflags uintptr_t rflags; pollution: rip uintptr_t rip; pollution: rsp uintptr_t rsp; pollution: mcontext struct mcontext { uint64_t ymm_upper[16][2]; uint64_t fxsave[29][2]; uintptr_t r15; uintptr_t r14; uintptr_t r13; uintptr_t r12; uintptr_t rbp; uintptr_t rbx; uintptr_t r11; uintptr_t r10; uintptr_t r9; uintptr_t r8; uintptr_t rax; uintptr_t rcx; uintptr_t rdx; uintptr_t rsi; uintptr_t rdi; uintptr_t rflags; uintptr_t rip; uintptr_t rsp; }; pollution: mcontext typedef struct mcontext mcontext_t; pollution: ucontext struct ucontext { uintptr_t _pad[1] ; ; ucontext_t *uc_link; stack_t uc_stack; sigset_t uc_sigmask; uintptr_t _sival; uint32_t _sigcode; uint32_t _signum; mcontext_t uc_mcontext; }; pollution: ucontext typedef struct ucontext ucontext_t; pollution: siginfo pollution: a void _cbindgen_export_siginfo(struct siginfo a); pollution: jb pollution: savemask pollution: sigsetjmp extern int32_t sigsetjmp(uint64_t *jb, int32_t savemask); pollution: jb pollution: ret int32_t __sigsetjmp_tail(uint64_t *jb, int32_t ret); pollution: jb pollution: ret pollution: siglongjmp void siglongjmp(uint64_t *jb, int32_t ret); pollution: sig int kill(pid_t pid, int sig); pollution: sig pollution: val int sigqueue(pid_t pid, int sig, union sigval val); pollution: pgrp pollution: sig pollution: killpg int killpg(pid_t pgrp, int sig); pollution: thread pollution: sig int pthread_kill(pthread_t thread, int sig); pollution: how pollution: set pollution: oldset int pthread_sigmask(int how, const sigset_t *set, sigset_t *oldset); pollution: sig int raise(int sig); pollution: sig pollution: act pollution: oact int sigaction(int sig, const struct sigaction *act, struct sigaction *oact); pollution: set pollution: signo int sigaddset(sigset_t *set, int signo); pollution: ss pollution: old_ss pollution: sigaltstack int sigaltstack(const stack_t *ss, stack_t *old_ss); pollution: set pollution: signo int sigdelset(sigset_t *set, int signo); pollution: set int sigemptyset(sigset_t *set); pollution: set int sigfillset(sigset_t *set); pollution: sig pollution: sighold int sighold(int sig); pollution: sig pollution: sigignore int sigignore(int sig); pollution: sig pollution: flag pollution: siginterrupt int siginterrupt(int sig, int flag); pollution: set pollution: signo int sigismember(const sigset_t *set, int signo); pollution: sig pollution: func void (*signal(int sig, void (*func)(int)))(int); pollution: sig pollution: sigpause int sigpause(int sig); pollution: set int sigpending(sigset_t *set); pollution: how pollution: set pollution: oset int sigprocmask(int how, const sigset_t *set, sigset_t *oset); pollution: sig pollution: sigrelse int sigrelse(int sig); pollution: sig pollution: func pollution: sigset void (*sigset(int sig, void (*func)(int)))(int); pollution: sigmask int sigsuspend(const sigset_t *sigmask); pollution: set pollution: sig int sigwait(const sigset_t *set, int *sig); pollution: set pollution: siginfo pollution: sig pollution: tp int sigtimedwait(const sigset_t *set, struct siginfo *sig, const struct timespec *tp); pollution: set pollution: sig int sigwaitinfo(const sigset_t *set, siginfo_t *sig); pollution: sig pollution: prefix void psignal(int sig, const char *prefix); pollution: info pollution: prefix void psiginfo(const siginfo_t *info, const char *prefix); pollution: a pollution: b void __completely_unused_cbindgen_workaround_fn_ucontext_mcontext(const ucontext_t *a, const mcontext_t *b); pollution: nfds pollution: readfds pollution: writefds pollution: exceptfds pollution: timeval pollution: timeout pollution: select int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout); wrong type: struct: expected typedef: FILE typedef struct FILE FILE; pollution: s char *ctermid(char *s); pollution: fildes pollution: mode FILE *fdopen(int fildes, const char *mode); pollution: pos int fgetpos(FILE *stream, fpos_t *pos); pollution: original pollution: max char *fgets(char *original, int max, FILE *stream); pollution: file void flockfile(FILE *file); pollution: filename pollution: mode FILE *fopen(const char *filename, const char *mode); pollution: c int fputc(int c, FILE *stream); pollution: s int fputs(const char *s, FILE *stream); pollution: ptr pollution: size pollution: nitems size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream); pollution: filename pollution: mode FILE *freopen(const char *filename, const char *mode, FILE *stream); pollution: offset pollution: whence int fseek(FILE *stream, long offset, int whence); pollution: off pollution: whence int fseeko(FILE *stream, off_t off, int whence); pollution: pos int fsetpos(FILE *stream, const fpos_t *pos); pollution: file int ftrylockfile(FILE *file); pollution: file void funlockfile(FILE *file); pollution: ptr pollution: size pollution: nitems size_t fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream); pollution: s pollution: gets char *gets(char *s); pollution: getw int getw(FILE *stream); pollution: s void perror(const char *s); pollution: command pollution: mode FILE *popen(const char *command, const char *mode); pollution: c int putc(int c, FILE *stream); pollution: c int putchar(int c); pollution: c int putc_unlocked(int c, FILE *stream); pollution: c int putchar_unlocked(int c); pollution: s int puts(const char *s); pollution: w pollution: putw int putw(int w, FILE *stream); pollution: path int remove(const char *path); pollution: oldpath pollution: newpath int rename(const char *oldpath, const char *newpath); pollution: buf void setbuf(FILE *stream, char *buf); pollution: setlinebuf void setlinebuf(FILE *stream); pollution: buf pollution: mode pollution: size int setvbuf(FILE *stream, char *buf, int mode, size_t size); pollution: dir pollution: pfx pollution: tempnam char *tempnam(const char *dir, const char *pfx); pollution: s char *tmpnam(char *s); pollution: c int ungetc(int c, FILE *stream); pollution: file pollution: format pollution: ap int vfprintf(FILE *file, const char *format, va_list ap); pollution: file pollution: format int fprintf(FILE *file, const char *format, ...); pollution: fd pollution: format pollution: ap int vdprintf(int fd, const char *format, va_list ap); pollution: fd pollution: format int dprintf(int fd, const char *format, ...); pollution: format pollution: ap int vprintf(const char *format, va_list ap); pollution: format int printf(const char *format, ...); pollution: format pollution: ap int vasprintf(char **strp, const char *format, va_list ap); pollution: format int asprintf(char **strp, const char *format, ...); pollution: s pollution: n pollution: format pollution: ap int vsnprintf(char *s, size_t n, const char *format, va_list ap); pollution: s pollution: n pollution: format int snprintf(char *s, size_t n, const char *format, ...); pollution: s pollution: format pollution: ap int vsprintf(char *s, const char *format, va_list ap); pollution: s pollution: format int sprintf(char *s, const char *format, ...); pollution: file pollution: format pollution: ap int vfscanf(FILE *file, const char *format, va_list ap); pollution: file pollution: format int fscanf(FILE *file, const char *format, ...); pollution: format pollution: ap int vscanf(const char *format, va_list ap); pollution: format int scanf(const char *format, ...); pollution: s pollution: format pollution: ap int vsscanf(const char *s, const char *format, va_list ap); pollution: s pollution: format int sscanf(const char *s, const char *format, ...); pollution: lineptr pollution: n ssize_t getline(char **lineptr, size_t *n, FILE *stream); pollution: lineptr pollution: n pollution: delim ssize_t getdelim(char **lineptr, size_t *n, int delim, FILE *stream); wrong type: struct: expected typedef: FILE typedef struct FILE FILE; pollution: c pollution: btowc wint_t btowc(int c); pollution: fgetwc wint_t fgetwc(FILE *stream); pollution: ws pollution: n pollution: fgetws wchar_t *fgetws(wchar_t *ws, int n, FILE *stream); pollution: wc pollution: fputwc wint_t fputwc(wchar_t wc, FILE *stream); pollution: ws pollution: fputws int fputws(const wchar_t *ws, FILE *stream); pollution: mode pollution: fwide int fwide(FILE *stream, int mode); pollution: getwc wint_t getwc(FILE *stream); pollution: getwchar wint_t getwchar(void); pollution: ps pollution: mbsinit int mbsinit(const mbstate_t *ps); pollution: s pollution: n pollution: ps pollution: mbrlen size_t mbrlen(const char *s, size_t n, mbstate_t *ps); pollution: pwc pollution: s pollution: n pollution: ps pollution: mbrtowc size_t mbrtowc(wchar_t *pwc, const char *s, size_t n, mbstate_t *ps); pollution: dst_ptr pollution: src_ptr pollution: src_len pollution: dst_len pollution: ps pollution: mbsnrtowcs size_t mbsnrtowcs(wchar_t *dst_ptr, const char **src_ptr, size_t src_len, size_t dst_len, mbstate_t *ps); pollution: dst pollution: src pollution: len pollution: ps pollution: mbsrtowcs size_t mbsrtowcs(wchar_t *dst, const char **src, size_t len, mbstate_t *ps); pollution: wc pollution: putwc wint_t putwc(wchar_t wc, FILE *stream); pollution: wc pollution: putwchar wint_t putwchar(wchar_t wc); pollution: s pollution: format pollution: vswscanf int vswscanf(const wchar_t *s, const wchar_t *format, va_list __valist); pollution: s pollution: format pollution: swscanf int swscanf(const wchar_t *s, const wchar_t *format, ...); pollution: wc pollution: ungetwc wint_t ungetwc(wint_t wc, FILE *stream); pollution: format pollution: arg pollution: vfwprintf int vfwprintf(FILE *stream, const wchar_t *format, va_list arg); pollution: format pollution: fwprintf int fwprintf(FILE *stream, const wchar_t *format, ...); pollution: format pollution: arg pollution: vwprintf int vwprintf(const wchar_t *format, va_list arg); pollution: format pollution: wprintf int wprintf(const wchar_t *format, ...); pollution: s pollution: n pollution: format pollution: arg pollution: vswprintf int vswprintf(wchar_t *s, size_t n, const wchar_t *format, va_list arg); pollution: s pollution: n pollution: format pollution: swprintf int swprintf(wchar_t *s, size_t n, const wchar_t *format, ...); pollution: d pollution: s pollution: wcpcpy wchar_t *wcpcpy(wchar_t *d, const wchar_t *s); pollution: d pollution: s pollution: n pollution: wcpncpy wchar_t *wcpncpy(wchar_t *d, const wchar_t *s, size_t n); pollution: s pollution: wc pollution: ps pollution: wcrtomb size_t wcrtomb(char *s, wchar_t wc, mbstate_t *ps); pollution: s pollution: wcsdup wchar_t *wcsdup(const wchar_t *s); pollution: s pollution: ws pollution: n pollution: st pollution: wcsrtombs size_t wcsrtombs(char *s, const wchar_t **ws, size_t n, mbstate_t *st); pollution: ws1 pollution: ws2 pollution: wcscat wchar_t *wcscat(wchar_t *ws1, const wchar_t *ws2); pollution: ws pollution: wc pollution: wcschr wchar_t *wcschr(const wchar_t *ws, wchar_t wc); pollution: ws1 pollution: ws2 pollution: wcscmp int wcscmp(const wchar_t *ws1, const wchar_t *ws2); pollution: ws1 pollution: ws2 pollution: wcscoll int wcscoll(const wchar_t *ws1, const wchar_t *ws2); pollution: ws1 pollution: ws2 pollution: wcscpy wchar_t *wcscpy(wchar_t *ws1, const wchar_t *ws2); pollution: wcs pollution: set pollution: wcscspn size_t wcscspn(const wchar_t *wcs, const wchar_t *set); pollution: ws pollution: wcslen size_t wcslen(const wchar_t *ws); pollution: ws1 pollution: ws2 pollution: n pollution: wcsncat wchar_t *wcsncat(wchar_t *ws1, const wchar_t *ws2, size_t n); pollution: ws1 pollution: ws2 pollution: n pollution: wcsncmp int wcsncmp(const wchar_t *ws1, const wchar_t *ws2, size_t n); pollution: ws1 pollution: ws2 pollution: n pollution: wcsncpy wchar_t *wcsncpy(wchar_t *ws1, const wchar_t *ws2, size_t n); pollution: s pollution: maxlen pollution: wcsnlen size_t wcsnlen(const wchar_t *s, size_t maxlen); pollution: dest pollution: src pollution: nwc pollution: len pollution: ps pollution: wcsnrtombs size_t wcsnrtombs(char *dest, const wchar_t **src, size_t nwc, size_t len, mbstate_t *ps); pollution: wcs pollution: set pollution: wcspbrk wchar_t *wcspbrk(const wchar_t *wcs, const wchar_t *set); pollution: ws1 pollution: wc pollution: wcsrchr wchar_t *wcsrchr(const wchar_t *ws1, wchar_t wc); pollution: wcs pollution: set pollution: wcsspn size_t wcsspn(const wchar_t *wcs, const wchar_t *set); pollution: ws1 pollution: ws2 pollution: wcsstr wchar_t *wcsstr(const wchar_t *ws1, const wchar_t *ws2); pollution: ptr pollution: end pollution: wcstod double wcstod(const wchar_t *ptr, wchar_t **end); pollution: wcs pollution: delim pollution: state pollution: wcstok wchar_t *wcstok(wchar_t *wcs, const wchar_t *delim, wchar_t **state); pollution: ptr pollution: end pollution: base pollution: wcstol long wcstol(const wchar_t *ptr, wchar_t **end, int base); pollution: ptr pollution: end pollution: base pollution: wcstoll long long wcstoll(const wchar_t *ptr, wchar_t **end, int base); pollution: ptr pollution: end pollution: base pollution: wcstoimax intmax_t wcstoimax(const wchar_t *ptr, wchar_t **end, int base); pollution: ptr pollution: end pollution: base pollution: wcstoul unsigned long wcstoul(const wchar_t *ptr, wchar_t **end, int base); pollution: ptr pollution: end pollution: base pollution: wcstoull unsigned long long wcstoull(const wchar_t *ptr, wchar_t **end, int base); pollution: ptr pollution: end pollution: base pollution: wcstoumax uintmax_t wcstoumax(const wchar_t *ptr, wchar_t **end, int base); pollution: ws1 pollution: ws2 pollution: wcswcs wchar_t *wcswcs(const wchar_t *ws1, const wchar_t *ws2); pollution: pwcs pollution: n pollution: wcswidth int wcswidth(const wchar_t *pwcs, size_t n); pollution: c pollution: wctob int wctob(wint_t c); pollution: wc pollution: wcwidth int wcwidth(wchar_t wc); pollution: ws pollution: wc pollution: n pollution: wmemchr wchar_t *wmemchr(const wchar_t *ws, wchar_t wc, size_t n); pollution: ws1 pollution: ws2 pollution: n pollution: wmemcmp int wmemcmp(const wchar_t *ws1, const wchar_t *ws2, size_t n); pollution: ws1 pollution: ws2 pollution: n pollution: wmemcpy wchar_t *wmemcpy(wchar_t *ws1, const wchar_t *ws2, size_t n); pollution: ws1 pollution: ws2 pollution: n pollution: wmemmove wchar_t *wmemmove(wchar_t *ws1, const wchar_t *ws2, size_t n); pollution: ws pollution: wc pollution: n pollution: wmemset wchar_t *wmemset(wchar_t *ws, wchar_t wc, size_t n); pollution: format pollution: vwscanf int vwscanf(const wchar_t *format, va_list __valist); pollution: format pollution: wscanf int wscanf(const wchar_t *format, ...); pollution: s1 pollution: s2 pollution: wcscasecmp int wcscasecmp(const wchar_t *s1, const wchar_t *s2); pollution: s1 pollution: s2 pollution: n pollution: wcsncasecmp int wcsncasecmp(const wchar_t *s1, const wchar_t *s2, size_t n); pollution: status void _Exit(int status) __attribute__((__noreturn__)); pollution: s pollution: a64l long a64l(const char *s); pollution: i int abs(int i); pollution: alignment pollution: size void *aligned_alloc(size_t alignment, size_t size); pollution: func int at_quick_exit(void (*func)(void)); pollution: func int atexit(void (*func)(void)); pollution: s double atof(const char *s); pollution: s int atoi(const char *s); pollution: s long atol(const char *s); pollution: s long long atoll(const char *s); pollution: key pollution: base pollution: nel pollution: width pollution: compar void *bsearch(const void *key, const void *base, size_t nel, size_t width, int (*compar)(const void*, const void*)); pollution: nelem pollution: elsize void *calloc(size_t nelem, size_t elsize); pollution: numer pollution: denom div_t div(int numer, int denom); pollution: drand48 double drand48(void); pollution: xsubi pollution: erand48 double erand48(unsigned short *xsubi); pollution: status void exit(int status) __attribute__((__noreturn__)); pollution: ptr void free(void *ptr); pollution: name char *getenv(const char *name); pollution: optionp pollution: tokens pollution: valuep int getsubopt(char **optionp, char *const *tokens, char **valuep); pollution: fildes pollution: grantpt int grantpt(int fildes); pollution: seed pollution: state pollution: size pollution: initstate char *initstate(unsigned int seed, char *state, size_t size); pollution: xsubi pollution: jrand48 long jrand48(unsigned short *xsubi); pollution: value pollution: l64a char *l64a(long value); pollution: i long labs(long i); pollution: param pollution: lcong48 void lcong48(unsigned short *param); pollution: numer pollution: denom ldiv_t ldiv(long numer, long denom); pollution: i long long llabs(long long i); pollution: numer pollution: denom lldiv_t lldiv(long long numer, long long denom); pollution: lrand48 long lrand48(void); pollution: size void *malloc(size_t size); pollution: alignment pollution: size pollution: memalign [[deprecated]] void *memalign(size_t alignment, size_t size); pollution: s pollution: n int mblen(const char *s, size_t n); pollution: pwcs pollution: s pollution: n size_t mbstowcs(wchar_t *pwcs, const char *s, size_t n); pollution: pwc pollution: s pollution: n int mbtowc(wchar_t *pwc, const char *s, size_t n); pollution: name char *mkdtemp(char *name); pollution: name pollution: flags int mkostemp(char *name, int flags); pollution: name pollution: suffix_len pollution: flags pollution: mkostemps int mkostemps(char *name, int suffix_len, int flags); pollution: name int mkstemp(char *name); pollution: name pollution: suffix_len pollution: mkstemps int mkstemps(char *name, int suffix_len); pollution: name pollution: mktemp [[deprecated]] char *mktemp(char *name); pollution: mrand48 long mrand48(void); pollution: xsubi pollution: nrand48 long nrand48(unsigned short *xsubi); pollution: memptr pollution: alignment pollution: size int posix_memalign(void **memptr, size_t alignment, size_t size); pollution: flags pollution: posix_openpt int posix_openpt(int flags); pollution: fd pollution: ptsname char *ptsname(int fd); pollution: fd pollution: buf pollution: buflen pollution: ptsname_r int ptsname_r(int fd, char *buf, size_t buflen); pollution: insert pollution: putenv int putenv(char *insert); pollution: base pollution: nel pollution: width pollution: compar void qsort(void *base, size_t nel, size_t width, int (*compar)(const void*, const void*)); pollution: status void quick_exit(int status) __attribute__((__noreturn__)); pollution: seed pollution: rand_r int rand_r(unsigned int *seed); pollution: random long random(void); pollution: ptr pollution: size void *realloc(void *ptr, size_t size); pollution: ptr pollution: m pollution: n void *reallocarray(void *ptr, size_t m, size_t n); pollution: pathname pollution: resolved char *realpath(const char *pathname, char *resolved); pollution: seed16v pollution: seed48 unsigned short *seed48(unsigned short *seed16v); pollution: key pollution: value pollution: overwrite int setenv(const char *key, const char *value, int overwrite); pollution: state pollution: setstate char *setstate(char *state); pollution: seed void srand(unsigned int seed); pollution: seedval pollution: srand48 void srand48(long seedval); pollution: seed pollution: srandom void srandom(unsigned int seed); pollution: s pollution: endptr double strtod(const char *s, char **endptr); pollution: s pollution: endptr float strtof(const char *s, char **endptr); pollution: s pollution: endptr pollution: base long strtol(const char *s, char **endptr, int base); pollution: s pollution: endptr pollution: base long long strtoll(const char *s, char **endptr, int base); pollution: s pollution: endptr pollution: base unsigned long strtoul(const char *s, char **endptr, int base); pollution: s pollution: endptr pollution: base unsigned long long strtoull(const char *s, char **endptr, int base); pollution: command int system(const char *command); pollution: fildes pollution: unlockpt int unlockpt(int fildes); pollution: key int unsetenv(const char *key); pollution: size pollution: valloc [[deprecated]] void *valloc(size_t size); pollution: s pollution: pwcs pollution: n size_t wcstombs(char *s, const wchar_t *pwcs, size_t n); pollution: s pollution: wc int wctomb(char *s, wchar_t wc); pollution: nptr pollution: endptr long double strtold(const char *nptr, char **endptr); pollution: va_start #define va_start(v,l) __builtin_va_start(v,l) pollution: ITIMER_VIRTUAL #define ITIMER_VIRTUAL 1 pollution: NSIG #define NSIG 32 pollution: PTHREAD_COND_INITIALIZER #define PTHREAD_COND_INITIALIZER ((pthread_cond_t){0}) pollution: SS_DISABLE #define SS_DISABLE 2 pollution: FD_SET #define FD_SET(d,s) ((s)->fds_bits[(d)/(8*sizeof(long))] |= (1UL<<((d)%(8*sizeof(long))))) pollution: pthread_cleanup_pop #define pthread_cleanup_pop(EXECUTE) __relibc_internal_pthread_cleanup_pop((EXECUTE)); } while(0) pollution: ITIMER_PROF #define ITIMER_PROF 2 pollution: timerisset #define timerisset(t) ((t)->tv_sec || (t)->tv_usec) pollution: pthread_cleanup_push #define pthread_cleanup_push(ROUTINE,ARG) do { struct { void (*routine)(void *); void *arg; void *prev; } __relibc_internal_pthread_ll_entry = { .routine = (void (*)(void *))(ROUTINE), .arg = (void *)(ARG), }; __relibc_internal_pthread_cleanup_push(&__relibc_internal_pthread_ll_entry); pollution: PTHREAD_RWLOCK_INITIALIZER #define PTHREAD_RWLOCK_INITIALIZER ((pthread_rwlock_t){0}) pollution: ITIMER_REAL #define ITIMER_REAL 0 pollution: alloca #define alloca(size) __builtin_alloca (size) pollution: FD_SETSIZE #define FD_SETSIZE 1024 pollution: timerclear #define timerclear(t) (void) ( (t)->tv_sec = 0, (t)->tv_usec = 0 ) pollution: FD_ZERO #define FD_ZERO(s) do { int __i; unsigned long *__b=(s)->fds_bits; for(__i=sizeof (fd_set)/sizeof (long); __i; __i--) *__b++=0; } while(0) pollution: TRAP_TRACE #define TRAP_TRACE 2 pollution: TRAP_BRKPT #define TRAP_BRKPT 1 pollution: timercmp #define timercmp(x,y,op) ((x)->tv_sec == (y)->tv_sec ? (x)->tv_usec op (y)->tv_usec : (x)->tv_sec op (y)->tv_sec) pollution: SS_ONSTACK #define SS_ONSTACK 1 pollution: MINSIGSTKSZ #define MINSIGSTKSZ 2048 pollution: va_copy #define va_copy(d,s) __builtin_va_copy(d,s) pollution: va_arg #define va_arg(v,l) __builtin_va_arg(v,l) pollution: PTHREAD_ONCE_INIT #define PTHREAD_ONCE_INIT ((pthread_once_t){0}) pollution: CLOCKS_PER_SEC #define CLOCKS_PER_SEC 1000000 pollution: va_end #define va_end(v) __builtin_va_end(v) pollution: timeradd #define timeradd(x,y,res) (void) ( (res)->tv_sec = (x)->tv_sec + (y)->tv_sec + (((x)->tv_usec + (y)->tv_usec) / 1000000), (res)->tv_usec = ((x)->tv_usec + (y)->tv_usec) % 1000000 ) pollution: FD_CLR #define FD_CLR(d,s) ((s)->fds_bits[(d)/(8*sizeof(long))] &= ~(1UL<<((d)%(8*sizeof(long))))) pollution: timersub #define timersub(x,y,res) (void) ( (res)->tv_sec = (x)->tv_sec - (y)->tv_sec, (res)->tv_usec = ((x)->tv_usec - (y)->tv_usec), ((res)->tv_usec < 0) && ((res)->tv_sec -= 1, (res)->tv_usec += 1000000) )