pollution: lgamma_r extern double lgamma_r (double, int *); pollution: signgam extern int signgam; wrong type: function: expected define: isnan extern int isnan (double); pollution: gamma extern double gamma (double); pollution: gamma_r extern double gamma_r (double, int *); pollution: j0 extern double j0 (double); pollution: j1 extern double j1 (double); pollution: jn extern double jn (int, double); pollution: y0 extern double y0 (double); pollution: y1 extern double y1 (double); pollution: yn extern double yn (int, double); pollution: scalb extern double scalb (double, double); pollution: quot int quot; pollution: rem int rem; pollution: quot long int quot; pollution: rem long int rem; pollution: strtod extern double strtod (const char * restrict, char ** restrict); pollution: strtol extern long int strtol (const char * restrict, char ** restrict,int); pollution: strtoul extern unsigned long int strtoul (const char * restrict, char ** restrict, int); pollution: strtof extern float strtof (const char * restrict, char ** restrict); pollution: quot long long int quot; pollution: rem long long int rem ; pollution: atoll extern long long int atoll (const char *); pollution: llabs extern long long int llabs ( long long int ); pollution: lldiv extern lldiv_t lldiv ( long long int, long long int ); pollution: strtoll extern long long int strtoll ( const char * restrict, char ** restrict, int ); pollution: strtoull extern unsigned long long int strtoull ( const char * restrict, char ** restrict, int ); pollution: strtold static long double strtold (const char * restrict __a, char ** restrict __b) { return ((long double)strtod (__a, __b)); } pollution: mblen extern int mblen (const char *, size_t); pollution: mbstowcs extern size_t mbstowcs (wchar_t * restrict, const char * restrict, size_t); pollution: mbtowc extern int mbtowc (wchar_t * restrict, const char * restrict, size_t); pollution: wcstombs extern size_t wcstombs (char * restrict, const wchar_t * restrict, size_t); pollution: wctomb extern int wctomb (char *, const wchar_t); pollution: abort extern _Noreturn void abort (void); pollution: atexit extern int atexit(void (*)(void)); pollution: atof extern double atof (const char *); pollution: atoi extern int atoi (const char *); pollution: atol extern long int atol (const char *); pollution: rand extern int rand (void); pollution: srand extern void srand (unsigned int); pollution: calloc extern void *calloc (size_t, size_t); pollution: free extern void free (void *); pollution: malloc extern void *malloc (size_t); pollution: realloc extern void *realloc (void *, size_t); pollution: exit extern _Noreturn void exit (int); pollution: getenv extern char *getenv (const char *); pollution: system extern int system(const char *); pollution: bsearch extern void *bsearch(const void *, const void *, size_t, size_t, int(*)(const void *,const void *)); pollution: qsort extern void qsort(void *, size_t, size_t, int(*)(const void *,const void *)); pollution: f pollution: at_quick_exit extern int at_quick_exit (void (*f)(void)); pollution: quick_exit extern _Noreturn void quick_exit (int); pollution: aligned_alloc extern void *aligned_alloc (size_t, size_t); pollution: abs extern int abs (int); pollution: div extern struct div_t div (int, int); pollution: labs extern long int labs (long int); pollution: ldiv extern struct ldiv_t ldiv (long int, long int); pollution: posix_memalign extern int posix_memalign (void **,size_t,size_t); pollution: quot intmax_t quot; pollution: rem intmax_t rem; pollution: strtoimax static intmax_t strtoimax (const char * restrict __nptr, char ** restrict __endptr, int __base) { return __strtollmax (__nptr, __endptr, __base); } pollution: imaxabs extern intmax_t imaxabs (intmax_t); pollution: imaxdiv extern imaxdiv_t imaxdiv (intmax_t, intmax_t); pollution: strtoumax extern uintmax_t strtoumax (const char * restrict, char ** restrict, int); pollution: wcstoimax extern intmax_t wcstoimax (const wchar_t * restrict, wchar_t ** restrict, int ); pollution: wcstoumax extern uintmax_t wcstoumax (const wchar_t * restrict, wchar_t ** restrict, int); pollution: int8 typedef signed char int8; pollution: int16 typedef signed short int16; pollution: int32 typedef signed int int32; pollution: int64 typedef signed long long int64; pollution: u_int8 typedef unsigned char u_int8; pollution: u_int16 typedef unsigned short u_int16; pollution: u_int32 typedef unsigned int u_int32; pollution: u_int64 typedef unsigned long long u_int64; pollution: losigs unsigned int losigs; pollution: hisigs unsigned int hisigs; pollution: losigs pollution: hisigs unsigned int losigs, hisigs; pollution: ss_set uint64_t ss_set[4]; pollution: val unsigned int val[2]; pollution: val uint64_t val[2]; pollution: val int val[2]; pollution: quad typedef struct _quad { int val[2]; } quad; pollution: srval vmhandle_t srval; pollution: offset caddr_t offset; pollution: alloc ulong32int64_t alloc; pollution: srval vmhandle_t srval[16]; pollution: alloc uint_t alloc; pollution: srval uint_t srval[16]; pollution: BadAttr pollution: VirtAddr pollution: MR_ATTR_TYPE typedef enum _MR_ATTR_TYPE { BadAttr = 0, VirtAddr = 1 } MR_ATTR_TYPE; pollution: BadMem pollution: FreeMem pollution: IPLCB pollution: RMALLOC pollution: PM_HEAP pollution: RTAS_HEAP pollution: TCE_TABLE pollution: IO_SPACE pollution: HUGE_PAGE pollution: MR_LABEL_TYPE typedef enum _MR_LABEL_TYPE { BadMem = 0, FreeMem = 1, IPLCB = 2, RMALLOC = 3, PM_HEAP = 4, RTAS_HEAP = 5, TCE_TABLE = 6, IO_SPACE = 7, HUGE_PAGE = 8 } MR_LABEL_TYPE; pollution: mr_addr unsigned long long mr_addr; pollution: mr_size unsigned long long mr_size; pollution: mr_att unsigned char mr_att; pollution: mr_label unsigned char mr_label; pollution: mr_nodeid unsigned short mr_nodeid; pollution: mr_flags unsigned short mr_flags; pollution: reserved char reserved[2]; pollution: va_list typedef char * va_list; pollution: UniChar typedef ushort_t UniChar; pollution: UTF32Char typedef uint_t UTF32Char; pollution: uchar typedef uchar_t uchar; pollution: ushort typedef ushort_t ushort; pollution: uint typedef uint_t uint; pollution: ulong typedef ulong_t ulong; pollution: r int r[1]; pollution: physadr typedef physadr_t physadr; pollution: u_char typedef unsigned char u_char; pollution: u_short typedef unsigned short u_short; pollution: u_int typedef unsigned int u_int; pollution: u_long typedef unsigned long u_long; pollution: losigs unsigned int losigs; pollution: hisigs unsigned int hisigs; pollution: sigset struct sigset { unsigned int losigs; unsigned int hisigs; }; pollution: val unsigned int val[2]; pollution: fsid struct fsid { unsigned int val[2]; }; pollution: fid_len uint_t fid_len; pollution: fid_ino ino32_t fid_ino; pollution: fid_gen uint_t fid_gen; pollution: fid_x char fid_x[20 - (sizeof(ino32_t) + 2) - sizeof(uint_t)]; pollution: fileid struct fileid { uint_t fid_len; ino32_t fid_ino; uint_t fid_gen; char fid_x[20 - (sizeof(ino32_t) + 2) - sizeof(uint_t)]; }; pollution: fid_len uint_t fid_len; pollution: fid_data char fid_data[20]; pollution: fid struct fid { uint_t fid_len; char fid_data[20]; }; pollution: fid typedef struct fid fid_t; pollution: x char x[32]; pollution: fhandle struct fhandle { char x[32]; }; pollution: fhandle typedef struct fhandle fhandle_t; pollution: fh_fsid fsid_t fh_fsid; pollution: fileid pollution: fh_fid struct fileid fh_fid; pollution: filehandle struct filehandle { fsid_t fh_fsid; struct fileid fh_fid; }; pollution: word1 __ulong32_t word1; pollution: word2 __ulong32_t word2; pollution: word3 __ulong32_t word3; pollution: word4 __ulong32_t word4; pollution: unique_id struct unique_id { __ulong32_t word1; __ulong32_t word2; __ulong32_t word3; __ulong32_t word4; }; pollution: unique_id typedef struct unique_id unique_id_t; pollution: tv_sec time_t tv_sec; pollution: tv_usec suseconds_t tv_usec; pollution: timeval struct timeval { time_t tv_sec; suseconds_t tv_usec; }; pollution: tv_sec int32_t tv_sec; pollution: tv_usec int32_t tv_usec; pollution: timeval32 struct timeval32 { int32_t tv_sec; int32_t tv_usec; }; pollution: tv_sec int64_t tv_sec; pollution: tv_usec int32_t tv_usec; pollution: timeval64 struct timeval64 { int64_t tv_sec; int32_t tv_usec; }; pollution: tz_minuteswest int tz_minuteswest; pollution: tz_dsttime int tz_dsttime; pollution: timezone struct timezone { int tz_minuteswest; int tz_dsttime; }; pollution: timeval pollution: it_interval struct timeval it_interval; pollution: timeval pollution: it_value struct timeval it_value; pollution: itimerval struct itimerval { struct timeval it_interval; struct timeval it_value; }; pollution: itimerval pollution: getitimer extern int getitimer(int, struct itimerval *); pollution: itimerval pollution: itimerval pollution: setitimer extern int setitimer(int, const struct itimerval *restrict, struct itimerval *restrict); pollution: timeval pollution: gettimeofday extern int gettimeofday(struct timeval *restrict, void *restrict); pollution: timeval pollution: timezone pollution: settimeofday extern int settimeofday(struct timeval *, struct timezone *); pollution: timeval64 pollution: utimes64 extern int utimes64(const char *, const struct timeval64 *); pollution: timeval pollution: utimes extern int utimes(const char *, const struct timeval *); pollution: fds_bits long fds_bits[(65534/(sizeof(long) * 8)+1)]; pollution: fd_set pollution: fd_set typedef struct fd_set { long fds_bits[(65534/(sizeof(long) * 8)+1)]; } fd_set; pollution: tv_sec time_t tv_sec; pollution: tv_nsec long tv_nsec; pollution: timespec struct timespec { time_t tv_sec; long tv_nsec; }; pollution: timespec pollution: pselect extern int pselect(int, void *restrict, void *restrict, void *restrict, const struct timespec *restrict, const sigset_t *restrict); pollution: timeval extern int __fd_select(int, fd_set *restrict, fd_set *restrict, fd_set *restrict, struct timeval *restrict); pollution: timeval pollution: select static int select(int __fds, fd_set *restrict __readlist, fd_set *restrict __writelist, fd_set *restrict __exceptlist, struct timeval *restrict __timeout) { return __fd_select(__fds, __readlist, __writelist, __exceptlist, __timeout); } pollution: tv_sec time_t tv_sec; pollution: tv_nsec suseconds_t tv_nsec; pollution: tv_sec int32_t tv_sec; pollution: tv_nsec int32_t tv_nsec; pollution: tv_sec int64_t tv_sec; pollution: tv_nsec int32_t tv_nsec; pollution: it_interval struct timestruc_t it_interval; pollution: it_value struct timestruc_t it_value; pollution: it_interval struct timestruc32_t it_interval; pollution: it_value struct timestruc32_t it_value; pollution: it_interval struct timestruc64_t it_interval; pollution: it_value struct timestruc64_t it_value; pollution: flag int flag; pollution: tb_high unsigned int tb_high; pollution: tb_low unsigned int tb_low; pollution: timebasestruct typedef struct timebasestruct { int flag; unsigned int tb_high; unsigned int tb_low; } timebasestruct_t; pollution: read_real_time int read_real_time(timebasestruct_t *, size_t); pollution: mread_real_time int mread_real_time(timebasestruct_t *, size_t); pollution: read_wall_time int read_wall_time(timebasestruct_t *, size_t); pollution: time_base_to_time int time_base_to_time(timebasestruct_t *, size_t); pollution: rlim_cur rlim_t rlim_cur; pollution: rlim_max rlim_t rlim_max; pollution: rlimit struct rlimit { rlim_t rlim_cur; rlim_t rlim_max; }; pollution: rlim_cur rlim32_t rlim_cur; pollution: rlim_max rlim32_t rlim_max; pollution: rlimit32 struct rlimit32 { rlim32_t rlim_cur; rlim32_t rlim_max; }; pollution: rlim_cur rlim64_t rlim_cur; pollution: rlim_max rlim64_t rlim_max; pollution: rlimit64 struct rlimit64 { rlim64_t rlim_cur; rlim64_t rlim_max; }; pollution: timeval pollution: ru_utime struct timeval ru_utime; pollution: timeval pollution: ru_stime struct timeval ru_stime; pollution: ru_maxrss long ru_maxrss; pollution: ru_ixrss long ru_ixrss; pollution: ru_idrss long ru_idrss; pollution: ru_isrss long ru_isrss; pollution: ru_minflt long ru_minflt; pollution: ru_majflt long ru_majflt; pollution: ru_nswap long ru_nswap; pollution: ru_inblock long ru_inblock; pollution: ru_oublock long ru_oublock; pollution: ru_msgsnd long ru_msgsnd; pollution: ru_msgrcv long ru_msgrcv; pollution: ru_nsignals long ru_nsignals; pollution: ru_nvcsw long ru_nvcsw; pollution: ru_nivcsw long ru_nivcsw; pollution: rusage struct rusage { struct timeval ru_utime; struct timeval ru_stime; long ru_maxrss; long ru_ixrss; long ru_idrss; long ru_isrss; long ru_minflt; long ru_majflt; long ru_nswap; long ru_inblock; long ru_oublock; long ru_msgsnd; long ru_msgrcv; long ru_nsignals; long ru_nvcsw; long ru_nivcsw; }; pollution: timeval32 pollution: ru_utime struct timeval32 ru_utime; pollution: timeval32 pollution: ru_stime struct timeval32 ru_stime; pollution: ru_maxrss signed int ru_maxrss; pollution: ru_ixrss signed int ru_ixrss; pollution: ru_idrss signed int ru_idrss; pollution: ru_isrss signed int ru_isrss; pollution: ru_minflt signed int ru_minflt; pollution: ru_majflt signed int ru_majflt; pollution: ru_nswap signed int ru_nswap; pollution: ru_inblock signed int ru_inblock; pollution: ru_oublock signed int ru_oublock; pollution: ru_msgsnd signed int ru_msgsnd; pollution: ru_msgrcv signed int ru_msgrcv; pollution: ru_nsignals signed int ru_nsignals; pollution: ru_nvcsw signed int ru_nvcsw; pollution: ru_nivcsw signed int ru_nivcsw; pollution: rusage32 struct rusage32 { struct timeval32 ru_utime; struct timeval32 ru_stime; signed int ru_maxrss; signed int ru_ixrss; signed int ru_idrss; signed int ru_isrss; signed int ru_minflt; signed int ru_majflt; signed int ru_nswap; signed int ru_inblock; signed int ru_oublock; signed int ru_msgsnd; signed int ru_msgrcv; signed int ru_nsignals; signed int ru_nvcsw; signed int ru_nivcsw; }; pollution: timeval pollution: ru_utime struct timeval ru_utime; pollution: timeval pollution: ru_stime struct timeval ru_stime; pollution: ru_maxrss long long ru_maxrss; pollution: ru_ixrss long long ru_ixrss; pollution: ru_idrss long long ru_idrss; pollution: ru_isrss long long ru_isrss; pollution: ru_minflt long long ru_minflt; pollution: ru_majflt long long ru_majflt; pollution: ru_nswap long long ru_nswap; pollution: ru_inblock long long ru_inblock; pollution: ru_oublock long long ru_oublock; pollution: ru_msgsnd long long ru_msgsnd; pollution: ru_msgrcv long long ru_msgrcv; pollution: ru_nsignals long long ru_nsignals; pollution: ru_nvcsw long long ru_nvcsw; pollution: ru_nivcsw long long ru_nivcsw; pollution: rusage64 struct rusage64 { struct timeval ru_utime; struct timeval ru_stime; long long ru_maxrss; long long ru_ixrss; long long ru_idrss; long long ru_isrss; long long ru_minflt; long long ru_majflt; long long ru_nswap; long long ru_inblock; long long ru_oublock; long long ru_msgsnd; long long ru_msgrcv; long long ru_nsignals; long long ru_nvcsw; long long ru_nivcsw; }; pollution: timeval64 pollution: ru_utime struct timeval64 ru_utime; pollution: timeval64 pollution: ru_stime struct timeval64 ru_stime; pollution: ru_maxrss longlong_t ru_maxrss; pollution: ru_ixrss longlong_t ru_ixrss; pollution: ru_idrss longlong_t ru_idrss; pollution: ru_isrss longlong_t ru_isrss; pollution: ru_minflt longlong_t ru_minflt; pollution: ru_majflt longlong_t ru_majflt; pollution: ru_nswap longlong_t ru_nswap; pollution: ru_inblock longlong_t ru_inblock; pollution: ru_oublock longlong_t ru_oublock; pollution: ru_msgsnd longlong_t ru_msgsnd; pollution: ru_msgrcv longlong_t ru_msgrcv; pollution: ru_nsignals longlong_t ru_nsignals; pollution: ru_nvcsw longlong_t ru_nvcsw; pollution: ru_nivcsw longlong_t ru_nivcsw; pollution: trusage64 struct trusage64 { struct timeval64 ru_utime; struct timeval64 ru_stime; longlong_t ru_maxrss; longlong_t ru_ixrss; longlong_t ru_idrss; longlong_t ru_isrss; longlong_t ru_minflt; longlong_t ru_majflt; longlong_t ru_nswap; longlong_t ru_inblock; longlong_t ru_oublock; longlong_t ru_msgsnd; longlong_t ru_msgrcv; longlong_t ru_nsignals; longlong_t ru_nvcsw; longlong_t ru_nivcsw; }; pollution: timeval32 pollution: ru_utime struct timeval32 ru_utime; pollution: timeval32 pollution: ru_stime struct timeval32 ru_stime; pollution: ru_maxrss signed int ru_maxrss; pollution: ru_ixrss signed int ru_ixrss; pollution: ru_idrss signed int ru_idrss; pollution: ru_isrss signed int ru_isrss; pollution: ru_minflt signed int ru_minflt; pollution: ru_majflt signed int ru_majflt; pollution: ru_nswap signed int ru_nswap; pollution: ru_inblock signed int ru_inblock; pollution: ru_oublock signed int ru_oublock; pollution: ru_msgsnd signed int ru_msgsnd; pollution: ru_msgrcv signed int ru_msgrcv; pollution: ru_nsignals signed int ru_nsignals; pollution: ru_nvcsw signed int ru_nvcsw; pollution: ru_nivcsw signed int ru_nivcsw; pollution: trusage32 struct trusage32 { struct timeval32 ru_utime; struct timeval32 ru_stime; signed int ru_maxrss; signed int ru_ixrss; signed int ru_idrss; signed int ru_isrss; signed int ru_minflt; signed int ru_majflt; signed int ru_nswap; signed int ru_inblock; signed int ru_oublock; signed int ru_msgsnd; signed int ru_msgrcv; signed int ru_nsignals; signed int ru_nvcsw; signed int ru_nivcsw; }; pollution: getpriority extern int getpriority(int, id_t); pollution: setpriority extern int setpriority(int, id_t, int); pollution: rlimit pollution: getrlimit extern int getrlimit(int, struct rlimit *); pollution: rlimit pollution: setrlimit extern int setrlimit(int, const struct rlimit *); pollution: rlimit64 pollution: getrlimit64 extern int getrlimit64(int, struct rlimit64 *); pollution: rlimit64 pollution: setrlimit64 extern int setrlimit64(int, const struct rlimit64 *); pollution: rusage pollution: getrusage extern int getrusage(int, struct rusage *); pollution: rusage64 pollution: getrusage64 extern int getrusage64(int, struct rusage64 *); pollution: signal extern void (*signal (int, void (*)(int)))(int); pollution: raise extern int raise(int); pollution: sival_ptr void * sival_ptr; pollution: sival_int int sival_int; pollution: sigval union sigval { void * sival_ptr; int sival_int; }; pollution: si_signo int si_signo; pollution: si_errno int si_errno; pollution: si_code int si_code; pollution: si_pid pid_t si_pid; pollution: si_uid uid_t si_uid; pollution: si_addr void *si_addr; pollution: si_status int si_status; pollution: si_band long si_band; pollution: sigval pollution: si_value union sigval si_value; pollution: sa_union union { void (*__su_handler)(int); void (*__su_sigaction) (int, siginfo_t *, void *); } sa_union; pollution: sa_mask sigset_t sa_mask; pollution: sa_flags int sa_flags; pollution: sigaction struct sigaction { union { void (*__su_handler)(int); void (*__su_sigaction) (int, siginfo_t *, void *); } sa_union; sigset_t sa_mask; int sa_flags; }; pollution: mstsave pollution: prev struct mstsave *prev; pollution: kjmpbuf label_t *kjmpbuf; pollution: stackfix char *stackfix; pollution: intpri char intpri; pollution: backt char backt; pollution: rsvd char rsvd[2]; pollution: curid pid_t curid; pollution: excp_type int excp_type; pollution: iar ulong_t iar; pollution: msr ulong_t msr; pollution: cr ulong_t cr; pollution: lr ulong_t lr; pollution: ctr ulong_t ctr; pollution: xer ulong_t xer; pollution: mq ulong_t mq; pollution: tid ulong_t tid; pollution: fpscr ulong_t fpscr; pollution: fpeu char fpeu; pollution: fpinfo char fpinfo; pollution: fpscr24_31 uchar fpscr24_31; pollution: pad char pad[1]; pollution: except ulong_t except[5]; pollution: pad1 char pad1[4]; pollution: o_iar ulong_t o_iar; pollution: o_toc ulong_t o_toc; pollution: o_arg1 ulong_t o_arg1; pollution: excbranch ulong_t excbranch; pollution: fpscrx ulong_t fpscrx; pollution: o_vaddr ulong_t o_vaddr; pollution: cachealign ulong_t cachealign[7]; pollution: as adspace_t as; pollution: gpr ulong_t gpr[32]; pollution: fpr double fpr[32]; pollution: mstsave struct mstsave { struct mstsave *prev; label_t *kjmpbuf; char *stackfix; char intpri; char backt; char rsvd[2]; pid_t curid; int excp_type; ulong_t iar; ulong_t msr; ulong_t cr; ulong_t lr; ulong_t ctr; ulong_t xer; ulong_t mq; ulong_t tid; ulong_t fpscr; char fpeu; char fpinfo; uchar fpscr24_31; char pad[1]; ulong_t except[5]; char pad1[4]; ulong_t o_iar; ulong_t o_toc; ulong_t o_arg1; ulong_t excbranch; ulong_t fpscrx; ulong_t o_vaddr; ulong_t cachealign[7]; adspace_t as; ulong_t gpr[32]; double fpr[32]; }; pollution: prev __ptr32 prev; pollution: kjmpbuf __ptr32 kjmpbuf; pollution: stackfix __cptr32 stackfix; pollution: intpri char intpri; pollution: backt char backt; pollution: rsvd char rsvd[2]; pollution: curid int curid; pollution: excp_type int excp_type; pollution: iar uint_t iar; pollution: msr uint_t msr; pollution: cr uint_t cr; pollution: lr uint_t lr; pollution: ctr uint_t ctr; pollution: xer uint_t xer; pollution: mq uint_t mq; pollution: tid uint_t tid; pollution: fpscr uint_t fpscr; pollution: fpeu char fpeu; pollution: fpinfo char fpinfo; pollution: fpscr24_31 uchar_t fpscr24_31; pollution: pad char pad[1]; pollution: except uint_t except[5]; pollution: pad1 char pad1[4]; pollution: o_iar uint_t o_iar; pollution: o_toc uint_t o_toc; pollution: o_arg1 uint_t o_arg1; pollution: excbranch uint_t excbranch; pollution: fpscrx uint_t fpscrx; pollution: o_vaddr uint_t o_vaddr; pollution: cachealign uint_t cachealign[7]; pollution: as adspace32_t as; pollution: gpr uint_t gpr[32]; pollution: fpr double fpr[32]; pollution: mstsave32 struct mstsave32 { __ptr32 prev; __ptr32 kjmpbuf; __cptr32 stackfix; char intpri; char backt; char rsvd[2]; int curid; int excp_type; uint_t iar; uint_t msr; uint_t cr; uint_t lr; uint_t ctr; uint_t xer; uint_t mq; uint_t tid; uint_t fpscr; char fpeu; char fpinfo; uchar_t fpscr24_31; char pad[1]; uint_t except[5]; char pad1[4]; uint_t o_iar; uint_t o_toc; uint_t o_arg1; uint_t excbranch; uint_t fpscrx; uint_t o_vaddr; uint_t cachealign[7]; adspace32_t as; uint_t gpr[32]; double fpr[32]; }; pollution: ss_sp void *ss_sp; pollution: ss_size size_t ss_size; pollution: ss_flags int ss_flags; pollution: ss_sp unsigned long long ss_sp; pollution: ss_size unsigned long long ss_size; pollution: ss_flags int ss_flags; pollution: ss_sp __ptr32 ss_sp; pollution: ss_size uint_t ss_size; pollution: ss_flags int ss_flags; pollution: gpr unsigned long long gpr[32]; pollution: msr unsigned long long msr; pollution: iar unsigned long long iar; pollution: lr unsigned long long lr; pollution: ctr unsigned long long ctr; pollution: cr unsigned int cr; pollution: xer unsigned int xer; pollution: fpscr unsigned int fpscr; pollution: fpscrx unsigned int fpscrx; pollution: except unsigned long long except[1]; pollution: fpr double fpr[32]; pollution: fpeu char fpeu; pollution: fpinfo char fpinfo; pollution: fpscr24_31 char fpscr24_31; pollution: pad char pad[1]; pollution: excp_type int excp_type; pollution: sc_onstack int sc_onstack; pollution: sc_mask sigset64_t sc_mask; pollution: sc_uerror int sc_uerror; pollution: sc_context struct __context64 sc_context; pollution: sigcontext64 struct sigcontext64 { int sc_onstack; sigset64_t sc_mask; int sc_uerror; struct __context64 sc_context; }; pollution: vmx __vmx_context_t vmx; pollution: vsx __vsx_context_t vsx; pollution: gpr unsigned long long gpr[32]; pollution: lr unsigned long long lr; pollution: ctr unsigned long long ctr; pollution: cr unsigned int cr; pollution: xer unsigned int xer; pollution: amr unsigned long long amr; pollution: texasr unsigned long long texasr; pollution: tfiar unsigned long long tfiar; pollution: tfhar unsigned long long tfhar; pollution: ppr unsigned long long ppr; pollution: dscr unsigned long long dscr; pollution: tar unsigned long long tar; pollution: fpscr unsigned int fpscr; pollution: fpscrx unsigned int fpscrx; pollution: fpr double fpr[32]; pollution: tmcontext char tmcontext; pollution: tmstate char tmstate; pollution: prevowner char prevowner; pollution: pad char pad[5]; pollution: mstsave pollution: jmp_context struct mstsave jmp_context; pollution: mstsave32 pollution: jmp_context struct mstsave32 jmp_context; pollution: sc_onstack int sc_onstack; pollution: sc_mask sigset_t sc_mask; pollution: sc_uerror int sc_uerror; pollution: sc_jmpbuf struct __jmpbuf sc_jmpbuf; pollution: uc_sigmask sigset_t uc_sigmask; pollution: uc_mcontext mcontext_t uc_mcontext; pollution: uc_link struct ucontext_t *uc_link; pollution: uc_stack stack_t uc_stack; pollution: uc_sigmask sigset32_t uc_sigmask; pollution: uc_mcontext mcontext32_t uc_mcontext; pollution: uc_link __ptr32 uc_link; pollution: uc_stack stack32_t uc_stack; pollution: ss_sp void *ss_sp; pollution: ss_onstack int ss_onstack; pollution: sigstack struct sigstack { void *ss_sp; int ss_onstack; }; pollution: sigmask extern int sigmask(int); pollution: sigval pollution: sigev_value union sigval sigev_value; pollution: sigev_signo int sigev_signo; pollution: sigev_notify int sigev_notify; pollution: sigval pollution: sigev_notify_function void (*sigev_notify_function)(union sigval); pollution: sigev_notify_attributes pthread_attr_t * sigev_notify_attributes; pollution: sigevent struct sigevent { union sigval sigev_value; int sigev_signo; int sigev_notify; void (*sigev_notify_function)(union sigval); pthread_attr_t * sigev_notify_attributes; }; pollution: sevt_value void *sevt_value; pollution: sevt_signo signal_t sevt_signo; pollution: osigevent struct osigevent { void *sevt_value; signal_t sevt_signo; }; pollution: sv_handler void (*sv_handler)(int); pollution: sv_sigaction void (*sv_sigaction) (int, siginfo_t *, void *); pollution: sv_union union { void (*sv_handler)(int); void (*sv_sigaction) (int, siginfo_t *, void *); } sv_union; pollution: sv_mask int sv_mask; pollution: sv_flags int sv_flags; pollution: sigvec struct sigvec { union { void (*sv_handler)(int); void (*sv_sigaction) (int, siginfo_t *, void *); } sv_union; int sv_mask; int sv_flags; }; pollution: ssignal_r void (*ssignal_r(int, void (*)(int), void (*[])(int)))(int); pollution: gsignal_r int gsignal_r(int, void (*[])(int)); pollution: sigblock extern int sigblock (int); pollution: siglocalmask extern int siglocalmask(int, const sigset_t *); pollution: sigvec pollution: sigvec pollution: sigvec extern int sigvec(int, struct sigvec *, struct sigvec *); pollution: siggetmask extern int siggetmask (void); pollution: sigsetmask extern int sigsetmask (int); pollution: kill extern int kill(pid_t, int); pollution: sigprocmask extern int sigprocmask (int, const sigset_t *restrict, sigset_t *restrict); pollution: sigsuspend extern int sigsuspend(const sigset_t *); pollution: sigwait extern int sigwait(const sigset_t *restrict, int *restrict); pollution: sigaction pollution: sigaction pollution: sigaction extern int sigaction (int, const struct sigaction *restrict, struct sigaction *restrict); pollution: sigemptyset extern int sigemptyset (sigset_t *); pollution: sigfillset extern int sigfillset (sigset_t *); pollution: sigaddset extern int sigaddset (sigset_t *, int); pollution: sigdelset extern int sigdelset (sigset_t *, int); pollution: sigismember extern int sigismember (const sigset_t *, int); pollution: sigpending extern int sigpending (sigset_t *); pollution: bsd_signal extern void (*bsd_signal (int, void (*)(int)))(int); pollution: killpg extern int killpg(pid_t, int); pollution: sighold extern int sighold (int); pollution: sigignore extern int sigignore (int); pollution: siginterrupt extern int siginterrupt (int, int); pollution: sigpause extern int sigpause(int); pollution: sigrelse extern int sigrelse (int); pollution: sigset extern void (*sigset (int, void(*)(int)))(int); pollution: sigaltstack extern int sigaltstack(const stack_t *restrict, stack_t *restrict); pollution: sigstack pollution: sigstack pollution: sigstack extern int sigstack(struct sigstack *, struct sigstack *); pollution: pthread_kill extern int pthread_kill(pthread_t, int); pollution: pthread_sigmask extern int pthread_sigmask(int, const sigset_t *, sigset_t *); pollution: sigval pollution: sigqueue extern int sigqueue(pid_t, int, const union sigval); pollution: timespec struct timespec; pollution: timespec pollution: sigtimedwait extern int sigtimedwait(const sigset_t *restrict, siginfo_t *restrict, const struct timespec *restrict); pollution: sigwaitinfo extern int sigwaitinfo(const sigset_t *restrict, siginfo_t *restrict); pollution: psiginfo extern void psiginfo(const siginfo_t *, const char *); pollution: psignal extern void psignal(int, const char *); pollution: P_ALL pollution: P_PID pollution: P_PGID pollution: wait extern pid_t wait(int *); pollution: waitpid extern pid_t waitpid(pid_t, int *, int); pollution: waitid extern int waitid(idtype_t, id_t, siginfo_t *, int); pollution: rusage pollution: wait3 extern pid_t wait3(int *, int, struct rusage *); pollution: rusage pollution: kwaitpid extern pid_t kwaitpid(int *, pid_t, int, struct rusage *, siginfo_t *); pollution: rusage64 pollution: kwaitpid64 extern pid_t kwaitpid64(int *, pid_t, int, struct rusage64 *, siginfo_t *); pollution: rusage64 pollution: wait364 extern pid_t wait364(int *, int, struct rusage64 *); pollution: rusage pollution: wait4 extern pid_t wait4(pid_t, int *, int, struct rusage *); pollution: x unsigned x[3]; pollution: a unsigned a[3]; pollution: c unsigned c; pollution: lastx unsigned short lastx[3]; pollution: init int init; pollution: drand48_data pollution: DRAND48D typedef struct drand48_data { unsigned x[3]; unsigned a[3]; unsigned c; unsigned short lastx[3]; int init; } DRAND48D; pollution: drand48 extern double drand48 (void); pollution: erand48 extern double erand48 (unsigned short[]); pollution: jrand48 extern long jrand48 (unsigned short[]); pollution: lcong48 extern void lcong48 (unsigned short int *); pollution: lrand48 extern long lrand48 (void); pollution: mrand48 extern long mrand48 (void); pollution: nrand48 extern long nrand48 (unsigned short[]); pollution: seed48 extern unsigned short *seed48 (unsigned short[]); pollution: setkey extern void setkey (const char *); pollution: srand48 extern void srand48 (long); pollution: putenv extern int putenv (char *); pollution: rand_r extern int rand_r (unsigned int *); pollution: getopt_r extern int getopt_r( int, char* const*, const char*, int *, char **, int *, int , int *, int *); pollution: drand48_r extern int drand48_r (DRAND48D *, double *); pollution: erand48_r extern int erand48_r (unsigned short [], DRAND48D *, double *); pollution: lrand48_r extern int lrand48_r (DRAND48D *, long *); pollution: mrand48_r extern int mrand48_r (DRAND48D *, long *); pollution: srand48_r extern int srand48_r (long, DRAND48D *); pollution: seed48_r extern int seed48_r (unsigned short [], DRAND48D *); pollution: lcong48_r extern int lcong48_r (unsigned short [], DRAND48D *); pollution: nrand48_r extern int nrand48_r (unsigned short [], DRAND48D *, long *); pollution: jrand48_r extern int jrand48_r (unsigned short [], DRAND48D *, long *); pollution: ecvt_r extern int ecvt_r (double, int, int *, int *, char *, int); pollution: fcvt_r extern int fcvt_r (double, int, int *, int *, char *, int); pollution: a64l extern long a64l (const char *); pollution: ecvt extern char *ecvt (double, int, int *, int *); pollution: fcvt extern char *fcvt (double, int, int *, int *); pollution: gcvt extern char *gcvt (double, int, char *); pollution: mktemp extern char *mktemp (char *); pollution: getsubopt extern int getsubopt (char **, char *const *, char **); pollution: grantpt extern int grantpt (int); pollution: initstate extern char *initstate (unsigned, char *, size_t); pollution: l64a extern char *l64a (long); pollution: mkstemp extern int mkstemp(char *); pollution: mkdtemp extern char *mkdtemp (char *); pollution: mkstemp64 extern int mkstemp64(char *); pollution: ptsname extern char *ptsname (int); pollution: random extern long random (void); pollution: realpath extern char *realpath (const char *, char *); pollution: setstate extern char *setstate (char *); pollution: srandom extern void srandom (unsigned); pollution: unlockpt extern int unlockpt (int); pollution: posix_openpt extern int posix_openpt (int); pollution: setenv extern int setenv (const char *, const char *, int); pollution: unsetenv extern int unsetenv (const char *); pollution: fptr int *fptr; pollution: rptr int *rptr; pollution: state int *state; pollution: rand_type int rand_type; pollution: rand_deg int rand_deg; pollution: rand_sep int rand_sep; pollution: end_ptr int *end_ptr; pollution: random_data pollution: RANDOMD typedef struct random_data { int *fptr; int *rptr; int *state; int rand_type; int rand_deg; int rand_sep; int *end_ptr; } RANDOMD; pollution: srandom_r extern int srandom_r (unsigned, RANDOMD *); pollution: initstate_r extern int initstate_r (unsigned, char *, size_t, char **,RANDOMD *); pollution: setstate_r extern int setstate_r (char *, char **, RANDOMD *); pollution: random_r extern int random_r (long *, RANDOMD *); pollution: l64a_r extern int l64a_r(long, char*, int); pollution: SINFINITY extern unsigned int SINFINITY; pollution: SQNAN extern unsigned int SQNAN; pollution: DQNAN extern unsigned int DQNAN[2]; pollution: SSNAN extern unsigned int SSNAN; pollution: DSNAN extern unsigned int DSNAN[2]; pollution: fp_read_rnd fprnd_t fp_read_rnd(void); pollution: rnd pollution: fp_swap_rnd fprnd_t fp_swap_rnd(fprnd_t rnd); pollution: decimal_point char *decimal_point; pollution: thousands_sep char *thousands_sep; pollution: grouping char *grouping; pollution: int_curr_symbol char *int_curr_symbol; pollution: currency_symbol char *currency_symbol; pollution: mon_decimal_point char *mon_decimal_point; pollution: mon_thousands_sep char *mon_thousands_sep; pollution: mon_grouping char *mon_grouping; pollution: positive_sign char *positive_sign; pollution: negative_sign char *negative_sign; pollution: int_frac_digits char int_frac_digits; pollution: frac_digits char frac_digits; pollution: p_cs_precedes char p_cs_precedes; pollution: p_sep_by_space char p_sep_by_space; pollution: n_cs_precedes char n_cs_precedes; pollution: n_sep_by_space char n_sep_by_space; pollution: p_sign_posn char p_sign_posn; pollution: n_sign_posn char n_sign_posn; pollution: left_parenthesis char *left_parenthesis; pollution: right_parenthesis char *right_parenthesis; pollution: int_p_cs_precedes char int_p_cs_precedes; pollution: int_p_sep_by_space char int_p_sep_by_space; pollution: int_n_cs_precedes char int_n_cs_precedes; pollution: int_n_sep_by_space char int_n_sep_by_space; pollution: int_p_sign_posn char int_p_sign_posn; pollution: int_n_sign_posn char int_n_sign_posn; pollution: lconv struct lconv { char *decimal_point; char *thousands_sep; char *grouping; char *int_curr_symbol; char *currency_symbol; char *mon_decimal_point; char *mon_thousands_sep; char *mon_grouping; char *positive_sign; char *negative_sign; char int_frac_digits; char frac_digits; char p_cs_precedes; char p_sep_by_space; char n_cs_precedes; char n_sep_by_space; char p_sign_posn; char n_sign_posn; char *left_parenthesis; char *right_parenthesis; char int_p_cs_precedes; char int_p_sep_by_space; char int_n_cs_precedes; char int_n_sep_by_space; char int_p_sign_posn; char int_n_sign_posn; } ; pollution: lconv pollution: localeconv struct lconv *localeconv (void); pollution: setlocale char *setlocale (int, const char *); pollution: newlocale locale_t newlocale (int, const char *, locale_t); pollution: duplocale locale_t duplocale (locale_t); pollution: uselocale locale_t uselocale (locale_t); pollution: freelocale void freelocale (locale_t); pollution: lconv pollution: lconv typedef struct lconv lconv; pollution: cd_stroff short cd_stroff; pollution: cd_repoff short cd_repoff; pollution: cd_cval short cd_cval; pollution: cd_cuniq short cd_cuniq; pollution: coldesc typedef struct coldesc { short cd_stroff; short cd_repoff; short cd_cval; short cd_cuniq; } coldesc_t; pollution: lc_version short lc_version; pollution: lc_length short lc_length; pollution: lc_locale_name char *lc_locale_name; pollution: len_collate int len_collate; pollution: lc_collate short *lc_collate; pollution: len_coluniq int len_coluniq; pollution: lc_coluniq short *lc_coluniq; pollution: len_coldesc int len_coldesc; pollution: lc_coldesc coldesc_t *lc_coldesc; pollution: len_strings int len_strings; pollution: lc_strings wchar_t *lc_strings; pollution: high_cvalue int high_cvalue; pollution: collation_table typedef struct collation_table { short lc_version; short lc_length; char *lc_locale_name; int len_collate; short *lc_collate; int len_coluniq; short *lc_coluniq; int len_coldesc; coldesc_t *lc_coldesc; int len_strings; wchar_t *lc_strings; int high_cvalue; } col_t; pollution: lc_version short lc_version; pollution: lc_length short lc_length; pollution: lc_code_type short lc_code_type; pollution: mb_cur_max short mb_cur_max; pollution: mb_cur_min short mb_cur_min; pollution: lc_dsp_width short lc_dsp_width; pollution: lc_locale_name char *lc_locale_name; pollution: len_caseconv int len_caseconv; pollution: lc_caseconv wchar_t *lc_caseconv; pollution: len_ctype int len_ctype; pollution: lc_ctype unsigned short *lc_ctype; pollution: char_classification_table typedef struct char_classification_table { short lc_version; short lc_length; short lc_code_type; short mb_cur_max; short mb_cur_min; short lc_dsp_width; char *lc_locale_name; int len_caseconv; wchar_t *lc_caseconv; int len_ctype; unsigned short *lc_ctype; } ctype_t; pollution: lc_version short lc_version; pollution: lc_length short lc_length; pollution: lc_locale_name char *lc_locale_name; pollution: int_curr_symbol char *int_curr_symbol; pollution: currency_symbol char *currency_symbol; pollution: mon_decimal_point char *mon_decimal_point; pollution: mon_thousands_sep char *mon_thousands_sep; pollution: mon_grouping char *mon_grouping; pollution: positive_sign char *positive_sign; pollution: negative_sign char *negative_sign; pollution: int_frac_digits char int_frac_digits; pollution: frac_digits char frac_digits; pollution: p_cs_precedes char p_cs_precedes; pollution: p_sep_by_space char p_sep_by_space; pollution: n_cs_precedes char n_cs_precedes; pollution: n_sep_by_space char n_sep_by_space; pollution: p_sign_posn char p_sign_posn; pollution: n_sign_posn char n_sign_posn; pollution: lc_monetary_table typedef struct lc_monetary_table { short lc_version; short lc_length; char *lc_locale_name; char *int_curr_symbol; char *currency_symbol; char *mon_decimal_point; char *mon_thousands_sep; char *mon_grouping; char *positive_sign; char *negative_sign; char int_frac_digits; char frac_digits; char p_cs_precedes; char p_sep_by_space; char n_cs_precedes; char n_sep_by_space; char p_sign_posn; char n_sign_posn; } mon_t; pollution: lc_version short lc_version; pollution: lc_length short lc_length; pollution: lc_locale_name char *lc_locale_name; pollution: decimal_point char *decimal_point; pollution: thousands_sep char *thousands_sep; pollution: grouping char *grouping; pollution: numeric_table typedef struct numeric_table { short lc_version; short lc_length; char *lc_locale_name; char *decimal_point; char *thousands_sep; char *grouping; } num_t; pollution: lc_version short lc_version; pollution: lc_length short lc_length; pollution: lc_locale_name char *lc_locale_name; pollution: messages char *messages; pollution: yes_string char *yes_string; pollution: no_string char *no_string; pollution: lc_messages_table typedef struct lc_messages_table { short lc_version; short lc_length; char *lc_locale_name; char *messages; char *yes_string; char *no_string; } msg_t; pollution: lc_version short lc_version; pollution: lc_length short lc_length; pollution: lc_locale_name char *lc_locale_name; pollution: t_fmt char *t_fmt; pollution: d_fmt char *d_fmt; pollution: nlldate char *nlldate; pollution: d_t_fmt char *d_t_fmt; pollution: abday char *abday; pollution: day char *day; pollution: abmon char *abmon; pollution: mon char *mon; pollution: misc char *misc; pollution: tstrs char *tstrs; pollution: tunits char *tunits; pollution: year char *year; pollution: am_pm char *am_pm; pollution: lc_time_table typedef struct lc_time_table { short lc_version; short lc_length; char *lc_locale_name; char *t_fmt; char *d_fmt; char *nlldate; char *d_t_fmt; char *abday; char *day; char *abmon; char *mon; char *misc; char *tstrs; char *tunits; char *year; char *am_pm; } tim_t; pollution: lc_version short lc_version; pollution: lc_length short lc_length; pollution: lc_identifier char *lc_identifier; pollution: wchar_mapping_table typedef struct wchar_mapping_table { short lc_version; short lc_length; char *lc_identifier; } map_t; pollution: lc_mag0 pollution: lc_mag1 char lc_mag0, lc_mag1; pollution: lc_version short lc_version; pollution: lc_code_type short lc_code_type; pollution: lc_length short lc_length; pollution: lc_coltbl col_t *lc_coltbl; pollution: lc_chrtbl ctype_t *lc_chrtbl; pollution: lc_montbl mon_t *lc_montbl; pollution: lc_numtbl num_t *lc_numtbl; pollution: lc_timtbl tim_t *lc_timtbl; pollution: lc_msgtbl msg_t *lc_msgtbl; pollution: lc_maptbl map_t *lc_maptbl; pollution: localeinfo_table typedef struct localeinfo_table { char lc_mag0, lc_mag1; short lc_version; short lc_code_type; short lc_length; col_t *lc_coltbl; ctype_t *lc_chrtbl; mon_t *lc_montbl; num_t *lc_numtbl; tim_t *lc_timtbl; msg_t *lc_msgtbl; map_t *lc_maptbl; } loc_t; pollution: core _LC_core_charmap_t core; pollution: cm_csname char *cm_csname; pollution: cm_mb_cur_max size_t cm_mb_cur_max; pollution: cm_mb_cur_min size_t cm_mb_cur_min; pollution: cm_max_disp_width unsigned char cm_max_disp_width; pollution: cm_cstab unsigned char *cm_cstab; pollution: loc_rec struct __LC_locale *loc_rec; pollution: obj _LC_charmap_t *obj; pollution: meth void *(**meth)(); pollution: loc_hdl struct _LC_locale_objhdl *loc_hdl; pollution: core _LC_core_monetary_t core; pollution: int_curr_symbol char *int_curr_symbol; pollution: currency_symbol char *currency_symbol; pollution: mon_decimal_point char *mon_decimal_point; pollution: mon_thousands_sep char *mon_thousands_sep; pollution: mon_grouping char *mon_grouping; pollution: positive_sign char *positive_sign; pollution: negative_sign char *negative_sign; pollution: int_frac_digits signed char int_frac_digits; pollution: frac_digits signed char frac_digits; pollution: p_cs_precedes signed char p_cs_precedes; pollution: p_sep_by_space signed char p_sep_by_space; pollution: n_cs_precedes signed char n_cs_precedes; pollution: n_sep_by_space signed char n_sep_by_space; pollution: p_sign_posn signed char p_sign_posn; pollution: n_sign_posn signed char n_sign_posn; pollution: debit_sign char *debit_sign; pollution: credit_sign char *credit_sign; pollution: left_parenthesis char *left_parenthesis; pollution: right_parenthesis char *right_parenthesis; pollution: loc_rec struct __LC_locale *loc_rec; pollution: int_p_cs_precedes signed char int_p_cs_precedes; pollution: int_p_sep_by_space signed char int_p_sep_by_space; pollution: int_n_cs_precedes signed char int_n_cs_precedes; pollution: int_n_sep_by_space signed char int_n_sep_by_space; pollution: int_p_sign_posn signed char int_p_sign_posn; pollution: int_n_sign_posn signed char int_n_sign_posn; pollution: obj _LC_monetary_t *obj; pollution: meth void *(**meth)(); pollution: loc_hdl struct _LC_locale_objhdl *loc_hdl; pollution: core _LC_core_numeric_t core; pollution: decimal_point char *decimal_point; pollution: thousands_sep char *thousands_sep; pollution: grouping char *grouping; pollution: loc_rec struct __LC_locale *loc_rec; pollution: obj _LC_numeric_t *obj; pollution: meth void *(**meth)(); pollution: loc_hdl struct _LC_locale_objhdl *loc_hdl; pollution: core _LC_core_resp_t core; pollution: yesexpr char *yesexpr; pollution: noexpr char *noexpr; pollution: yesstr char *yesstr; pollution: nostr char *nostr; pollution: loc_rec struct __LC_locale *loc_rec; pollution: obj _LC_resp_t *obj; pollution: meth void *(**meth)(); pollution: loc_hdl struct _LC_locale_objhdl *loc_hdl; pollution: core _LC_core_time_t core; pollution: d_fmt char *d_fmt; pollution: t_fmt char *t_fmt; pollution: d_t_fmt char *d_t_fmt; pollution: t_fmt_ampm char *t_fmt_ampm; pollution: abday char *abday[7]; pollution: day char *day[7]; pollution: abmon char *abmon[12]; pollution: mon char *mon[12]; pollution: am_pm char *am_pm[2]; pollution: era char *era; pollution: era_year char *era_year; pollution: era_d_fmt char *era_d_fmt; pollution: alt_digits char *alt_digits; pollution: era_d_t_fmt char *era_d_t_fmt; pollution: era_t_fmt char *era_t_fmt; pollution: loc_rec struct __LC_locale *loc_rec; pollution: obj _LC_time_t *obj; pollution: meth void *(**meth)(); pollution: loc_hdl struct _LC_locale_objhdl *loc_hdl; pollution: n unsigned short n[4 +1]; pollution: ce_sym char *ce_sym; pollution: ce_wgt _LC_weight_t ce_wgt; pollution: ct_wgt _LC_weight_t ct_wgt; pollution: ct_collel _LC_collel_t *ct_collel; pollution: tgt_wgt_str char *tgt_wgt_str[4 +1]; pollution: core _LC_core_collate_t core; pollution: co_nord unsigned char co_nord; pollution: co_sort _LC_weight_t co_sort; pollution: co_wc_min wchar_t co_wc_min; pollution: co_wc_max wchar_t co_wc_max; pollution: co_col_min wchar_t co_col_min; pollution: co_col_max wchar_t co_col_max; pollution: co_coltbl _LC_coltbl_t *co_coltbl; pollution: co_nsubs unsigned int co_nsubs; pollution: co_subs _LC_subs_t *co_subs; pollution: co_special unsigned short co_special; pollution: loc_rec struct __LC_locale *loc_rec; pollution: obj _LC_collate_t *obj; pollution: meth void *(**meth)(); pollution: loc_hdl struct _LC_locale_objhdl *loc_hdl; pollution: name char *name; pollution: mask unsigned int mask; pollution: core _LC_core_ctype_t core; pollution: min_wc wchar_t min_wc; pollution: max_wc wchar_t max_wc; pollution: upper wchar_t *upper; pollution: lower wchar_t *lower; pollution: mask unsigned int *mask; pollution: qmask unsigned int *qmask; pollution: qidx unsigned char *qidx; pollution: nclasses unsigned char nclasses; pollution: classnms _LC_classnm_t *classnms; pollution: loc_rec struct __LC_locale *loc_rec; pollution: obj _LC_ctype_t *obj; pollution: meth void *(**meth)(); pollution: loc_hdl struct _LC_locale_objhdl *loc_hdl; pollution: core _LC_core_locale_t core; pollution: nl_info char *nl_info[63]; pollution: lconv pollution: nl_lconv struct lconv *nl_lconv; pollution: lc_charmap _LC_charmap_objhdl_t lc_charmap; pollution: lc_collate _LC_collate_objhdl_t lc_collate; pollution: lc_ctype _LC_ctype_objhdl_t lc_ctype; pollution: lc_monetary _LC_monetary_objhdl_t lc_monetary; pollution: lc_numeric _LC_numeric_objhdl_t lc_numeric; pollution: lc_resp _LC_resp_objhdl_t lc_resp; pollution: lc_time _LC_time_objhdl_t lc_time; pollution: loc_rec struct __LC_locale *loc_rec; pollution: obj _LC_locale_t *obj; pollution: meth void *(**meth)(); pollution: loc_hdl struct _LC_locale_objhdl *loc_hdl; pollution: lc_object _LC_object_t lc_object; pollution: lc_locale _LC_locale_objhdl_t lc_locale; pollution: lc_charmap _LC_charmap_objhdl_t lc_charmap; pollution: lc_collate _LC_collate_objhdl_t lc_collate; pollution: lc_ctype _LC_ctype_objhdl_t lc_ctype; pollution: lc_monetary _LC_monetary_objhdl_t lc_monetary; pollution: lc_numeric _LC_numeric_objhdl_t lc_numeric; pollution: lc_resp _LC_resp_objhdl_t lc_resp; pollution: lc_time _LC_time_objhdl_t lc_time; pollution: obj union { _LC_object_t lc_object; _LC_locale_objhdl_t lc_locale; _LC_charmap_objhdl_t lc_charmap; _LC_collate_objhdl_t lc_collate; _LC_ctype_objhdl_t lc_ctype; _LC_monetary_objhdl_t lc_monetary; _LC_numeric_objhdl_t lc_numeric; _LC_resp_objhdl_t lc_resp; _LC_time_objhdl_t lc_time; } obj; pollution: meth void *(**meth)(); pollution: loc_hdl struct _LC_locale_objhdl *loc_hdl; pollution: hdr _LC_object_t hdr; pollution: handle _LC_locale_objhdl_t handle; pollution: locale_name char *locale_name; pollution: cur_locale extern locale_t cur_locale; pollution: optarg extern char *optarg; pollution: optind extern int optind; pollution: opterr extern int opterr; pollution: atoff extern float atoff(char *); pollution: imul_dbl extern void imul_dbl(long, long, long *); pollution: umul_dbl extern void umul_dbl(unsigned long, unsigned long, unsigned long *); pollution: on_exit extern int on_exit (void (*)(int, void *), void *); pollution: unatexit extern int unatexit(void (*)(void)); pollution: wcstod extern double wcstod (const wchar_t *, wchar_t **); pollution: wcstol extern long int wcstol (const wchar_t *, wchar_t **, int); pollution: wcstoul extern unsigned long int wcstoul (const wchar_t *, wchar_t **, int); pollution: rpmatch extern int rpmatch (const char *); pollution: clearenv extern int clearenv (void); pollution: getopt extern int getopt (int, char* const*, const char*); pollution: getpass extern char *getpass(const char *); pollution: ttyslot extern int ttyslot (void); pollution: valloc extern void *valloc (size_t); pollution: vec_malloc extern void *vec_malloc(size_t); pollution: vec_calloc extern void *vec_calloc(size_t, size_t); pollution: x pollution: y double x, y; pollution: dbl_hypot struct dbl_hypot { double x, y; }; pollution: dbl_hypot extern double _cabshypot(struct dbl_hypot); pollution: drem extern double drem (double, double); pollution: exp__E extern double exp__E(double, double); pollution: log__L extern double log__L(double); pollution: nearest extern double nearest(double); pollution: rsqrt extern double rsqrt(double); pollution: finite extern int finite (double); pollution: itrunc extern int itrunc(double); pollution: unordered extern int unordered(double, double); pollution: uitrunc extern unsigned uitrunc(double); wrong type: function: expected define: isinf extern int isinf (double); pollution: dtoi extern int dtoi(double); pollution: class extern int class(); pollution: type int type; pollution: name char *name; pollution: arg1 double arg1; pollution: arg2 double arg2; pollution: retval double retval; pollution: exception struct exception { int type; char *name; double arg1; double arg2; double retval; }; pollution: ADD_NS_TO_TIMEVAL #define ADD_NS_TO_TIMEVAL(tvp,delta) { (tvp).tv_usec += delta; if((tvp).tv_usec >= NS_PER_SEC) { (tvp).tv_sec++; (tvp).tv_usec -= NS_PER_SEC; } } pollution: ADD_TO_NS #define ADD_TO_NS(tvp,delta) { (tvp).tv_nsec += delta; if((tvp).tv_nsec >= NS_PER_SEC) { (tvp).tv_sec++; (tvp).tv_nsec -= NS_PER_SEC; } } pollution: ADSP_MASK #define ADSP_MASK(_x) ((1U << 31) >> (_x)) pollution: AIO_LISTIO_MAX #define AIO_LISTIO_MAX 4096 pollution: AIO_LISTIO_MAX_SIZE #define AIO_LISTIO_MAX_SIZE AIO_LISTIO_MAX pollution: AIO_MAX #define AIO_MAX 4096 pollution: AIO_PRIO_DELTA_MAX #define AIO_PRIO_DELTA_MAX 20 pollution: AIO_PRIO_DFL #define AIO_PRIO_DFL 1 pollution: AIO_PRIO_MAX #define AIO_PRIO_MAX 1 pollution: AIO_PRIO_MIN #define AIO_PRIO_MIN 1 pollution: AMRSTACKFRAMESZ #define AMRSTACKFRAMESZ _AMRSTACKFRAMESZ pollution: AMRSTACKSIZE #define AMRSTACKSIZE _AMRSTACKSIZE pollution: ARG_MAX #define ARG_MAX 1048576 pollution: ATEXIT_MAX #define ATEXIT_MAX 2048 pollution: BADSIG #define BADSIG SIG_ERR pollution: BC_BASE_MAX #define BC_BASE_MAX _POSIX2_BC_BASE_MAX pollution: BC_DIM_MAX #define BC_DIM_MAX _POSIX2_BC_DIM_MAX pollution: BC_SCALE_MAX #define BC_SCALE_MAX _POSIX2_BC_SCALE_MAX pollution: BC_STRING_MAX #define BC_STRING_MAX 2048 pollution: BUS_ADRALN #define BUS_ADRALN 1 pollution: BUS_ADRERR #define BUS_ADRERR 2 pollution: BUS_OBJERR #define BUS_OBJERR 3 pollution: BUS_UEGARD #define BUS_UEGARD 4 pollution: CHARCLASS_NAME_MAX #define CHARCLASS_NAME_MAX 14 pollution: CHAR_BIT #define CHAR_BIT (8) pollution: CHAR_MAX #define CHAR_MAX UCHAR_MAX pollution: CHAR_MIN #define CHAR_MIN (0) pollution: CHILD_MAX #define CHILD_MAX 128 pollution: CLD_CONTINUED #define CLD_CONTINUED 15 pollution: CLD_DUMPED #define CLD_DUMPED 12 pollution: CLD_EXITED #define CLD_EXITED 10 pollution: CLD_KILLED #define CLD_KILLED 11 pollution: CLD_STOPPED #define CLD_STOPPED 14 pollution: CLD_TRAPPED #define CLD_TRAPPED 13 pollution: CLKTICK #define CLKTICK _CLKTICK pollution: COLL_WEIGHTS_MAX #define COLL_WEIGHTS_MAX 4 pollution: CP_ITIMERSTRUCT #define CP_ITIMERSTRUCT(__tsrc,__tdest) (__tdest).it_interval.tv_sec = (__tsrc).it_interval.tv_sec; (__tdest).it_interval.tv_nsec = (__tsrc).it_interval.tv_nsec; (__tdest).it_value.tv_sec = (__tsrc).it_value.tv_sec; (__tdest).it_value.tv_nsec = (__tsrc).it_value.tv_nsec pollution: CP_RUSAGE #define CP_RUSAGE(__tsrc,__tdest) { (__tdest)->ru_utime.tv_sec = (__tsrc)->ru_utime.tv_sec; (__tdest)->ru_utime.tv_usec = (__tsrc)->ru_utime.tv_usec; (__tdest)->ru_stime.tv_sec = (__tsrc)->ru_stime.tv_sec; (__tdest)->ru_stime.tv_usec = (__tsrc)->ru_stime.tv_usec; (__tdest)->ru_maxrss = (__tsrc)->ru_maxrss; (__tdest)->ru_ixrss = (__tsrc)->ru_ixrss; (__tdest)->ru_idrss = (__tsrc)->ru_idrss; (__tdest)->ru_isrss = (__tsrc)->ru_isrss; (__tdest)->ru_minflt = (__tsrc)->ru_minflt; (__tdest)->ru_majflt = (__tsrc)->ru_majflt; (__tdest)->ru_nswap = (__tsrc)->ru_nswap; (__tdest)->ru_inblock = (__tsrc)->ru_inblock; (__tdest)->ru_oublock = (__tsrc)->ru_oublock; (__tdest)->ru_msgsnd = (__tsrc)->ru_msgsnd; (__tdest)->ru_msgrcv = (__tsrc)->ru_msgrcv; (__tdest)->ru_nsignals = (__tsrc)->ru_nsignals; (__tdest)->ru_nvcsw = (__tsrc)->ru_nvcsw; (__tdest)->ru_nivcsw = (__tsrc)->ru_nivcsw; } pollution: CP_TIMESTRUCT #define CP_TIMESTRUCT(__tsrc,__tdest) (__tdest).tv_sec = (__tsrc).tv_sec; (__tdest).tv_nsec = (__tsrc).tv_nsec pollution: CP_TIMEVAL #define CP_TIMEVAL(__tsrc,__tdest) (__tdest).tv_sec = (__tsrc).tv_sec; (__tdest).tv_usec = (__tsrc).tv_usec pollution: CUBRTHUGE #define CUBRTHUGE 5.6438030941223618e102 pollution: DBL_DECIMAL_DIG #define DBL_DECIMAL_DIG __DBL_DECIMAL_DIG__ pollution: DBL_DIG #define DBL_DIG __DBL_DIG__ pollution: DBL_EPSILON #define DBL_EPSILON __DBL_EPSILON__ pollution: DBL_HAS_SUBNORM #define DBL_HAS_SUBNORM __DBL_HAS_DENORM__ pollution: DBL_INFINITY #define DBL_INFINITY (*((double *) (_DBLINF))) pollution: DBL_MANT_DIG #define DBL_MANT_DIG __DBL_MANT_DIG__ pollution: DBL_MAX #define DBL_MAX __DBL_MAX__ pollution: DBL_MAX_10_EXP #define DBL_MAX_10_EXP __DBL_MAX_10_EXP__ pollution: DBL_MAX_EXP #define DBL_MAX_EXP __DBL_MAX_EXP__ pollution: DBL_MIN #define DBL_MIN __DBL_MIN__ pollution: DBL_MIN_10_EXP #define DBL_MIN_10_EXP __DBL_MIN_10_EXP__ pollution: DBL_MIN_EXP #define DBL_MIN_EXP __DBL_MIN_EXP__ pollution: DBL_QNAN #define DBL_QNAN (*((double *) (DQNAN))) pollution: DBL_SNAN #define DBL_SNAN (*((double *) (DSNAN))) pollution: DBL_TRUE_MIN #define DBL_TRUE_MIN __DBL_DENORM_MIN__ pollution: DECIMAL_DIG #define DECIMAL_DIG __DECIMAL_DIG__ pollution: DELAYTIMER_MAX #define DELAYTIMER_MAX _POSIX_DELAYTIMER_MAX pollution: DEV_OFF_MAX #define DEV_OFF_MAX 0xffffffffffLL pollution: DFLDSIZ #define DFLDSIZ _DFLDSIZ pollution: DFLSSIZ #define DFLSSIZ _DFLSSIZ pollution: DINFINITY #define DINFINITY _DBLINF pollution: DOMAIN #define DOMAIN 01 pollution: DST_AUST #define DST_AUST 2 pollution: DST_CAN #define DST_CAN 6 pollution: DST_EET #define DST_EET 5 pollution: DST_MET #define DST_MET 4 pollution: DST_NONE #define DST_NONE 0 pollution: DST_USA #define DST_USA 1 pollution: DST_WET #define DST_WET 3 pollution: EQUIV_CLASS_MAX #define EQUIV_CLASS_MAX 4 pollution: EXCONTINUE #define EXCONTINUE _EXCONTINUE pollution: EXDLOK #define EXDLOK _EXDLOK pollution: EXIO #define EXIO _EXIO pollution: EXIT_FAILURE #define EXIT_FAILURE (1) pollution: EXIT_SUCCESS #define EXIT_SUCCESS 0 pollution: EXPGIO #define EXPGIO _EXPGIO pollution: EXPR_NEST_MAX #define EXPR_NEST_MAX _POSIX2_EXPR_NEST_MAX pollution: EXRESUME #define EXRESUME _EXRESUME pollution: EXRETURN #define EXRETURN _EXRETURN pollution: EXSIG #define EXSIG _EXSIG pollution: EXTRAP #define EXTRAP _EXTRAP pollution: FALSE #define FALSE 0 pollution: FD_CLR #define FD_CLR(n,p) ((p)->fds_bits[(n)/__NFDBITS] &= ~((long)1 << ((n) % __NFDBITS))) pollution: FD_ISSET #define FD_ISSET(n,p) (((p)->fds_bits[(n)/__NFDBITS] & ((long)1 << ((n) % __NFDBITS)))?1:0) pollution: FD_SET #define FD_SET(n,p) ((p)->fds_bits[(n)/__NFDBITS] |= ((long)1 << ((n) % __NFDBITS))) pollution: FD_SETSIZE #define FD_SETSIZE 65534 pollution: FD_ZERO #define FD_ZERO(p) memset((p), 0, sizeof(*(p))) pollution: FHSIZE #define FHSIZE 32 pollution: FLT_DECIMAL_DIG #define FLT_DECIMAL_DIG __FLT_DECIMAL_DIG__ pollution: FLT_DIG #define FLT_DIG __FLT_DIG__ pollution: FLT_EPSILON #define FLT_EPSILON __FLT_EPSILON__ pollution: FLT_EVAL_METHOD #define FLT_EVAL_METHOD __FLT_EVAL_METHOD__ pollution: FLT_HAS_SUBNORM #define FLT_HAS_SUBNORM __FLT_HAS_DENORM__ pollution: FLT_INFINITY #define FLT_INFINITY (*((float *) (&SINFINITY))) pollution: FLT_MANT_DIG #define FLT_MANT_DIG __FLT_MANT_DIG__ pollution: FLT_MAX #define FLT_MAX __FLT_MAX__ pollution: FLT_MAX_10_EXP #define FLT_MAX_10_EXP __FLT_MAX_10_EXP__ pollution: FLT_MAX_EXP #define FLT_MAX_EXP __FLT_MAX_EXP__ pollution: FLT_MIN #define FLT_MIN __FLT_MIN__ pollution: FLT_MIN_10_EXP #define FLT_MIN_10_EXP __FLT_MIN_10_EXP__ pollution: FLT_MIN_EXP #define FLT_MIN_EXP __FLT_MIN_EXP__ pollution: FLT_QNAN #define FLT_QNAN (*((float *) (&SQNAN))) pollution: FLT_RADIX #define FLT_RADIX __FLT_RADIX__ pollution: FLT_ROUNDS #define FLT_ROUNDS (__builtin_flt_rounds()) pollution: FLT_SNAN #define FLT_SNAN (*((float *) (&SSNAN))) pollution: FLT_TRUE_MIN #define FLT_TRUE_MIN __FLT_DENORM_MIN__ pollution: FPE_FLTDIV #define FPE_FLTDIV 22 pollution: FPE_FLTINV #define FPE_FLTINV 26 pollution: FPE_FLTOVF #define FPE_FLTOVF 23 pollution: FPE_FLTRES #define FPE_FLTRES 25 pollution: FPE_FLTSUB #define FPE_FLTSUB 27 pollution: FPE_FLTUND #define FPE_FLTUND 24 pollution: FPE_INTDIV #define FPE_INTDIV 20 pollution: FPE_INTOVF #define FPE_INTOVF 21 pollution: FRAMESIZE #define FRAMESIZE _FRAMESIZE pollution: FWADUMP_DATA #define FWADUMP_DATA 0x1 pollution: HOST_NAME_MAX #define HOST_NAME_MAX 256 pollution: HUGE #define HUGE HUGE_VAL pollution: HZ #define HZ _HZ pollution: ILL_BADSTK #define ILL_BADSTK 37 pollution: ILL_COPROC #define ILL_COPROC 36 pollution: ILL_ILLADR #define ILL_ILLADR 32 pollution: ILL_ILLOPC #define ILL_ILLOPC 30 pollution: ILL_ILLOPN #define ILL_ILLOPN 31 pollution: ILL_ILLTRP #define ILL_ILLTRP 33 pollution: ILL_PRVOPC #define ILL_PRVOPC 34 pollution: ILL_PRVREG #define ILL_PRVREG 35 pollution: ILL_TMBADTHING #define ILL_TMBADTHING 38 pollution: INT16_C #define INT16_C(c) c pollution: INT16_MAX #define INT16_MAX (32767) pollution: INT16_MIN #define INT16_MIN (-32767-1) pollution: INT32_C #define INT32_C(c) c pollution: INT32_MAX #define INT32_MAX (2147483647) pollution: INT32_MIN #define INT32_MIN (-2147483647-1) pollution: INT64_C #define INT64_C(c) __CONCAT__(c,LL) pollution: INT64_MAX #define INT64_MAX (INT64_C(9223372036854775807)) pollution: INT64_MIN #define INT64_MIN (INT64_C(-9223372036854775807)-1) pollution: INT8_C #define INT8_C(c) c pollution: INT8_MAX #define INT8_MAX (127) pollution: INT8_MIN #define INT8_MIN (-128) pollution: INTFAST_MAX #define INTFAST_MAX INT32_MAX pollution: INTFAST_MIN #define INTFAST_MIN INT32_MIN pollution: INTMAX_C #define INTMAX_C(c) __CONCAT__(c,LL) pollution: INTMAX_MAX #define INTMAX_MAX INT64_MAX pollution: INTMAX_MIN #define INTMAX_MIN INT64_MIN pollution: INTPTR_MAX #define INTPTR_MAX (2147483647L) pollution: INTPTR_MIN #define INTPTR_MIN (-2147483647L-1) pollution: INT_FAST16_MAX #define INT_FAST16_MAX INT16_MAX pollution: INT_FAST16_MIN #define INT_FAST16_MIN INT16_MIN pollution: INT_FAST32_MAX #define INT_FAST32_MAX INT32_MAX pollution: INT_FAST32_MIN #define INT_FAST32_MIN INT32_MIN pollution: INT_FAST64_MAX #define INT_FAST64_MAX INT64_MAX pollution: INT_FAST64_MIN #define INT_FAST64_MIN INT64_MIN pollution: INT_FAST8_MAX #define INT_FAST8_MAX INT8_MAX pollution: INT_FAST8_MIN #define INT_FAST8_MIN INT8_MIN pollution: INT_LEAST16_MAX #define INT_LEAST16_MAX INT16_MAX pollution: INT_LEAST16_MIN #define INT_LEAST16_MIN INT16_MIN pollution: INT_LEAST32_MAX #define INT_LEAST32_MAX INT32_MAX pollution: INT_LEAST32_MIN #define INT_LEAST32_MIN INT32_MIN pollution: INT_LEAST64_MAX #define INT_LEAST64_MAX INT64_MAX pollution: INT_LEAST64_MIN #define INT_LEAST64_MIN INT64_MIN pollution: INT_LEAST8_MAX #define INT_LEAST8_MAX INT8_MAX pollution: INT_LEAST8_MIN #define INT_LEAST8_MIN INT8_MIN pollution: INT_MAX #define INT_MAX (2147483647) pollution: INT_MIN #define INT_MIN (-INT_MAX - 1) pollution: INV_CUBRTHUGE #define INV_CUBRTHUGE 1.7718548704178434e-103 pollution: IOV_MAX #define IOV_MAX _XOPEN_IOV_MAX pollution: ITIMER_PROF #define ITIMER_PROF 2 pollution: ITIMER_REAL #define ITIMER_REAL 0 pollution: ITIMER_REAL1 #define ITIMER_REAL1 20 pollution: ITIMER_REAL_TH #define ITIMER_REAL_TH ITIMER_REAL1 pollution: ITIMER_VIRT #define ITIMER_VIRT 3 pollution: ITIMER_VIRTUAL #define ITIMER_VIRTUAL 1 pollution: LC_ALL #define LC_ALL (-1) pollution: LC_ALL_MASK #define LC_ALL_MASK (LC_COLLATE_MASK | LC_CTYPE_MASK | LC_MESSAGES_MASK | LC_MONETARY_MASK | LC_NUMERIC_MASK | LC_TIME_MASK) pollution: LC_COLLATE #define LC_COLLATE 0 pollution: LC_COLLATE_MASK #define LC_COLLATE_MASK 1 pollution: LC_CTYPE #define LC_CTYPE 1 pollution: LC_CTYPE_MASK #define LC_CTYPE_MASK 2 pollution: LC_GLOBAL_LOCALE #define LC_GLOBAL_LOCALE (locale_t)-1 pollution: LC_MESSAGES #define LC_MESSAGES 5 pollution: LC_MESSAGES_MASK #define LC_MESSAGES_MASK 4 pollution: LC_MONETARY #define LC_MONETARY 2 pollution: LC_MONETARY_MASK #define LC_MONETARY_MASK 8 pollution: LC_NUMERIC #define LC_NUMERIC 3 pollution: LC_NUMERIC_MASK #define LC_NUMERIC_MASK 16 pollution: LC_TIME #define LC_TIME 4 pollution: LC_TIME_MASK #define LC_TIME_MASK 32 pollution: LDBL_DECIMAL_DIG #define LDBL_DECIMAL_DIG __LDBL_DECIMAL_DIG__ pollution: LDBL_DIG #define LDBL_DIG __LDBL_DIG__ pollution: LDBL_EPSILON #define LDBL_EPSILON __LDBL_EPSILON__ pollution: LDBL_HAS_SUBNORM #define LDBL_HAS_SUBNORM __LDBL_HAS_DENORM__ pollution: LDBL_INFINITY #define LDBL_INFINITY DBL_INFINITY pollution: LDBL_MANT_DIG #define LDBL_MANT_DIG __LDBL_MANT_DIG__ pollution: LDBL_MAX #define LDBL_MAX __LDBL_MAX__ pollution: LDBL_MAX_10_EXP #define LDBL_MAX_10_EXP __LDBL_MAX_10_EXP__ pollution: LDBL_MAX_EXP #define LDBL_MAX_EXP __LDBL_MAX_EXP__ pollution: LDBL_MIN #define LDBL_MIN __LDBL_MIN__ pollution: LDBL_MIN_10_EXP #define LDBL_MIN_10_EXP __LDBL_MIN_10_EXP__ pollution: LDBL_MIN_EXP #define LDBL_MIN_EXP __LDBL_MIN_EXP__ pollution: LDBL_TRUE_MIN #define LDBL_TRUE_MIN __LDBL_DENORM_MIN__ pollution: LINE_MAX #define LINE_MAX _POSIX2_LINE_MAX pollution: LINK_MAX #define LINK_MAX SHRT_MAX pollution: LLONGTOSIGSET #define LLONGTOSIGSET(__ll,__set) { (__set).hisigs = *(int *)&(__ll); (__set).losigs = *((int *)&(__ll)+1); } pollution: LLONG_MAX #define LLONG_MAX (9223372036854775807LL) pollution: LLONG_MIN #define LLONG_MIN (-9223372036854775807LL -1LL) pollution: LOADWCS #define LOADWCS _LOADWCS pollution: LOGIN_NAME_MAX #define LOGIN_NAME_MAX 9 pollution: LONGLONG_MAX #define LONGLONG_MAX (0x7fffffffffffffffLL) pollution: LONGLONG_MIN #define LONGLONG_MIN (-LONGLONG_MAX - 1) pollution: LONG_BIT #define LONG_BIT 32 pollution: LONG_MAX #define LONG_MAX (2147483647L) pollution: LONG_MIN #define LONG_MIN (-LONG_MAX - 1) pollution: LOW_SIG #define LOW_SIG(__s) ((__s) <= 32 ) pollution: LOW_SIG32 #define LOW_SIG32(__s) ((__s) <= 32 ) pollution: MAXDSIZ #define MAXDSIZ _MAXDSIZ pollution: MAXFIDSZ #define MAXFIDSZ 20 pollution: MAXFLOAT #define MAXFLOAT (*((float *) (&_SFPMAX))) pollution: MAXSEG #define MAXSEG _MAXSEG pollution: MAXSIG #define MAXSIG 16 pollution: MAXSSIZ #define MAXSSIZ _MAXSSIZ pollution: MAXTSIZ #define MAXTSIZ _MAXTSIZ pollution: MAX_CANON #define MAX_CANON 256 pollution: MAX_DEC_NS #define MAX_DEC_NS 147483647 pollution: MAX_DEC_SECS #define MAX_DEC_SECS 2 pollution: MAX_INPUT #define MAX_INPUT 512 pollution: MAX_NS_TO_uS #define MAX_NS_TO_uS 294967296 pollution: MAX_SECS_TO_uS #define MAX_SECS_TO_uS 4000 pollution: MB_CUR_MAX #define MB_CUR_MAX (__OBJ_DATA(*__LC_CHARMAP_PTR)->cm_mb_cur_max) pollution: MB_LEN_MAX #define MB_LEN_MAX 4 pollution: MINSIG #define MINSIG (-4) pollution: MINSIGSTKSZ #define MINSIGSTKSZ ((sizeof (ucontext_t))+2*_STACK_FLOOR) pollution: MIN_SECS_SINCE_EPOCH #define MIN_SECS_SINCE_EPOCH 0 pollution: MQ_OPEN_MAX #define MQ_OPEN_MAX 32768 pollution: MQ_PRIO_MAX #define MQ_PRIO_MAX 128 pollution: MS_PER_SEC #define MS_PER_SEC 1000 pollution: M_1_PI #define M_1_PI 0.318309886183790671537767526745028724 pollution: M_2PI #define M_2PI 6.2831853071795862320E0 pollution: M_2_PI #define M_2_PI 0.636619772367581343075535053490057448 pollution: M_2_SQRTPI #define M_2_SQRTPI 1.12837916709551257389615890312154517 pollution: M_E #define M_E 2.71828182845904523536028747135266250 pollution: M_LN10 #define M_LN10 2.30258509299404568401799145468436421 pollution: M_LN2 #define M_LN2 0.693147180559945309417232121458176568 pollution: M_LOG10E #define M_LOG10E 0.434294481903251827651128918916605082 pollution: M_LOG2E #define M_LOG2E 1.44269504088896340735992468100189214 pollution: M_PI #define M_PI 3.14159265358979323846264338327950288 pollution: M_PI_2 #define M_PI_2 1.57079632679489661923132169163975144 pollution: M_PI_4 #define M_PI_4 0.785398163397448309615660845819875721 pollution: M_SQRT1_2 #define M_SQRT1_2 0.707106781186547524400844362104849039 pollution: M_SQRT2 #define M_SQRT2 1.41421356237309504880168872420969808 pollution: NALRM #define NALRM 1 pollution: NALRM_THREAD #define NALRM_THREAD 1 pollution: NBBY #define NBBY 8 pollution: NFPRS #define NFPRS _NFPRS pollution: NGPRS #define NGPRS _NGPRS pollution: NGROUPS_MAX #define NGROUPS_MAX 2048 pollution: NGROUPS_MIN #define NGROUPS_MIN 128 pollution: NHIVSRS #define NHIVSRS _NHIVSRS pollution: NLCTMAG0 #define NLCTMAG0 (unsigned char)0x01 pollution: NLCTMAG1 #define NLCTMAG1 (unsigned char)0x05 pollution: NLOVSRS #define NLOVSRS _NLOVSRS pollution: NL_ARGMAX #define NL_ARGMAX 9 pollution: NL_LANGMAX #define NL_LANGMAX 14 pollution: NL_MSGMAX #define NL_MSGMAX 65535 pollution: NL_SETMAX #define NL_SETMAX 65535 pollution: NL_TEXTMAX #define NL_TEXTMAX 16384 pollution: NO_VOLATILE_REGS #define NO_VOLATILE_REGS 0x0001 pollution: NPROF #define NPROF 1 pollution: NSIG #define NSIG NSIG32 pollution: NSIG32 #define NSIG32 (SIGMAX32+1) pollution: NSIG64 #define NSIG64 (SIGMAX64+1) pollution: NSRS #define NSRS _NSRS pollution: NS_PER_MSEC #define NS_PER_MSEC (NS_PER_SEC / 1000) pollution: NS_PER_SEC #define NS_PER_SEC 1000000000 pollution: NS_PER_TICK #define NS_PER_TICK (NS_PER_SEC/HZ) pollution: NS_PER_uS #define NS_PER_uS (1000) pollution: NTIMEOFDAY #define NTIMEOFDAY 5 pollution: NTIMERS #define NTIMERS (NALRM + NPROF + NVIRTUAL + NTIMEOFDAY) pollution: NTIMERS_THREAD #define NTIMERS_THREAD (NALRM_THREAD) pollution: NULL #define NULL 0 pollution: NUMBER_OF_FRAMES #define NUMBER_OF_FRAMES _NUMBER_OF_FRAMES pollution: NUMBER_OF_RECOVERY_FRAMES #define NUMBER_OF_RECOVERY_FRAMES _NUMBER_OF_RECOVERY_FRAMES pollution: NVIRTUAL #define NVIRTUAL 2 pollution: NVRS #define NVRS _NVRS pollution: NVSRS #define NVSRS _NVSRS pollution: NZERO #define NZERO 20 pollution: OFF_CONT #define OFF_CONT ((uint) &((struct sigcontext *)0)->sc_jmpbuf) pollution: OFF_CONT64 #define OFF_CONT64 ((uint) &((struct sigcontext64 *)0)->sc_context) pollution: OFF_FPINFO #define OFF_FPINFO ((uint) &((struct sigcontext64 *)0)->sc_context.fpinfo) pollution: OFF_FPR #define OFF_FPR ((uint) &((struct sigcontext64 *)0)->sc_context.fpr[0]) pollution: OFF_FPSCR #define OFF_FPSCR ((uint) &((struct sigcontext64 *)0)->sc_context.fpscr) pollution: OFF_FPSCRX #define OFF_FPSCRX ((uint) &((struct sigcontext64 *)0)->sc_context.fpscrx) pollution: OFF_MAX #define OFF_MAX 0x7fffffff pollution: OPEN_MAX #define OPEN_MAX 65534 pollution: OVERFLOW #define OVERFLOW 03 pollution: PAGESIZE #define PAGESIZE PAGE_SIZE pollution: PAGE_SIZE #define PAGE_SIZE 4096 pollution: PASS_MAX #define PASS_MAX 255 pollution: PATH_MAX #define PATH_MAX 1023 pollution: PID_MAX #define PID_MAX INT_MAX pollution: PIPE_BUF #define PIPE_BUF 32768 pollution: PLOSS #define PLOSS 06 pollution: PMAP_OVBUF_CHAR #define PMAP_OVBUF_CHAR _PMAP_OVBUF_CHAR pollution: PMAP_OVBUF_SIZE #define PMAP_OVBUF_SIZE _PMAP_OVBUF_SIZE pollution: PMAP_OVBUF_ULL #define PMAP_OVBUF_ULL _PMAP_OVBUF_ULL pollution: PMAP_STK_SIZE #define PMAP_STK_SIZE _PMAP_STK_SIZE pollution: POLL_ERR #define POLL_ERR 43 pollution: POLL_HUP #define POLL_HUP 45 pollution: POLL_IN #define POLL_IN 40 pollution: POLL_MSG #define POLL_MSG (-3) pollution: POLL_OUT #define POLL_OUT 41 pollution: POLL_PRI #define POLL_PRI 44 pollution: PPC_IMP #define PPC_IMP _PPC_IMP pollution: PPC_IMP_REC #define PPC_IMP_REC _PPC_IMP_REC pollution: PPC_OFF #define PPC_OFF _PPC_OFF pollution: PPC_PRECISE #define PPC_PRECISE _PPC_PRECISE pollution: PRIO_MAX #define PRIO_MAX 20 pollution: PRIO_MIN #define PRIO_MIN -20 pollution: PRIO_PGRP #define PRIO_PGRP 1 pollution: PRIO_PROCESS #define PRIO_PROCESS 0 pollution: PRIO_USER #define PRIO_USER 2 pollution: PRIX16 #define PRIX16 "hX" pollution: PRIX32 #define PRIX32 "X" pollution: PRIX64 #define PRIX64 "llX" pollution: PRIX8 #define PRIX8 "hhX" pollution: PRIXFAST16 #define PRIXFAST16 "hX" pollution: PRIXFAST32 #define PRIXFAST32 "X" pollution: PRIXFAST64 #define PRIXFAST64 "llX" pollution: PRIXFAST8 #define PRIXFAST8 "hhX" pollution: PRIXLEAST16 #define PRIXLEAST16 "hX" pollution: PRIXLEAST32 #define PRIXLEAST32 "X" pollution: PRIXLEAST64 #define PRIXLEAST64 "llX" pollution: PRIXLEAST8 #define PRIXLEAST8 "hhX" pollution: PRIXMAX #define PRIXMAX "llX" pollution: PRIXPTR #define PRIXPTR "lX" pollution: PRId16 #define PRId16 "hd" pollution: PRId32 #define PRId32 "d" pollution: PRId64 #define PRId64 "lld" pollution: PRId8 #define PRId8 "hhd" pollution: PRIdFAST #define PRIdFAST "d" pollution: PRIdFAST16 #define PRIdFAST16 "hd" pollution: PRIdFAST32 #define PRIdFAST32 "d" pollution: PRIdFAST64 #define PRIdFAST64 "lld" pollution: PRIdFAST8 #define PRIdFAST8 "hhd" pollution: PRIdLEAST16 #define PRIdLEAST16 "hd" pollution: PRIdLEAST32 #define PRIdLEAST32 "d" pollution: PRIdLEAST64 #define PRIdLEAST64 "lld" pollution: PRIdLEAST8 #define PRIdLEAST8 "hhd" pollution: PRIdMAX #define PRIdMAX "lld" pollution: PRIdPTR #define PRIdPTR "ld" pollution: PRIi16 #define PRIi16 "hi" pollution: PRIi32 #define PRIi32 "i" pollution: PRIi64 #define PRIi64 "lli" pollution: PRIi8 #define PRIi8 "hhi" pollution: PRIiFAST16 #define PRIiFAST16 "hi" pollution: PRIiFAST32 #define PRIiFAST32 "i" pollution: PRIiFAST64 #define PRIiFAST64 "lli" pollution: PRIiFAST8 #define PRIiFAST8 "hhi" pollution: PRIiLEAST16 #define PRIiLEAST16 "hi" pollution: PRIiLEAST32 #define PRIiLEAST32 "i" pollution: PRIiLEAST64 #define PRIiLEAST64 "lli" pollution: PRIiLEAST8 #define PRIiLEAST8 "hhi" pollution: PRIiMAX #define PRIiMAX "lld" pollution: PRIiPTR #define PRIiPTR "ld" pollution: PRIo16 #define PRIo16 "ho" pollution: PRIo32 #define PRIo32 "o" pollution: PRIo64 #define PRIo64 "llo" pollution: PRIo8 #define PRIo8 "hho" pollution: PRIoFAST #define PRIoFAST "o" pollution: PRIoFAST16 #define PRIoFAST16 "ho" pollution: PRIoFAST32 #define PRIoFAST32 "o" pollution: PRIoFAST64 #define PRIoFAST64 "llo" pollution: PRIoFAST8 #define PRIoFAST8 "hho" pollution: PRIoLEAST16 #define PRIoLEAST16 "ho" pollution: PRIoLEAST32 #define PRIoLEAST32 "o" pollution: PRIoLEAST64 #define PRIoLEAST64 "llo" pollution: PRIoLEAST8 #define PRIoLEAST8 "ho" pollution: PRIoMAX #define PRIoMAX "llo" pollution: PRIoPTR #define PRIoPTR "lo" pollution: PRIu16 #define PRIu16 "hu" pollution: PRIu32 #define PRIu32 "u" pollution: PRIu64 #define PRIu64 "llu" pollution: PRIu8 #define PRIu8 "hhu" pollution: PRIuFAST #define PRIuFAST "u" pollution: PRIuFAST16 #define PRIuFAST16 "hu" pollution: PRIuFAST32 #define PRIuFAST32 "u" pollution: PRIuFAST64 #define PRIuFAST64 "llu" pollution: PRIuFAST8 #define PRIuFAST8 "hhu" pollution: PRIuLEAST16 #define PRIuLEAST16 "hu" pollution: PRIuLEAST32 #define PRIuLEAST32 "u" pollution: PRIuLEAST64 #define PRIuLEAST64 "llu" pollution: PRIuLEAST8 #define PRIuLEAST8 "hhu" pollution: PRIuMAX #define PRIuMAX "llu" pollution: PRIuPTR #define PRIuPTR "lu" pollution: PRIx16 #define PRIx16 "hx" pollution: PRIx32 #define PRIx32 "x" pollution: PRIx64 #define PRIx64 "llx" pollution: PRIx8 #define PRIx8 "hhx" pollution: PRIxFAST #define PRIxFAST "x" pollution: PRIxFAST16 #define PRIxFAST16 "hx" pollution: PRIxFAST32 #define PRIxFAST32 "x" pollution: PRIxFAST64 #define PRIxFAST64 "llx" pollution: PRIxFAST8 #define PRIxFAST8 "hhx" pollution: PRIxLEAST16 #define PRIxLEAST16 "hx" pollution: PRIxLEAST32 #define PRIxLEAST32 "x" pollution: PRIxLEAST64 #define PRIxLEAST64 "llx" pollution: PRIxLEAST8 #define PRIxLEAST8 "hhx" pollution: PRIxMAX #define PRIxMAX "llx" pollution: PRIxPTR #define PRIxPTR "lx" pollution: PTHREAD_DATAKEYS_MAX #define PTHREAD_DATAKEYS_MAX PTHREAD_KEYS_MAX pollution: PTHREAD_DESTRUCTOR_ITERATIONS #define PTHREAD_DESTRUCTOR_ITERATIONS _POSIX_THREAD_DESTRUCTOR_ITERATIONS pollution: PTHREAD_KEYS_MAX #define PTHREAD_KEYS_MAX 450 pollution: PTHREAD_STACK_MIN #define PTHREAD_STACK_MIN ( PAGESIZE * 2 ) pollution: PTHREAD_THREADS_MAX #define PTHREAD_THREADS_MAX 512 pollution: PTRDIFF_MAX #define PTRDIFF_MAX (2147483647L) pollution: PTRDIFF_MIN #define PTRDIFF_MIN (-2147483647L-1) pollution: RAND_MAX #define RAND_MAX 32767 pollution: RE_DUP_MAX #define RE_DUP_MAX _POSIX2_RE_DUP_MAX pollution: RLIM64_INFINITY #define RLIM64_INFINITY (0x7fffffffffffffffLL) pollution: RLIMIT_AS #define RLIMIT_AS 6 pollution: RLIMIT_CORE #define RLIMIT_CORE 4 pollution: RLIMIT_CPU #define RLIMIT_CPU 0 pollution: RLIMIT_DATA #define RLIMIT_DATA 2 pollution: RLIMIT_FSIZE #define RLIMIT_FSIZE 1 pollution: RLIMIT_NOFILE #define RLIMIT_NOFILE 7 pollution: RLIMIT_NPROC #define RLIMIT_NPROC 9 pollution: RLIMIT_RSS #define RLIMIT_RSS 5 pollution: RLIMIT_STACK #define RLIMIT_STACK 3 pollution: RLIMIT_THREADS #define RLIMIT_THREADS 8 pollution: RLIM_FSB_INFINITY #define RLIM_FSB_INFINITY 0xFFFFFFFFU pollution: RLIM_INFINITY #define RLIM_INFINITY 0x7FFFFFFF pollution: RLIM_NLIMITS #define RLIM_NLIMITS 10 pollution: RLIM_SAVED_CUR #define RLIM_SAVED_CUR (RLIM_INFINITY-2) pollution: RLIM_SAVED_MAX #define RLIM_SAVED_MAX (RLIM_INFINITY-1) pollution: RTSIG_MAX #define RTSIG_MAX _POSIX_RTSIG_MAX pollution: RUSAGE_ADD #define RUSAGE_ADD(_dest,_src1,_src2) (_dest)->ru_minflt = (_src1)->ru_minflt + (_src2)->ru_minflt; (_dest)->ru_majflt = (_src1)->ru_majflt + (_src2)->ru_majflt; (_dest)->ru_nswap = (_src1)->ru_nswap + (_src2)->ru_nswap; (_dest)->ru_nsignals = (_src1)->ru_nsignals + (_src2)->ru_nsignals; (_dest)->ru_nvcsw = (_src1)->ru_nvcsw + (_src2)->ru_nvcsw; (_dest)->ru_nivcsw = (_src1)->ru_nivcsw + (_src2)->ru_nivcsw; pollution: RUSAGE_CHILDREN #define RUSAGE_CHILDREN (-1) pollution: RUSAGE_SELF #define RUSAGE_SELF 0 pollution: RUSAGE_SUB #define RUSAGE_SUB(_dest,_src1,_src2) (_dest)->ru_minflt = (_src1)->ru_minflt - (_src2)->ru_minflt; (_dest)->ru_majflt = (_src1)->ru_majflt - (_src2)->ru_majflt; (_dest)->ru_nswap = (_src1)->ru_nswap - (_src2)->ru_nswap; (_dest)->ru_nsignals = (_src1)->ru_nsignals - (_src2)->ru_nsignals; (_dest)->ru_nvcsw = (_src1)->ru_nvcsw - (_src2)->ru_nvcsw; (_dest)->ru_nivcsw = (_src1)->ru_nivcsw - (_src2)->ru_nivcsw; pollution: RUSAGE_THREAD #define RUSAGE_THREAD 1 pollution: RUSAGE_TIMES #define RUSAGE_TIMES 2 pollution: SA_FULLDUMP #define SA_FULLDUMP 0x00000040 pollution: SA_NOCLDSTOP #define SA_NOCLDSTOP 0x00000004 pollution: SA_NOCLDWAIT #define SA_NOCLDWAIT 0x00000400 pollution: SA_NODEFER #define SA_NODEFER 0x00000200 pollution: SA_NODUMP #define SA_NODUMP 0x00000010 pollution: SA_OLDSTYLE #define SA_OLDSTYLE SA_RESETHAND pollution: SA_ONSTACK #define SA_ONSTACK 0x00000001 pollution: SA_PARTDUMP #define SA_PARTDUMP 0x00000020 pollution: SA_RESETHAND #define SA_RESETHAND 0x00000002 pollution: SA_RESTART #define SA_RESTART 0x00000008 pollution: SA_SIGINFO #define SA_SIGINFO 0x00000100 pollution: SA_SIGSETSTYLE #define SA_SIGSETSTYLE 0x00000080 pollution: SCHAR_MAX #define SCHAR_MAX (127) pollution: SCHAR_MIN #define SCHAR_MIN (-SCHAR_MAX - 1) pollution: SCNd16 #define SCNd16 "hd" pollution: SCNd32 #define SCNd32 "d" pollution: SCNd64 #define SCNd64 "lld" pollution: SCNd8 #define SCNd8 "hhd" pollution: SCNdFAST #define SCNdFAST "d" pollution: SCNdFAST16 #define SCNdFAST16 "hd" pollution: SCNdFAST32 #define SCNdFAST32 "d" pollution: SCNdFAST64 #define SCNdFAST64 "lld" pollution: SCNdFAST8 #define SCNdFAST8 "hhd" pollution: SCNdLEAST16 #define SCNdLEAST16 "hd" pollution: SCNdLEAST32 #define SCNdLEAST32 "d" pollution: SCNdLEAST64 #define SCNdLEAST64 "lld" pollution: SCNdLEAST8 #define SCNdLEAST8 "hhd" pollution: SCNdMAX #define SCNdMAX "lld" pollution: SCNdPTR #define SCNdPTR "ld" pollution: SCNi16 #define SCNi16 "hi" pollution: SCNi32 #define SCNi32 "i" pollution: SCNi64 #define SCNi64 "lli" pollution: SCNi8 #define SCNi8 "hhi" pollution: SCNiFAST16 #define SCNiFAST16 "hi" pollution: SCNiFAST32 #define SCNiFAST32 "i" pollution: SCNiFAST64 #define SCNiFAST64 "lli" pollution: SCNiFAST8 #define SCNiFAST8 "hhi" pollution: SCNiLEAST16 #define SCNiLEAST16 "hi" pollution: SCNiLEAST32 #define SCNiLEAST32 "i" pollution: SCNiLEAST64 #define SCNiLEAST64 "lli" pollution: SCNiLEAST8 #define SCNiLEAST8 "hhi" pollution: SCNiMAX #define SCNiMAX "lld" pollution: SCNiPTR #define SCNiPTR "ld" pollution: SCNo16 #define SCNo16 "ho" pollution: SCNo32 #define SCNo32 "o" pollution: SCNo64 #define SCNo64 "llo" pollution: SCNo8 #define SCNo8 "hho" pollution: SCNoFAST #define SCNoFAST "o" pollution: SCNoFAST16 #define SCNoFAST16 "ho" pollution: SCNoFAST32 #define SCNoFAST32 "o" pollution: SCNoFAST64 #define SCNoFAST64 "llo" pollution: SCNoFAST8 #define SCNoFAST8 "hho" pollution: SCNoLEAST16 #define SCNoLEAST16 "ho" pollution: SCNoLEAST32 #define SCNoLEAST32 "o" pollution: SCNoLEAST64 #define SCNoLEAST64 "llo" pollution: SCNoLEAST8 #define SCNoLEAST8 "hho" pollution: SCNoMAX #define SCNoMAX "llo" pollution: SCNoPTR #define SCNoPTR "lo" pollution: SCNu16 #define SCNu16 "hu" pollution: SCNu32 #define SCNu32 "u" pollution: SCNu64 #define SCNu64 "llu" pollution: SCNu8 #define SCNu8 "hhu" pollution: SCNuFAST #define SCNuFAST "u" pollution: SCNuFAST16 #define SCNuFAST16 "hu" pollution: SCNuFAST32 #define SCNuFAST32 "u" pollution: SCNuFAST64 #define SCNuFAST64 "llu" pollution: SCNuFAST8 #define SCNuFAST8 "hhu" pollution: SCNuLEAST16 #define SCNuLEAST16 "hu" pollution: SCNuLEAST32 #define SCNuLEAST32 "u" pollution: SCNuLEAST64 #define SCNuLEAST64 "llu" pollution: SCNuLEAST8 #define SCNuLEAST8 "hhu" pollution: SCNuMAX #define SCNuMAX "llu" pollution: SCNuPTR #define SCNuPTR "lu" pollution: SCNx16 #define SCNx16 "hx" pollution: SCNx32 #define SCNx32 "x" pollution: SCNx64 #define SCNx64 "llx" pollution: SCNx8 #define SCNx8 "hhx" pollution: SCNxFAST #define SCNxFAST "x" pollution: SCNxFAST16 #define SCNxFAST16 "hx" pollution: SCNxFAST32 #define SCNxFAST32 "x" pollution: SCNxFAST64 #define SCNxFAST64 "llx" pollution: SCNxFAST8 #define SCNxFAST8 "hhx" pollution: SCNxLEAST16 #define SCNxLEAST16 "hx" pollution: SCNxLEAST32 #define SCNxLEAST32 "x" pollution: SCNxLEAST64 #define SCNxLEAST64 "llx" pollution: SCNxLEAST8 #define SCNxLEAST8 "hhx" pollution: SCNxMAX #define SCNxMAX "llx" pollution: SCNxPTR #define SCNxPTR "lx" pollution: SEGV_ACCERR #define SEGV_ACCERR 51 pollution: SEGV_KEYERR #define SEGV_KEYERR 52 pollution: SEGV_MAPERR #define SEGV_MAPERR 50 pollution: SEM_NSEMS_MAX #define SEM_NSEMS_MAX 32768 pollution: SEM_VALUE_MAX #define SEM_VALUE_MAX _POSIX_SEM_VALUE_MAX pollution: SHRT_MAX #define SHRT_MAX (32767) pollution: SHRT_MIN #define SHRT_MIN (-SHRT_MAX - 1) pollution: SIGABRT #define SIGABRT 6 pollution: SIGADDSET #define SIGADDSET(__set,__s) {*((&(__set).losigs)+(((__s)-1)/32)) |= (1<<(((__s)-1)%32));} pollution: SIGADDSET32 #define SIGADDSET32(__set,__s) {*((&(__set).losigs)+(((__s)-1)/32)) |= (1<<(((__s)-1)%32));} pollution: SIGADDSET64 #define SIGADDSET64(__set,__s) {*((__set).ss_set+(((__s)-1)/64)) |= (1ULL<<(((__s)-1)%64));} pollution: SIGAIO #define SIGAIO SIGIO pollution: SIGALRM #define SIGALRM 14 pollution: SIGALRM1 #define SIGALRM1 38 pollution: SIGANDSET #define SIGANDSET(__dest,__m1,__m2) { (__dest).losigs = (__m1).losigs & (__m2).losigs; (__dest).hisigs = (__m1).hisigs & (__m2).hisigs; } pollution: SIGANDSET32 #define SIGANDSET32(__dest,__m1,__m2) { (__dest).losigs = (__m1).losigs & (__m2).losigs; (__dest).hisigs = (__m1).hisigs & (__m2).hisigs; } pollution: SIGANDSET64 #define SIGANDSET64(__dest,__m1,__m2) { *(__dest).ss_set = *(__m1).ss_set & *(__m2).ss_set; *((__dest).ss_set + 1) = *((__m1).ss_set + 1) & *((__m2).ss_set + 1); *((__dest).ss_set + 2) = *((__m1).ss_set + 2) & *((__m2).ss_set + 2); *((__dest).ss_set + 3) = *((__m1).ss_set + 3) & *((__m2).ss_set + 3); } pollution: SIGBUS #define SIGBUS 10 pollution: SIGCAPI #define SIGCAPI 49 pollution: SIGCHLD #define SIGCHLD 20 pollution: SIGCLD #define SIGCLD SIGCHLD pollution: SIGCONT #define SIGCONT 19 pollution: SIGCPUFAIL #define SIGCPUFAIL 59 pollution: SIGDANGER #define SIGDANGER 33 pollution: SIGDELSET #define SIGDELSET(__set,__s) {*((&(__set).losigs)+(((__s)-1)/32)) &= ~(1<<(((__s)-1)%32));} pollution: SIGDELSET32 #define SIGDELSET32(__set,__s) {*((&(__set).losigs)+(((__s)-1)/32)) &= ~(1<<(((__s)-1)%32));} pollution: SIGDELSET64 #define SIGDELSET64(__set,__s) {*((__set).ss_set+(((__s)-1)/64)) &= ~(1ULL<<(((__s)-1)%64));} pollution: SIGEMT #define SIGEMT 7 pollution: SIGEV_NONE #define SIGEV_NONE 1 pollution: SIGEV_SIGNAL #define SIGEV_SIGNAL 2 pollution: SIGEV_THREAD #define SIGEV_THREAD 3 pollution: SIGFILLSET #define SIGFILLSET(__set) { (__set).losigs = ~0; (__set).hisigs = ~0; } pollution: SIGFILLSET32 #define SIGFILLSET32(__set) { (__set).losigs = ~0; (__set).hisigs = ~0; } pollution: SIGFILLSET64 #define SIGFILLSET64(__set) { *(__set).ss_set = ~(0ULL); *((__set).ss_set + 1) = ~(0ULL); *((__set).ss_set + 2) = ~(0ULL); *((__set).ss_set + 3) = ~(0ULL); } pollution: SIGFPE #define SIGFPE 8 pollution: SIGGRANT #define SIGGRANT SIGKAP pollution: SIGHUP #define SIGHUP 1 pollution: SIGILL #define SIGILL 4 pollution: SIGINITSET #define SIGINITSET(__set) { (__set).losigs = 0; (__set).hisigs = 0; } pollution: SIGINITSET32 #define SIGINITSET32(__set) { (__set).losigs = 0; (__set).hisigs = 0; } pollution: SIGINITSET64 #define SIGINITSET64(__set) { *(__set).ss_set = 0ULL; *((__set).ss_set + 1) = 0ULL; *((__set).ss_set + 2) = 0ULL; *((__set).ss_set + 3) = 0ULL; } pollution: SIGINT #define SIGINT 2 pollution: SIGIO #define SIGIO 23 pollution: SIGIOINT #define SIGIOINT SIGURG pollution: SIGIOT #define SIGIOT SIGABRT pollution: SIGISMEMBER #define SIGISMEMBER(__set,__s) ( (*((&(__set).losigs)+(((__s)-1)/32)) >> (((__s)-1)%32) ) & 1 ) pollution: SIGISMEMBER32 #define SIGISMEMBER32(__set,__s) ( (*((&(__set).losigs)+(((__s)-1)/32)) >> (((__s)-1)%32) ) & 1 ) pollution: SIGISMEMBER64 #define SIGISMEMBER64(__set,__s) ((*((__set).ss_set+(((__s)-1)/64)) >> (((__s)-1)%64))&1ULL) pollution: SIGKAP #define SIGKAP 60 pollution: SIGKILL #define SIGKILL 9 pollution: SIGLOST #define SIGLOST SIGIOT pollution: SIGMASK #define SIGMASK(__s) (1<<(((__s)-1)%32)) pollution: SIGMASK32 #define SIGMASK32(__s) (1<<(((__s)-1)%32)) pollution: SIGMASKHI #define SIGMASKHI(__s) ( 1 << (((__s)-32) - 1) ) pollution: SIGMASKHI32 #define SIGMASKHI32(__s) ( 1 << (((__s)-32) - 1) ) pollution: SIGMASKLO #define SIGMASKLO(__s) ( 1 << ((__s) - 1) ) pollution: SIGMASKLO32 #define SIGMASKLO32(__s) ( 1 << ((__s) - 1) ) pollution: SIGMASKSET #define SIGMASKSET(__dest,__mask) { (__dest).losigs &= ~(__mask).losigs; (__dest).hisigs &= ~(__mask).hisigs; } pollution: SIGMASKSET32 #define SIGMASKSET32(__dest,__mask) { (__dest).losigs &= ~(__mask).losigs; (__dest).hisigs &= ~(__mask).hisigs; } pollution: SIGMASKSET64 #define SIGMASKSET64(__dest,__mask) { *(__dest).ss_set &= ~*(__mask).ss_set; *((__dest).ss_set + 1) &= ~*((__mask).ss_set + 1); *((__dest).ss_set + 2) &= ~*((__mask).ss_set + 2); *((__dest).ss_set + 3) &= ~*((__mask).ss_set + 3); } pollution: SIGMAX #define SIGMAX SIGMAX32 pollution: SIGMAX32 #define SIGMAX32 63 pollution: SIGMAX64 #define SIGMAX64 255 pollution: SIGMIGRATE #define SIGMIGRATE 35 pollution: SIGMSG #define SIGMSG 27 pollution: SIGORSET #define SIGORSET(__dest,__mask) { (__dest).losigs |= (__mask).losigs; (__dest).hisigs |= (__mask).hisigs; } pollution: SIGORSET32 #define SIGORSET32(__dest,__mask) { (__dest).losigs |= (__mask).losigs; (__dest).hisigs |= (__mask).hisigs; } pollution: SIGORSET64 #define SIGORSET64(__dest,__mask) { *(__dest).ss_set |= *(__mask).ss_set; *((__dest).ss_set + 1) |= *((__mask).ss_set + 1); *((__dest).ss_set + 2) |= *((__mask).ss_set + 2); *((__dest).ss_set + 3) |= *((__mask).ss_set + 3); } pollution: SIGPIPE #define SIGPIPE 13 pollution: SIGPOLL #define SIGPOLL SIGIO pollution: SIGPRE #define SIGPRE 36 pollution: SIGPROF #define SIGPROF 32 pollution: SIGPTY #define SIGPTY SIGIO pollution: SIGPWR #define SIGPWR 29 pollution: SIGQUEUE_MAX #define SIGQUEUE_MAX _POSIX_SIGQUEUE_MAX pollution: SIGQUIT #define SIGQUIT 3 pollution: SIGRECONFIG #define SIGRECONFIG 58 pollution: SIGRETRACT #define SIGRETRACT 61 pollution: SIGRTMAX #define SIGRTMAX 57 pollution: SIGRTMIN #define SIGRTMIN 50 pollution: SIGSAK #define SIGSAK 63 pollution: SIGSEGV #define SIGSEGV 11 pollution: SIGSETEMPTY #define SIGSETEMPTY(__set) (!((__set).losigs) && !((__set).hisigs)) pollution: SIGSETEMPTY32 #define SIGSETEMPTY32(__set) (!((__set).losigs) && !((__set).hisigs)) pollution: SIGSETEMPTY64 #define SIGSETEMPTY64(__set) (!*(__set).ss_set && !*((__set).ss_set + 1) && !*((__set).ss_set + 2) && !*((__set).ss_set + 3)) pollution: SIGSETTOLLONG #define SIGSETTOLLONG(__set,__ll) { *(int *)&(__ll) = (__set).hisigs; *((int *)&(__ll)+1) = (__set).losigs; } pollution: SIGSOUND #define SIGSOUND 62 pollution: SIGSTKSZ #define SIGSTKSZ 4096 pollution: SIGSTOP #define SIGSTOP 17 pollution: SIGSYS #define SIGSYS 12 pollution: SIGSYSERROR #define SIGSYSERROR 48 pollution: SIGTALRM #define SIGTALRM 38 pollution: SIGTERM #define SIGTERM 15 pollution: SIGTRAP #define SIGTRAP 5 pollution: SIGTSTP #define SIGTSTP 18 pollution: SIGTTIN #define SIGTTIN 21 pollution: SIGTTOU #define SIGTTOU 22 pollution: SIGURG #define SIGURG 16 pollution: SIGUSR1 #define SIGUSR1 30 pollution: SIGUSR2 #define SIGUSR2 31 pollution: SIGVIRT #define SIGVIRT 37 pollution: SIGVTALRM #define SIGVTALRM 34 pollution: SIGWAITING #define SIGWAITING 39 pollution: SIGWINCH #define SIGWINCH 28 pollution: SIGXCPU #define SIGXCPU 24 pollution: SIGXFSZ #define SIGXFSZ 25 pollution: SIG_ATOMIC_MAX #define SIG_ATOMIC_MAX INT32_MAX pollution: SIG_ATOMIC_MIN #define SIG_ATOMIC_MIN INT32_MIN pollution: SIG_BLOCK #define SIG_BLOCK 0 pollution: SIG_CATCH #define SIG_CATCH ((void (*)(int))3) pollution: SIG_DFL #define SIG_DFL ((void (*)(int))0) pollution: SIG_ERR #define SIG_ERR ((void (*)(int))-1) pollution: SIG_HOLD #define SIG_HOLD ((void (*)(int))2) pollution: SIG_IGN #define SIG_IGN ((void (*)(int))1) pollution: SIG_PENDING #define SIG_PENDING(__p) (( (__p)->p_sig.losigs & ~((__p)->p_sigignore.losigs | (__p)->p_sigmask.losigs) ) || ( (__p)->p_sig.hisigs & ~((__p)->p_sigignore.hisigs | (__p)->p_sigmask.hisigs) )) pollution: SIG_PENDING32 #define SIG_PENDING32(__p) (( (__p)->p_sig.losigs & ~((__p)->p_sigignore.losigs | (__p)->p_sigmask.losigs) ) || ( (__p)->p_sig.hisigs & ~((__p)->p_sigignore.hisigs | (__p)->p_sigmask.hisigs) )) pollution: SIG_PENDING64 #define SIG_PENDING64(__p) (( *(__p)->p_sig & ~(*(__p)->p_sigignore.ss_set | *(__p)->p_sigmask.ss_set) ) || ( *((__p)->p_sig + 1) & ~(*((__p)->p_sigignore.ss_set + 1) | *((__p)->p_sigmask.ss_set + 1))) || ( *((__p)->p_sig + 2) & ~(*((__p)->p_sigignore.ss_set + 2) | *((__p)->p_sigmask.ss_set + 2))) || ( *((__p)->p_sig + 3) & ~(*((__p)->p_sigignore.ss_set + 3) | *((__p)->p_sigmask.ss_set + 3))) ) pollution: SIG_SETMASK #define SIG_SETMASK 2 pollution: SIG_STD #define SIG_STD SA_OLDSTYLE pollution: SIG_STK #define SIG_STK SA_ONSTACK pollution: SIG_UNBLOCK #define SIG_UNBLOCK 1 pollution: SING #define SING 02 pollution: SIZE_MAX #define SIZE_MAX (4294967295UL) pollution: SI_ASYNCIO #define SI_ASYNCIO 73 pollution: SI_EMPTY #define SI_EMPTY 9 pollution: SI_FAST_WATCH #define SI_FAST_WATCH 2 pollution: SI_MESGQ #define SI_MESGQ 74 pollution: SI_QUEUE #define SI_QUEUE 71 pollution: SI_TIMER #define SI_TIMER 72 pollution: SI_UNDEFINED #define SI_UNDEFINED 8 pollution: SI_USER #define SI_USER 0 pollution: SI_WPDABR #define SI_WPDABR 1 pollution: SI_WP_SYSCALL #define SI_WP_SYSCALL 3 pollution: SLB_SAVE_SIZE #define SLB_SAVE_SIZE _SLB_SAVE_SIZE pollution: SSIZE_MAX #define SSIZE_MAX LONG_MAX pollution: SS_DISABLE #define SS_DISABLE 0x00000002 pollution: SS_ONSTACK #define SS_ONSTACK 0x00000001 pollution: STORWCS #define STORWCS _STORWCS pollution: STREAM_MAX #define STREAM_MAX 32767 pollution: SV_INTERRUPT #define SV_INTERRUPT SA_RESTART pollution: SV_ONSTACK #define SV_ONSTACK SA_ONSTACK pollution: SYMLOOP_MAX #define SYMLOOP_MAX 20 pollution: TIMEBASE_SZ #define TIMEBASE_SZ (sizeof (struct timebasestruct)) pollution: TIMEOFDAY #define TIMEOFDAY 9 pollution: TIMERID_ALRM #define TIMERID_ALRM (ITIMER_REAL) pollution: TIMERID_PROF #define TIMERID_PROF (ITIMER_PROF) pollution: TIMERID_REAL #define TIMERID_REAL (ITIMER_REAL) pollution: TIMERID_REAL1 #define TIMERID_REAL1 (ITIMER_REAL1) pollution: TIMERID_REAL_TH #define TIMERID_REAL_TH TIMERID_REAL1 pollution: TIMERID_TOD #define TIMERID_TOD (TIMERID_VIRT+1) pollution: TIMERID_VIRT #define TIMERID_VIRT (ITIMER_VIRT) pollution: TIMERID_VIRTUAL #define TIMERID_VIRTUAL (ITIMER_VIRTUAL) pollution: TIMER_MAX #define TIMER_MAX _POSIX_TIMER_MAX pollution: TLOSS #define TLOSS 05 pollution: TMP_MAX #define TMP_MAX 16384 pollution: TOT_USER_SIG #define TOT_USER_SIG (MAXSIG - MINSIG + 1) pollution: TRACE_EVENT_NAME_MAX #define TRACE_EVENT_NAME_MAX 255 pollution: TRACE_NAME_MAX #define TRACE_NAME_MAX 255 pollution: TRACE_SYS_MAX #define TRACE_SYS_MAX 64 pollution: TRACE_USER_EVENT_MAX #define TRACE_USER_EVENT_MAX 56 pollution: TRAP_BRKPT #define TRAP_BRKPT 60 pollution: TRAP_TRACE #define TRAP_TRACE 61 pollution: TRUE #define TRUE 1 pollution: TTY_NAME_MAX #define TTY_NAME_MAX PATH_MAX pollution: TZNAME_MAX #define TZNAME_MAX 255 pollution: UCHAR_MAX #define UCHAR_MAX (255) pollution: UID_MAX #define UID_MAX UINT_MAX pollution: UINT16_C #define UINT16_C(c) c pollution: UINT16_MAX #define UINT16_MAX (65535) pollution: UINT32_C #define UINT32_C(c) __CONCAT__(c,U) pollution: UINT32_MAX #define UINT32_MAX (4294967295U) pollution: UINT64_C #define UINT64_C(c) __CONCAT__(c,ULL) pollution: UINT64_MAX #define UINT64_MAX (UINT64_C(18446744073709551615)) pollution: UINT8_C #define UINT8_C(c) c pollution: UINT8_MAX #define UINT8_MAX (255) pollution: UINTFAST_MAX #define UINTFAST_MAX UINT32_MAX pollution: UINTMAX_C #define UINTMAX_C(c) __CONCAT__(c,ULL) pollution: UINTMAX_MAX #define UINTMAX_MAX UINT64_MAX pollution: UINTPTR_MAX #define UINTPTR_MAX (4294967295UL) pollution: UINT_FAST16_MAX #define UINT_FAST16_MAX UINT16_MAX pollution: UINT_FAST32_MAX #define UINT_FAST32_MAX UINT32_MAX pollution: UINT_FAST64_MAX #define UINT_FAST64_MAX UINT64_MAX pollution: UINT_FAST8_MAX #define UINT_FAST8_MAX UINT8_MAX pollution: UINT_LEAST16_MAX #define UINT_LEAST16_MAX UINT16_MAX pollution: UINT_LEAST32_MAX #define UINT_LEAST32_MAX UINT32_MAX pollution: UINT_LEAST64_MAX #define UINT_LEAST64_MAX UINT64_MAX pollution: UINT_LEAST8_MAX #define UINT_LEAST8_MAX UINT8_MAX pollution: UINT_MAX #define UINT_MAX (4294967295U) pollution: ULLONG_MAX #define ULLONG_MAX (18446744073709551615ULL) pollution: ULONGLONG_MAX #define ULONGLONG_MAX (0xffffffffffffffffuLL) pollution: ULONG_MAX #define ULONG_MAX (4294967295UL) pollution: UNDERFLOW #define UNDERFLOW 04 pollution: USE_SAVE_AREA #define USE_SAVE_AREA 0x0002 pollution: USHRT_MAX #define USHRT_MAX (65535) pollution: WCHAR_MAX #define WCHAR_MAX UINT16_MAX pollution: WCHAR_MIN #define WCHAR_MIN 0 pollution: WCONTINUED #define WCONTINUED 0x01000000 pollution: WEXITED #define WEXITED 0x04 pollution: WEXITSTATUS #define WEXITSTATUS(__x) (int)(WIFEXITED(__x) ? (int)((((unsigned int)(__x)) >> 8) & 0xff) : -1) pollution: WIFCONTINUED #define WIFCONTINUED(__x) ((__x) & WCONTINUED) pollution: WIFEXITED #define WIFEXITED(__x) (!((__x) & 0xff)) pollution: WIFSIGNALED #define WIFSIGNALED(__x) (!WIFEXITED(__x) && !WIFSTOPPED(__x) && !WIFCONTINUED(__x)) pollution: WIFSTOPPED #define WIFSTOPPED(__x) ((__x) & _W_STOPPED) pollution: WINT_MAX #define WINT_MAX INT32_MAX pollution: WINT_MIN #define WINT_MIN INT32_MIN pollution: WNOHANG #define WNOHANG 0x1 pollution: WNOWAIT #define WNOWAIT 0x10 pollution: WORD_BIT #define WORD_BIT 32 pollution: WSTOPPED #define WSTOPPED _W_STOPPED pollution: WSTOPSIG #define WSTOPSIG(__x) (int)(WIFSTOPPED(__x) ? (int)((((unsigned int)(__x)) >> 8) & 0xff) : -1) pollution: WTERMSIG #define WTERMSIG(__x) (int)(WIFSIGNALED(__x) ? (int)((((unsigned int)(__x)) >> 16) & 0xff) : -1) pollution: WUNTRACED #define WUNTRACED 0x2 pollution: W_SEWTED #define W_SEWTED _W_SEWTED pollution: W_SFWTED #define W_SFWTED _W_SFWTED pollution: W_SLWTED #define W_SLWTED _W_SLWTED pollution: W_STOPPED #define W_STOPPED _W_STOPPED pollution: W_STRC #define W_STRC _W_STRC pollution: adsp_is_alloc #define adsp_is_alloc(_a,_x) ((_a)->alloc & ADSP_MASK(_x)) pollution: calloc #define calloc vec_calloc pollution: context64 #define context64 __context64 pollution: fh_dev #define fh_dev fh_fsid.fsid_dev pollution: fh_gen #define fh_gen fh_fid.fid_gen pollution: fh_ino #define fh_ino fh_fid.fid_ino pollution: fh_len #define fh_len fh_fid.fid_len pollution: fh_type #define fh_type fh_fsid.fsid_type pollution: fsid_dev #define fsid_dev val[0] pollution: fsid_type #define fsid_type val[1] pollution: hz #define hz __hz pollution: jmpbuf #define jmpbuf __jmpbuf pollution: lgammal_r #define lgammal_r(__x,__y) lgamma_r((double) (__x), (__y)) pollution: malloc #define malloc vec_malloc pollution: ntimeradd #define ntimeradd(tvp,svp,rvp) { (rvp).tv_sec = (tvp).tv_sec + (svp).tv_sec; (rvp).tv_nsec = (tvp).tv_nsec + (svp).tv_nsec; if((rvp).tv_nsec > (NS_PER_SEC - 1)) { (rvp).tv_nsec -= NS_PER_SEC; (rvp).tv_sec++; } assert((rvp).tv_nsec <= NS_PER_SEC); } pollution: ntimerclear #define ntimerclear(tvp) (tvp)->tv_sec = (tvp)->tv_nsec = 0 pollution: ntimercmp #define ntimercmp(tvp,fvp,cmp) ((tvp).tv_sec cmp (fvp).tv_sec || (tvp).tv_sec == (fvp).tv_sec && (tvp).tv_nsec cmp (fvp).tv_nsec) pollution: ntimerisset #define ntimerisset(tvp) ((tvp)->tv_sec || (tvp)->tv_nsec) pollution: ntimersub #define ntimersub(tvp,svp,rvp) { assert((tvp).tv_nsec <= NS_PER_SEC); assert((svp).tv_nsec <= NS_PER_SEC); assert(!((tvp).tv_sec == 0 && ((svp).tv_nsec > (tvp).tv_nsec))); if((tvp).tv_sec == (svp).tv_sec) { assert((tvp).tv_nsec >= (svp).tv_nsec); } else { assert((tvp).tv_sec > (svp).tv_sec); } if((svp).tv_nsec > (tvp).tv_nsec) { assert((tvp).tv_sec > (svp).tv_sec); (rvp).tv_sec = ((tvp).tv_sec - 1) - (svp).tv_sec; (rvp).tv_nsec = ((int)(((uint)((tvp).tv_nsec) + NS_PER_SEC) - (uint)((svp).tv_nsec))); } else { (rvp).tv_sec = (tvp).tv_sec - (svp).tv_sec; (rvp).tv_nsec = (tvp).tv_nsec - (svp).tv_nsec; } assert((tvp).tv_nsec <= NS_PER_SEC); assert((svp).tv_nsec <= NS_PER_SEC); assert((rvp).tv_nsec <= NS_PER_SEC); } pollution: pmap_stack #define pmap_stack __pmap_stack pollution: ru_first #define ru_first ru_ixrss pollution: ru_last #define ru_last ru_nivcsw pollution: sa_handler #define sa_handler sa_union.__su_handler pollution: sa_sigaction #define sa_sigaction sa_union.__su_sigaction pollution: sigcontext #define sigcontext __sigcontext pollution: sigmask #define sigmask(__m) (1 << ((__m)-1)) pollution: sv_handler #define sv_handler sv_union.sv_handler pollution: sv_onstack #define sv_onstack sv_flags pollution: sv_sigaction #define sv_sigaction sv_union.sv_sigaction pollution: timerclear #define timerclear(tvp) (tvp)->tv_sec = (tvp)->tv_usec = 0 pollution: timercmp #define timercmp(tvp,fvp,cmp) ((tvp)->tv_sec cmp (fvp)->tv_sec || (tvp)->tv_sec == (fvp)->tv_sec && (tvp)->tv_usec cmp (fvp)->tv_usec) pollution: timerisset #define timerisset(tvp) ((tvp)->tv_sec || (tvp)->tv_usec) pollution: uS_PER_SEC #define uS_PER_SEC (NS_PER_SEC / 1000) pollution: uS_PER_SECOND #define uS_PER_SECOND (1000000) pollution: vec_free #define vec_free free pollution: vec_realloc #define vec_realloc realloc