cppcheck/cfg/posix.cfg

<?xml version="1.0"?>
<def format="2">
  <!-- http://man7.org/linux/man-pages/man3/a64l.3.html -->
  <!-- long a64l(const char *str64); -->
  <function name="a64l">
    <use-retval/>
    <returnValue type="long"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man3/a64l.3.html -->
  <!-- char *l64a(long value); -->
  <function name="l64a">
    <use-retval/>
    <returnValue type="char *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
      <!-- The behavior of l64a() is undefined when value is negative. -->
      <!-- If value is zero, it returns an empty string. -->
      <valid>0:</valid>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man2/accept.2.html -->
  <!-- int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen); -->
  <function name="accept">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://pubs.opengroup.org/onlinepubs/9699919799/functions/access.html -->
  <!-- int access(const char *pathname, int amode); -->
  <function name="access">
    <use-retval/>
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
      <not-null/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man3/adjtime.3.html -->
  <!-- int adjtime(const struct timeval *delta, struct timeval *olddelta); -->
  <function name="adjtime">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-bool/>
    </arg>
  </function>
  <resource>
    <alloc>dlopen</alloc>
    <dealloc>dlclose</dealloc>
  </resource>
  <!-- see http://pubs.opengroup.org/onlinepubs/9699919799/functions/dlopen.html -->
  <function name="dlopen">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="void*"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- see http://pubs.opengroup.org/onlinepubs/9699919799/functions/dlsym.html -->
  <function name="dlsym">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <use-retval/>
    <returnValue type="void*"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
  </function>
  <!-- see http://pubs.opengroup.org/onlinepubs/9699919799/functions/dlclose.html -->
  <function name="dlclose">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
  </function>
  <!-- int gettimeofday(struct timeval *tv, struct timezone *tz); -->
  <function name="gettimeofday">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <leak-ignore/>
    <arg nr="1"/>
    <arg nr="2">
      <not-bool/>
    </arg>
  </function>
  <!-- int settimeofday(const struct timeval *tv, const struct timezone *tz); -->
  <function name="settimeofday">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- void FD_CLR(int fd, fd_set *set); -->
  <function name="FD_CLR">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
    </arg>
  </function>
  <!-- int FD_ISSET(int fd, fd_set *set); -->
  <function name="FD_ISSET">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- void FD_SET(int fd, fd_set *set); -->
  <function name="FD_SET">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
    </arg>
  </function>
  <!-- void FD_ZERO(fd_set *set);-->
  <function name="FD_ZERO">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
    </arg>
  </function>
  <!-- http://pubs.opengroup.org/onlinepubs/009695399/functions/fdatasync.html -->
  <!-- int fdatasync(int fildes); -->
  <function name="fdatasync">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://pubs.opengroup.org/onlinepubs/9699919799/functions/fnmatch.html -->
  <!-- int fnmatch(const char *pattern, const char *string, int flags); -->
  <function name="fnmatch">
    <pure/>
    <use-retval/>
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
      <not-null/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-null/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://pubs.opengroup.org/onlinepubs/009695399/functions/fsync.html -->
  <!-- int fsync(int fildes); -->
  <function name="fsync">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int truncate(const char *path, off_t length); -->
  <function name="truncate">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int ftruncate(int fd, off_t length); -->
  <function name="ftruncate">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int flock(int fd, int operation); -->
  <function name="flock">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int symlink(const char *oldpath, const char *newpath); -->
  <function name="symlink">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int open(const char *pathname, int flags) -->
  <!-- int open(const char *pathname, int flags, mode_t mode); -->
  <function name="open">
    <!-- TODO: add use-retval when cppcheck suppresses redundant messages
    because of violations to alloc/dealloc and use-retval configuration-->
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
    <arg nr="3" default="0">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int creat(const char *pathname, mode_t mode); -->
  <function name="creat">
    <use-retval/>
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- unsigned int sleep(unsigned int seconds); -->
  <function name="sleep">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="unsigned int"/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
      <valid>0:</valid>
    </arg>
  </function>
  <!-- int usleep(useconds_t useconds); -->
  <function name="usleep">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <leak-ignore/>
    <arg nr="1">
      <not-bool/>
      <valid>0:999999</valid>
    </arg>
    <warn severity="style">Obsolescent function 'usleep' called. It is recommended to use 'nanosleep' or 'setitimer' instead.
The obsolescent function 'usleep' is called. POSIX.1-2001 declares usleep() function obsolescent and POSIX.1-2008 removes it. It is recommended that new applications use the 'nanosleep' or 'setitimer' function.</warn>
  </function>
  <!-- void _exit(int status); -->
  <function name="_exit">
    <noreturn>true</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man2/access.2.html -->
  <!-- int faccessat(int dirfd, const char *pathname, int mode, int flags); -->
  <function name="faccessat">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
    </arg>
    <arg nr="4">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man2/acct.2.html -->
  <!-- int acct(const char *filename); -->
  <function name="acct">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man2/alarm.2.html -->
  <!-- unsigned int alarm(unsigned int seconds); -->
  <function name="alarm">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="unsigned int"/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
      <valid>0:</valid>
    </arg>
  </function>
  <!-- struct rpcent *getrpcent(void); -->
  <function name="getrpcent">
    <use-retval/>
    <returnValue type="struct rpcent *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <warn severity="portability">Non reentrant function 'getrpcent' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getrpcent_r'.</warn>
  </function>
  <!-- struct rpcent *getrpcbyname(char *name); -->
  <function name="getrpcbyname">
    <use-retval/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="struct rpcent *"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'getrpcbyname' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getrpcbyname_r'.</warn>
  </function>
  <!-- struct rpcent *getrpcbynumber(int number); -->
  <function name="getrpcbynumber">
    <use-retval/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="struct rpcent *"/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'getrpcbynumber' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getrpcbynumber_r'.</warn>
  </function>
  <!-- struct protoent *getprotoent(void); -->
  <function name="getprotoent">
    <use-retval/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="struct protoent *"/>
    <warn severity="portability">Non reentrant function 'getprotoent' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getprotoent_r'.</warn>
  </function>
  <!-- struct protoent *getprotobyname(const char *name); -->
  <function name="getprotobyname">
    <use-retval/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="struct protoent *"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'getprotobyname' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getprotobyname_r'.</warn>
  </function>
  <!-- struct protoent *getprotobynumber(int proto); -->
  <function name="getprotobynumber">
    <use-retval/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="struct protoent *"/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'getprotobynumber' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getprotobynumber_r'.</warn>
  </function>
  <!-- struct servent *getservent(void); -->
  <function name="getservent">
    <use-retval/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="struct servent *"/>
    <warn severity="portability">Non reentrant function 'getservent' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getservent_r'.</warn>
  </function>
  <!-- struct servent *getservbyname(const char *name, const char *proto); -->
  <function name="getservbyname">
    <use-retval/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="struct servent *"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'getservbyname' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getservbyname_r'.</warn>
  </function>
  <!-- struct servent *getservbyport(int port, const char *proto); -->
  <function name="getservbyport">
    <use-retval/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="struct servent *"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'getservbyport' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getservbyport_r'.</warn>
  </function>
  <!-- struct netent  *getnetent(void); -->
  <function name="getnetent">
    <use-retval/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="struct netent *"/>
    <warn severity="portability">Non reentrant function 'getnetent' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getnetent_r'.</warn>
  </function>
  <!-- struct netent *getnetbyname(const char *name); -->
  <function name="getnetbyname">
    <use-retval/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="struct netent *"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'getnetbyname' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getnetbyname_r'.</warn>
  </function>
  <!-- struct netent *getnetbyaddr(uint32_t net, int type); -->
  <function name="getnetbyaddr">
    <use-retval/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="struct netent *"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'getnetbyaddr' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getnetbyaddr_r'.</warn>
  </function>
  <!-- struct hostent *gethostent(void); -->
  <function name="gethostent">
    <use-retval/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="struct hostent *"/>
    <warn severity="portability">Non reentrant function 'gethostent' called. For threadsafe applications it is recommended to use the reentrant replacement function 'gethostent_r'.</warn>
  </function>
  <!-- struct hostent *gethostbyname(const char *name); -->
  <function name="gethostbyname">
    <use-retval/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="struct hostent *"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="getaddrinfo"/>
  </function>
  <!-- struct hostent *gethostbyname2(const char *name, int af); -->
  <function name="gethostbyname2">
    <use-retval/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="struct hostent *"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'gethostbyname2' called. For threadsafe applications it is recommended to use the reentrant replacement function 'gethostbyname2_r'.</warn>
  </function>
  <!-- struct hostent *gethostbyaddr(const void *addr, socklen_t len, int type); -->
  <function name="gethostbyaddr">
    <use-retval/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="struct hostent *"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="getnameinfo"/>
  </function>
  <!-- int brk(void *addr); -->
  <function name="brk">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- void *sbrk(intptr_t incr);-->
  <function name="sbrk">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="void *"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
  </function>
  <!-- int closedir(DIR *dir); -->
  <function name="closedir">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- char *strfry(char *string); -->
  <function name="strfry">
    <noreturn>false</noreturn>
    <returnValue type="char *"/>
    <arg nr="1">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- char *strsep(char **stringp, const char *delim); -->
  <function name="strsep">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="char *"/>
    <arg nr="1">
      <not-uninit/>
      <not-null/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- char *strdup(const char *s); -->
  <function name="strdup">
    <noreturn>false</noreturn>
    <returnValue type="char *"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- char *strndup(const char *s, size_t n); -->
  <function name="strndup">
    <noreturn>false</noreturn>
    <returnValue type="char *"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
      <valid>0:</valid>
    </arg>
  </function>
  <!-- wchar_t *wcsdup(const wchar_t *s); -->
  <function name="wcsdup">
    <noreturn>false</noreturn>
    <returnValue type="wchar_t *"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int mkstemp(char *template); -->
  <function name="mkstemp">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- char *mkdtemp(char *template); -->
  <function name="mkdtemp">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="char *"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- char *mktemp(char *template); -->
  <function name="mktemp">
    <noreturn>false</noreturn>
    <returnValue type="char *"/>
    <leak-ignore/>
    <use-retval/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="warning">Obsolete function 'mktemp' called. It is recommended to use 'mkstemp' or 'mkdtemp' instead.
The function 'mktemp' is considered to be dangerous due to race conditions and some implementations generating only up to 26 different filenames out of each template. This function has been removed in POSIX.1-2008. Use 'mkstemp' or 'mkdtemp' instead.</warn>
  </function>
  <!-- char *getcwd(char *buf, size_t size); -->
  <function name="getcwd">
    <noreturn>false</noreturn>
    <returnValue type="char *"/>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
      <valid>0:</valid>
    </arg>
  </function>
  <!-- int mkdir(const char *pathname, mode_t mode); -->
  <function name="mkdir">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int rmdir(const char *pathname); -->
  <function name="rmdir">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int chdir(const char *path); -->
  <function name="chdir">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int chroot(const char *path); -->
  <function name="chroot">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int link(const char *oldpath, const char *newpath); -->
  <function name="link">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int unlink(const char *pathname); -->
  <function name="unlink">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int stat(const char *file_name, struct stat *buf); -->
  <function name="stat">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- int lstat(const char *file_name, struct stat *buf); -->
  <function name="lstat">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- int fstat(const char *file_name, struct stat *buf); -->
  <function name="fstat">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- int chmod(const char *path, mode_t mode); -->
  <function name="chmod">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int fchmod(int fildes, mode_t mode); -->
  <function name="fchmod">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int chown(const char *path, uid_t owner, gid_t group); -->
  <function name="chown">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int lchown(const char *path, uid_t owner, gid_t group); -->
  <function name="lchown">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int fchown(int fildes, uid_t owner, gid_t group); -->
  <function name="fchown">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- clock_t times(struct tms *buffer); -->
  <function name="times">
    <noreturn>false</noreturn>
    <returnValue type="clock_t"/>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int utime(const char *filename, struct utimbuf *buf); -->
  <function name="utime">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="utimensat"/>
  </function>
  <!-- int utimes(const char *filename, const struct timeval times[2]); -->
  <function name="utimes">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- DIR *opendir(const char *name); -->
  <function name="opendir">
    <noreturn>false</noreturn>
    <returnValue type="DIR *"/>
    <use-retval/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- DIR *fdopendir(int fd); -->
  <function name="fdopendir">
    <use-retval/>
    <returnValue type="DIR *"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int isatty(int fildes); -->
  <function name="isatty">
    <use-retval/>
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- FILE *popen(const char *command, const char *type); -->
  <function name="popen">
    <use-retval/>
    <returnValue type="FILE *"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int pclose(FILE *stream); -->
  <function name="pclose">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int socket(int domain, int type, int protocol); -->
  <function name="socket">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int nice(int incr); -->
  <function name="nice">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int pause(void); -->
  <function name="pause">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <leak-ignore/>
  </function>
  <!-- int close(int fildes); -->
  <function name="close">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- size_t confstr(int, char *, size_t); -->
  <function name="confstr">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="size_t"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
      <valid>0:</valid>
    </arg>
  </function>
  <!-- long int fpathconf(int fildes, int name); -->
  <function name="fpathconf">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="long int"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- long int pathconf(const char *path, int name); -->
  <function name="pathconf">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="long int"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- long int sysconf(int name); -->
  <function name="sysconf">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="long int"/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- FILE *fdopen(int fd, const char *mode); -->
  <function name="fdopen">
    <use-retval/>
    <returnValue type="FILE *"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- long int random(void); -->
  <function name="random">
    <use-retval/>
    <returnValue type="long int"/>
    <noreturn>false</noreturn>
  </function>
  <!-- void srandom(unsigned int seed); -->
  <function name="srandom">
    <noreturn>false</noreturn>
    <!-- It is common practice to call srandom with an uninitialized 
         variable. Therefore, no warning shall be generated in this 
         very special case. -->
    <arg nr="1"/>
  </function>
  <!-- void rewinddir(DIR *dir); -->
  <function name="rewinddir">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
  </function>
  <!-- void seekdir(DIR *dirp, long loc); -->
  <function name="seekdir">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
  </function>
  <!-- int rand_r(unsigned int *seedp); -->
  <function name="rand_r">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-bool/>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="rand"/>
  </function>
  <!-- int strcasecmp(const char *s1, const char *s2); -->
  <function name="strcasecmp">
    <pure/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int strncasecmp(const char *s1, const char *s2, size_t n); -->
  <function name="strncasecmp">
    <pure/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-bool/>
      <valid>0:</valid>
    </arg>
  </function>
  <!-- ssize_t read(int fd, void *buf, size_t count); -->
  <function name="read">
    <leak-ignore/>
    <returnValue type="ssize_t"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
      <valid>0:</valid>
    </arg>
  </function>
  <!-- ssize_t write(int fildes, const void *buf, size_t nbyte); -->
  <function name="write">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="ssize_t"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
      <valid>0:</valid>
    </arg>
  </function>
  <!-- ssize_t recv(int sockfd, void *buf, size_t len, int flags); -->
  <function name="recv">
    <returnValue type="ssize_t"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="3">
      <not-uninit/>
    </arg>
    <arg nr="4">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                        struct sockaddr *src_addr, socklen_t *addrlen); -->
  <function name="recvfrom">
    <returnValue type="ssize_t"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="3">
      <not-uninit/>
    </arg>
    <arg nr="4">
      <not-uninit/>
    </arg>
    <arg nr="5"/>
    <arg nr="6">
      <not-bool/>
    </arg>
  </function>
  <!-- ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags); -->
  <function name="recvmsg">
    <returnValue type="ssize_t"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- ssize_t send(int sockfd, const void *buf, size_t len, int flags); -->
  <function name="send">
    <returnValue type="ssize_t"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="3">
      <not-uninit/>
    </arg>
    <arg nr="4">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
                      const struct sockaddr *dest_addr, socklen_t addrlen); -->
  <function name="sendto">
    <returnValue type="ssize_t"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="3">
      <not-uninit/>
    </arg>
    <arg nr="4">
      <not-uninit/>
    </arg>
    <arg nr="5"/>
    <arg nr="6">
      <not-bool/>
    </arg>
  </function>
  <!-- ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags); -->
  <function name="sendmsg">
    <returnValue type="ssize_t"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset); -->
  <function name="mmap">
    <use-retval/>
    <returnValue type="void *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <arg nr="3">
      <not-uninit/>
    </arg>
    <arg nr="4">
      <not-uninit/>
    </arg>
    <arg nr="5">
      <not-uninit/>
    </arg>
    <arg nr="6">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- void *mmap64(void *addr, size_t length, int prot, int flags, int fd, off64_t offset); -->
  <function name="mmap64">
    <use-retval/>
    <returnValue type="void *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <arg nr="3">
      <not-uninit/>
    </arg>
    <arg nr="4">
      <not-uninit/>
    </arg>
    <arg nr="5">
      <not-uninit/>
    </arg>
    <arg nr="6">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int munmap(void *addr, size_t length); -->
  <function name="munmap">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
      <valid>0:</valid>
    </arg>
  </function>
  <!-- void openlog(const char *ident, int option, int facility); -->
  <function name="openlog">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
    </arg>
  </function>
  <!-- int fcntl(int fd, int cmd, ... /* arg */ ); -->
  <function name="fcntl">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="any">
      <not-uninit/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man2/ioctl.2.html -->
  <!-- int ioctl(int fd, unsigned long request, ...); -->
  <function name="ioctl">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="any">
      <not-uninit/>
    </arg>
  </function>
  <!-- void syslog(int priority, const char *format, ...); -->
  <function name="syslog">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <formatstr/>
    <arg nr="2">
      <formatstr/>
    </arg>
    <arg nr="any">
      <not-uninit/>
    </arg>
  </function>
  <!-- void vsyslog(int priority, const char *format, va_list ap); -->
  <function name="vsyslog">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <formatstr/>
    <arg nr="2">
      <formatstr/>
    </arg>
    <arg nr="any">
      <not-uninit/>
    </arg>
  </function>
  <!-- gid_t getgid(void) -->
  <function name="getgid">
    <use-retval/>
    <returnValue type="gid_t"/>
    <noreturn>false</noreturn>
  </function>
  <!-- gid_t getegid(void) -->
  <function name="getegid">
    <use-retval/>
    <returnValue type="gid_t"/>
    <noreturn>false</noreturn>
  </function>
  <!-- uid_t getuid (void); -->
  <function name="getuid">
    <use-retval/>
    <returnValue type="uid_t"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
  </function>
  <!-- pid_t getsid(pid_t pid); -->
  <function name="getsid">
    <use-retval/>
    <returnValue type="pid_t"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- uid_t geteuid(void); -->
  <function name="geteuid">
    <use-retval/>
    <returnValue type="uid_t"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
  </function>
  <!-- pid_t getppid(void); -->
  <function name="getppid">
    <use-retval/>
    <returnValue type="pid_t"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
  </function>
  <!-- pid_t getpid(void); -->
  <function name="getpid">
    <use-retval/>
    <returnValue type="pid_t"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
  </function>
  <!-- pid_t getpgrp(void); -->
  <function name="getpgrp">
    <use-retval/>
    <returnValue type="pid_t"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
  </function>
  <!-- ppid_t getpgid(pid_t pid); -->
  <function name="getpgid">
    <use-retval/>
    <returnValue type="ppid_t"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int setuid(uid_t uid); -->
  <function name="setuid">
    <use-retval/>
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int seteuid(uid_t euid); -->
  <function name="seteuid">
    <use-retval/>
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int setgid(gid_t gid); -->
  <function name="setgid">
    <use-retval/>
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int setegid(gid_t egid); -->
  <function name="setegid">
    <use-retval/>
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int setpgid(pid_t pid, pid_t pgid); -->
  <function name="setpgid">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int pipe(int fildes[2]); -->
  <function name="pipe">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-bool/>
    </arg>
  </function>
  <!-- pid_t setpgrp(void); -->
  <function name="setpgrp">
    <returnValue type="pid_t"/>
    <noreturn>false</noreturn>
  </function>
  <!-- int setregid(gid_t rgid, gid_t egid); -->
  <function name="setregid">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int setreuid(uid_t ruid, uid_t euid); -->
  <function name="setreuid">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int setfsuid(uid_t fsuid); -->
  <function name="setfsuid">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int setfsgid(uid_t fsgid); -->
  <function name="setfsgid">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- pid_t setsid(void); -->
  <function name="setsid">
    <returnValue type="pid_t"/>
    <noreturn>false</noreturn>
    <!-- it is a good idea to do: <use-retval/> -->
  </function>
  <!-- char *getwd(char *path_name);-->
  <function name="getwd">
    <returnValue type="char *"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-bool/>
    </arg>
    <leak-ignore/>
    <warn severity="style" reason="Obsolescent" alternatives="getcwd"/>
  </function>
  <!-- http://pubs.opengroup.org/onlinepubs/009695399/basedefs/arpa/inet.h.html -->
  <!-- uint32_t htonl(uint32_t); -->
  <function name="htonl">
    <returnValue type="uint32_t"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- uint16_t htons(uint16_t); -->
  <function name="htons">
    <returnValue type="uint16_t"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- uint32_t ntohl(uint32_t); -->
  <function name="ntohl">
    <returnValue type="uint32_t"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- uint16_t ntohs(uint16_t); -->
  <function name="ntohs">
    <returnValue type="uint16_t"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int      mq_close(mqd_t); -->
  <function name="mq_close">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int      mq_getattr(mqd_t, struct mq_attr *); -->
  <function name="mq_getattr">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-bool/>
    </arg>
  </function>
  <!-- int      mq_notify(mqd_t, const struct sigevent *); -->
  <function name="mq_notify">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-bool/>
    </arg>
  </function>
  <!-- mqd_t    mq_open(const char *, int, ...); -->
  <function name="mq_open">
    <returnValue type="mqd_t"/>
    <noreturn>false</noreturn>
  </function>
  <!-- ssize_t  mq_receive(mqd_t, char *, size_t, unsigned *); -->
  <function name="mq_receive">
    <returnValue type="ssize_t"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="4">
      <not-bool/>
    </arg>
  </function>
  <!-- int      mq_send(mqd_t, const char *, size_t, unsigned); -->
  <function name="mq_send">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="4">
      <not-bool/>
    </arg>
  </function>
  <!-- int      mq_setattr(mqd_t, const struct mq_attr *restrict,-->
  <!--             struct mq_attr *restrict); -->
  <function name="mq_setattr">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-bool/>
    </arg>
  </function>
  <!-- ssize_t  mq_timedreceive(mqd_t, char *restrict, size_t,-->
  <!--             unsigned *restrict, const struct timespec *restrict); -->
  <function name="mq_timedreceive">
    <returnValue type="ssize_t"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="5">
      <not-bool/>
    </arg>
  </function>
  <!-- int      mq_timedsend(mqd_t, const char *, size_t, unsigned,-->
  <!--             const struct timespec *); -->
  <function name="mq_timedsend">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="5">
      <not-bool/>
    </arg>
  </function>
  <!-- int      mq_unlink(const char *); -->
  <function name="mq_unlink">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int     dbm_clearerr(DBM *); -->
  <function name="dbm_clearerr">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- void    dbm_close(DBM *); -->
  <function name="dbm_close">
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
  </function>
  <!-- int     dbm_delete(DBM *, datum); -->
  <function name="dbm_delete">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
  </function>
  <!-- int     dbm_error(DBM *); -->
  <function name="dbm_error">
    <use-retval/>
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- datum   dbm_fetch(DBM *, datum); -->
  <function name="dbm_fetch">
    <use-retval/>
    <returnValue type="datum"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
  </function>
  <!-- datum   dbm_firstkey(DBM *); -->
  <function name="dbm_firstkey">
    <use-retval/>
    <returnValue type="datum"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- datum   dbm_nextkey(DBM *); -->
  <function name="dbm_nextkey">
    <use-retval/>
    <returnValue type="datum"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- DBM    *dbm_open(const char *, int, mode_t); -->
  <function name="dbm_open">
    <returnValue type="DBM *"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int     dbm_store(DBM *, datum, datum, int); -->
  <function name="dbm_store">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
    </arg>
    <arg nr="4">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://pubs.opengroup.org/onlinepubs/009695399/functions/freeaddrinfo.html -->
  <!-- void freeaddrinfo(struct addrinfo *ai); -->
  <function name="freeaddrinfo">
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
      <not-null/>
      <!-- not-null is not required by the resource above, but some systems will segfault -->
    </arg>
  </function>
  <!-- http://pubs.opengroup.org/onlinepubs/009695399/functions/freeaddrinfo.html -->
  <!-- int getaddrinfo(const char * nodename, const char * servname, const struct addrinfo * hints, struct addrinfo ** res); -->
  <function name="getaddrinfo">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
    </arg>
    <arg nr="4">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- void endhostent(void); -->
  <function name="endhostent">
    <noreturn>false</noreturn>
  </function>
  <!-- void sethostent(int stayopen); -->
  <function name="sethostent">
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
  </function>
  <!-- int uname(struct utsname *buf); -->
  <function name="uname">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!--void           endpwent(void); -->
  <function name="endpwent">
    <noreturn>false</noreturn>
  </function>
  <!--struct passwd *getpwent(void); -->
  <function name="getpwent">
    <use-retval/>
    <returnValue type="struct passwd *"/>
    <noreturn>false</noreturn>
    <warn severity="portability">Non reentrant function 'getpwent' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getpwent_r'.</warn>
  </function>
  <!--struct passwd *getpwnam(const char *); -->
  <function name="getpwnam">
    <use-retval/>
    <returnValue type="struct passwd *"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'getpwnam' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getpwnam_r'.</warn>
  </function>
  <!-- char *strtok(char *s, const char *ct); -->
  <function name="strtok,std::strtok">
    <!-- Already configured in std.cfg. Add only a warning for POSIX that a
    threadsafe function exists that should be used. -->
    <warn severity="portability">Non reentrant function 'strtok' called. For threadsafe applications it is recommended to use the reentrant replacement function 'strtok_r'.</warn>
  </function>
  <!-- char *strtok_r(char *str, const char *delim, char **saveptr); -->
  <function name="strtok_r">
    <!-- strtok may modify the first argument, so using the return value is not mandatory -->
    <noreturn>false</noreturn>
    <returnValue type="char *"/>
    <pure/>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!--int getpwnam_r(const char *, struct passwd *, char *, size_t, struct passwd **); -->
  <function name="getpwnam_r">
    <use-retval/>
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="4">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <arg nr="5">
      <not-bool/>
    </arg>
  </function>
  <!-- struct passwd *getpwuid(uid_t uid); -->
  <function name="getpwuid">
    <use-retval/>
    <returnValue type="struct passwd *"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'getpwuid' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getpwuid_r'.</warn>
  </function>
  <!-- int getpwuid_r(uid_t, struct passwd *, char *, size_t, struct passwd **); -->
  <function name="getpwuid_r">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="4">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <arg nr="5">
      <not-bool/>
    </arg>
  </function>
  <!-- void setpwent(void); -->
  <function name="setpwent">
    <noreturn>false</noreturn>
  </function>
  <!-- int catclose(nl_catd); -->
  <function name="catclose">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- char *catgets(nl_catd, int, int, const char *); -->
  <function name="catgets">
    <returnValue type="char *"/>
    <use-retval/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
    </arg>
    <arg nr="4">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- nl_catd catopen(const char *, int); -->
  <function name="catopen">
    <returnValue type="nl_catd"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/poll.h.html -->
  <!-- int   poll(struct pollfd [], nfds_t, int); -->
  <function name="poll">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int    regcomp(regex_t *, const char *, int); -->
  <function name="regcomp">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- size_t regerror(int, const regex_t *, char *, size_t); -->
  <function name="regerror">
    <returnValue type="size_t"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="4">
      <not-uninit/>
      <valid>0:</valid>
      <not-bool/>
    </arg>
  </function>
  <!-- int    regexec(const regex_t *, const char *, size_t, regmatch_t [restrict], int); -->
  <function name="regexec">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <arg nr="4">
      <not-uninit/>
    </arg>
    <arg nr="5">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- void   regfree(regex_t *); -->
  <function name="regfree">
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
  </function>
  <!-- int    sched_get_priority_max(int); -->
  <function name="sched_get_priority_max">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int    sched_get_priority_min(int); -->
  <function name="sched_get_priority_min">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int    sched_getparam(pid_t, struct sched_param *); -->
  <function name="sched_getparam">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- int    sched_getscheduler(pid_t); -->
  <function name="sched_getscheduler">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int    sched_rr_get_interval(pid_t, struct timespec *); -->
  <function name="sched_rr_get_interval">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- int    sched_setparam(pid_t, const struct sched_param *); -->
  <function name="sched_setparam">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int    sched_setscheduler(pid_t, int, const struct sched_param *); -->
  <function name="sched_setscheduler">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int    sched_yield(void); -->
  <function name="sched_yield">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
  </function>
  <!-- char *ecvt(double value, int ndigit, int *restrict decpt, int *restrict sign);-->
  <!--      LEGACY in POSIX.1-2001, removed in POSIX.1-2008-->
  <function name="ecvt">
    <returnValue type="char *"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-null/>
    </arg>
    <arg nr="4">
      <not-null/>
      <not-bool/>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="sprintf"/>
  </function>
  <!-- char *fcvt(double value, int ndigit, int *restrict decpt, int *restrict sign);-->
  <!--    LEGACY in POSIX.1-2001, removed in POSIX.1-2008-->
  <function name="fcvt">
    <returnValue type="char *"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-null/>
    </arg>
    <arg nr="4">
      <not-null/>
      <not-bool/>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="sprintf"/>
  </function>
  <!-- char *gcvt(double value, int ndigit, char *buf);-->
  <!--    LEGACY in POSIX.1-2001, removed in POSIX.1-2008-->
  <function name="gcvt">
    <returnValue type="char *"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-null/>
      <not-bool/>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="sprintf"/>
  </function>
  <!-- off_t lseek(int fildes, off_t offset, int whence); -->
  <function name="lseek">
    <returnValue type="off_t"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
    </arg>
  </function>
  <!-- int nanosleep(const struct timespec *rqtp, struct timespec *rmtp); -->
  <function name="nanosleep">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
    </arg>
    <arg nr="2">
      <not-bool/>
    </arg>
  </function>
  <!-- void setkey(const char *key); -->
  <function name="setkey">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
  </function>
  <!-- char *getpass(const char *prompt); -->
  <function name="getpass">
    <returnValue type="char *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://pubs.opengroup.org/onlinepubs/009695399/basedefs/stdlib.h.html -->
  <!-- double drand48(void); -->
  <function name="drand48">
    <use-retval/>
    <returnValue type="double"/>
    <noreturn>false</noreturn>
  </function>
  <!-- int putenv(char *string); -->
  <function name="putenv">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int setenv(const char *envname, const char *envval, int overwrite); -->
  <function name="setenv">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
    </arg>
  </function>
  <!-- int unsetenv(const char *name); -->
  <function name="unsetenv">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- struct tm * localtime(const time_t *tp); -->
  <function name="localtime,std::localtime">
    <noreturn>false</noreturn>
    <returnValue type="struct tm *"/>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'localtime' called. For threadsafe applications it is recommended to use the reentrant replacement function 'localtime_r'.</warn>
  </function>
  <!-- struct tm *localtime_r(const time_t *timep, struct tm *result); -->
  <function name="localtime_r">
    <noreturn>false</noreturn>
    <returnValue type="struct tm *"/>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- struct dirent *readdir(DIR *dirp); -->
  <function name="readdir">
    <returnValue type="struct dirent *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'readdir' called. For threadsafe applications it is recommended to use the reentrant replacement function 'readdir_r'.</warn>
  </function>
  <!-- int readdir_r(DIR *dirp, struct dirent *entry, struct dirent **result); -->
  <function name="readdir_r">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
    </arg>
    <arg nr="3">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- ssize_t readlink(const char *path, char *buf, size_t bufsiz); -->
  <function name="readlink">
    <returnValue type="ssize_t"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
      <valid>0:</valid>
    </arg>
  </function>
  <!-- int readlinkat(int dirfd, const char *pathname, char *buf, size_t bufsiz); -->
  <function name="readlinkat">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-null/>
      <minsize type="argvalue" arg="4"/>
    </arg>
    <arg nr="4">
      <not-uninit/>
      <not-bool/>
      <valid>0:</valid>
    </arg>
  </function>
  <!-- char *asctime_r(const struct tm *tm, char *buf); -->
  <function name="asctime_r">
    <returnValue type="char *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-bool/>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="strftime"/>
  </function>
  <!-- char *ctime_r(const time_t *timep, char *buf); -->
  <function name="ctime_r">
    <returnValue type="char *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-bool/>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="strftime"/>
  </function>
  <!-- struct tm *gmtime_r(const time_t *timep, struct tm *result); -->
  <function name="gmtime_r">
    <returnValue type="struct tm *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- struct tm * gmtime(const time_t *tp); -->
  <function name="gmtime">
    <returnValue type="struct tm *"/>
    <use-retval/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'gmtime' called. For threadsafe applications it is recommended to use the reentrant replacement function 'gmtime_r'.</warn>
  </function>
  <!-- http://pubs.opengroup.org/onlinepubs/007908799/xsh/time.h.html -->
  <!-- int clock_settime(clockid_t clock_id, const struct timespec *tp); -->
  <function name="clock_settime">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int killpg(int pgrp, int sig); -->
  <function name="killpg">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int kill(pid_t pid, int sig); -->
  <function name="kill">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int clock_gettime(clockid_t clock_id, struct timespec *tp); -->
  <function name="clock_gettime">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- int clock_getres(clockid_t clock_id, struct timespec *res); -->
  <function name="clock_getres">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-bool/>
    </arg>
  </function>
  <!-- char* tmpnam(char *s); -->
  <function name="tmpnam,tmpnam_r">
    <returnValue type="char *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="tmpfile,mkstemp,mkdtemp"/>
  </function>
  <!-- void makecontext(ucontext_t *ucp, void (*func)(), int argc, ...); -->
  <function name="makecontext">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
    </arg>
    <arg nr="any"/>
    <warn severity="portability">Obsolescent function 'makecontext' called. Applications are recommended to be rewritten to use POSIX threads.</warn>
  </function>
  <!-- void swapcontext(ucontext_t *restrict oucp, const ucontext_t *restrict ucp); -->
  <function name="swapcontext">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
    </arg>
    <arg nr="2">
      <not-null/>
    </arg>
    <warn severity="portability">Obsolescent function 'swapcontext' called. Applications are recommended to be rewritten to use POSIX threads.</warn>
  </function>
  <!-- void getcontext(ucontext_t *ucp); -->
  <function name="getcontext">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
    </arg>
    <warn severity="portability">Obsolescent function 'getcontext' called. Applications are recommended to be rewritten to use POSIX threads.</warn>
  </function>
  <!-- useconds_t ualarm(useconds_t useconds, useconds_t interval); -->
  <function name="ualarm">
    <returnValue type="useconds_t"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="timer_create,timer_delete,timer_getoverrun,timer_gettime,timer_settime"/>
  </function>
  <!-- double scalb(double x, double n); -->
  <function name="scalb">
    <returnValue type="double"/>
    <use-retval/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="scalbln,scalblnf,scalbln,scalbn,scalbnf,scalbnl"/>
  </function>
  <!-- void bcopy(const void *s1, void *s2, size_t n); -->
  <function name="bcopy">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="2">
      <not-null/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="memcpy,memmove"/>
  </function>
  <!-- int bcmp(const void *s1, void *s2, size_t n); -->
  <function name="bcmp">
    <use-retval/>
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
      <valid>0:</valid>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="memcmp"/>
  </function>
  <!-- void bzero(void *s, size_t n); -->
  <function name="bzero">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="memset"/>
  </function>
  <!-- int ftime(struct timeb *tp); -->
  <function name="ftime">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="time,gettimeofday,clock_gettime"/>
  </function>
  <!-- wchar_t *wcswcs(const wchar_t *ws1, const wchar_t *ws2); -->
  <function name="wcswcs">
    <use-retval/>
    <returnValue type="wchar_t *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="wcsstr"/>
  </function>
  <!-- char *stpcpy(char *desstr, const char *srcstr); -->
  <function name="stpcpy">
    <returnValue type="char *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <minsize type="strlen" arg="2"/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-uninit/>
      <strz/>
      <not-bool/>
    </arg>
  </function>
  <!-- char *index(const char *s, int c); -->
  <function name="index">
    <use-retval/>
    <returnValue type="char *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="strchr"/>
  </function>
  <!-- char *rindex(const char *s, int c); -->
  <function name="rindex">
    <use-retval/>
    <returnValue type="char *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="strrchr"/>
  </function>
  <!-- sighandler_t bsd_signal(int signum, sighandler_t handler); -->
  <function name="bsd_signal">
    <returnValue type="sighandler_t"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="sigaction"/>
  </function>
  <!-- pid_t fork(void); -->
  <function name="fork">
    <returnValue type="pid_t"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
  </function>
  <!-- pid_t vfork(void); -->
  <function name="vfork">
    <returnValue type="pid_t"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <warn severity="style" reason="Obsolescent" alternatives="fork"/>
  </function>
  <!-- int pthread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void)); -->
  <function name="pthread_atfork">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="3"/>
  </function>
  <!-- int pthread_create(pthread_t * thread, const pthread_attr_t * attr, void *(*start_routine)(void*), void * arg); -->
  <function name="pthread_create">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
    </arg>
    <arg nr="2"/>
    <arg nr="3">
      <not-null/>
    </arg>
    <arg nr="4"/>
  </function>
  <function name="pthread_detach">
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
  </function>
  <function name="pthread_equal">
    <noreturn>false</noreturn>
    <use-retval/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
  </function>
  <function name="pthread_exit">
    <noreturn>true</noreturn>
    <arg nr="1"/>
  </function>
  <!-- int pthread_join(pthread_t thread, void **value_ptr); -->
  <function name="pthread_join">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2"/>
  </function>
  <function name="pthread_kill">
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
  </function>
  <function name="pthread_self">
    <noreturn>false</noreturn>
    <use-retval/>
  </function>
  <function name="pthread_attr_destroy">
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
    </arg>
  </function>
  <function name="pthread_attr_init">
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
    </arg>
  </function>
  <!-- int pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr); -->
  <function name="pthread_attr_setstackaddr">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="pthread_attr_setstack"/>
  </function>
  <!-- int pthread_attr_getstackaddr(const pthread_attr_t *attr, void **stackaddr); -->
  <function name="pthread_attr_getstackaddr">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-bool/>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="pthread_attr_getstack"/>
  </function>
  <!-- int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize); -->
  <!-- int pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize); -->
  <function name="pthread_attr_setstacksize,pthread_attr_setguardsize">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
      <valid>0:</valid>
    </arg>
  </function>
  <!-- int pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize); -->
  <!-- int pthread_attr_getguardsize(const pthread_attr_t *attr, size_t *guardsize); -->
  <function name="pthread_attr_getstacksize,pthread_attr_getguardsize">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr); -->
  <function name="pthread_mutex_init">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
    </arg>
    <arg nr="2">
      <!-- NULL is valid -->
    </arg>
  </function>
  <!-- int pthread_mutex_destroy(pthread_mutex_t *mutex); -->
  <function name="pthread_mutex_destroy">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
  </function>
  <!-- int pthread_mutex_lock(pthread_mutex_t *mutex); -->
  <function name="pthread_mutex_lock">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
  </function>
  <!-- int pthread_mutex_trylock(pthread_mutex_t *mutex); -->
  <function name="pthread_mutex_trylock">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
  </function>
  <!-- int pthread_mutex_unlock(pthread_mutex_t *mutex); -->
  <function name="pthread_mutex_unlock">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
  </function>
  <!-- char *tempnam(const char *dir, const char *pfx); -->
  <function name="tempnam">
    <use-retval/>
    <returnValue type="char *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'tempnam' called. For threadsafe applications it is recommended to use the reentrant replacement function 'tempnam_r'.</warn>
  </function>
  <!-- char *crypt(const char *key, const char *salt); -->
  <function name="crypt">
    <use-retval/>
    <returnValue type="char *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'crypt' called. For threadsafe applications it is recommended to use the reentrant replacement function 'crypt_r'.</warn>
  </function>
  <!-- char *ttyname(int fd); -->
  <function name="ttyname">
    <use-retval/>
    <returnValue type="char *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'ttyname' called. For threadsafe applications it is recommended to use the reentrant replacement function 'ttyname_r'.</warn>
  </function>
  <!-- struct spwd *getspnam(const char *name); -->
  <function name="getspnam">
    <use-retval/>
    <returnValue type="struct spwd *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'getspnam' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getspnam_r'.</warn>
  </function>
  <!-- struct spwd *getspent(void); -->
  <function name="getspent">
    <use-retval/>
    <returnValue type="struct spwd *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <warn severity="portability">Non reentrant function 'getspent' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getspent_r'.</warn>
  </function>
  <!-- struct spwd *fgetspent(FILE *fp); -->
  <function name="fgetspent">
    <use-retval/>
    <returnValue type="struct spwd *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'fgetspent' called. For threadsafe applications it is recommended to use the reentrant replacement function 'fgetspent_r'.</warn>
  </function>
  <!-- struct spwd *sgetspent(const char *s); -->
  <function name="sgetspent">
    <use-retval/>
    <returnValue type="struct spwd *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'sgetspent' called. For threadsafe applications it is recommended to use the reentrant replacement function 'sgetspent_r'.</warn>
  </function>
  <!-- struct passwd *fgetpwent(FILE *stream); -->
  <function name="fgetpwent">
    <use-retval/>
    <returnValue type="struct passwd *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'fgetpwent' called. For threadsafe applications it is recommended to use the reentrant replacement function 'fgetpwent_r'.</warn>
  </function>
  <!-- struct group *getgrent(void); -->
  <function name="getgrent">
    <use-retval/>
    <returnValue type="struct group *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <warn severity="portability">Non reentrant function 'getgrent' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getgrent_r'.</warn>
  </function>
  <!-- int getgrent_r(struct group *gbuf, char *buf, size_t buflen, struct group **gbufp) -->
  <function name="getgrent_r">
    <use-retval/>
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <arg nr="4">
      <not-bool/>
    </arg>
  </function>
  <!-- struct group *fgetgrent(FILE *stream); -->
  <function name="fgetgrent">
    <use-retval/>
    <returnValue type="struct group *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'fgetgrent' called. For threadsafe applications it is recommended to use the reentrant replacement function 'fgetgrent_r'.</warn>
  </function>
  <!-- int getnetgrent(char **host, char **user, char **domain); -->
  <function name="getnetgrent">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
    </arg>
    <arg nr="2">
      <not-null/>
    </arg>
    <arg nr="3">
      <not-null/>
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'getnetgrent' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getnetgrent_r'.</warn>
  </function>
  <!-- struct group *getgrnam(const char *name); -->
  <function name="getgrnam">
    <use-retval/>
    <returnValue type="struct group *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'getgrnam' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getgrnam_r'.</warn>
  </function>
  <!-- struct group *getgrgid(gid_t gid); -->
  <function name="getgrgid">
    <returnValue type="struct group *"/>
    <use-retval/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'getgrgid' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getgrgid_r'.</warn>
  </function>
  <!-- char *getlogin(void); -->
  <function name="getlogin">
    <returnValue type="char *"/>
    <use-retval/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <warn severity="portability">Non reentrant function 'getlogin' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getlogin_r'.</warn>
  </function>
  <!-- char *ctermid(char *s); -->
  <function name="ctermid">
    <returnValue type="char *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-bool/>
    </arg>
    <warn severity="portability">Non reentrant function 'ctermid' called. For threadsafe applications it is recommended to use the reentrant replacement function 'ctermid_r'.</warn>
  </function>
  <!-- char *realpath(const char *path, char *resolved_path); -->
  <function name="realpath">
    <returnValue type="char *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
      <not-null/>
    </arg>
    <arg nr="2">
      <not-bool/>
    </arg>
  </function>
  <!-- int fileno(FILE *stream);-->
  <function name="fileno">
    <returnValue type="int"/>
    <use-retval/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int fseeko(FILE *stream, off_t offset, int whence); -->
  <function name="fseeko">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- off_t ftello(FILE *stream); -->
  <function name="ftello">
    <use-retval/>
    <returnValue type="off_t"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int execv(const char *path, char *const argv[]); 
       int execvp(const char *file, char *const argv[]); -->
  <function name="execv,execvp">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <strz/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- pid_t wait(int *stat_loc); -->
  <function name="wait">
    <returnValue type="pid_t"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-bool/>
    </arg>
  </function>
  <!-- pid_t waitpid(pid_t pid, int *stat_loc, int options); -->
  <function name="waitpid">
    <returnValue type="pid_t"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2"/>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- see http://man7.org/linux/man-pages/man3/wcsnlen.3.html-->
  <!-- size_t wcsnlen(const wchar_t *s, size_t maxlen);-->
  <!-- see http://man7.org/linux/man-pages/man3/strnlen.3.html-->
  <!-- size_t strnlen(const char *s, size_t maxlen); -->
  <function name="strnlen,wcsnlen">
    <use-retval/>
    <returnValue type="size_t"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
      <valid>0:</valid>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man3/ffs.3.html -->
  <!-- int ffs(int i); -->
  <function name="ffs">
    <returnValue type="int"/>
    <use-retval/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://pubs.opengroup.org/onlinepubs/9699919799/functions/shmctl.html -->
  <!-- int shmctl(int shmid, int cmd, struct shmid_ds *buf); -->
  <function name="shmctl">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://pubs.opengroup.org/onlinepubs/009695399/functions/shmget.html -->
  <!-- int shmget(key_t key, size_t size, int shmflg); -->
  <function name="shmget">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man2/shmat.2.html -->
  <!-- void *shmat(int shmid, const void *shmaddr, int shmflg); -->
  <function name="shmat">
    <noreturn>false</noreturn>
    <returnValue type="void *"/>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2"/>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man2/shmat.2.html -->
  <!-- int shmdt(const void *shmaddr);-->
  <function name="shmdt">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man2/setrlimit.2.html -->
  <!-- int getrlimit(int resource, struct rlimit *rlim); -->
  <function name="getrlimit">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man2/setrlimit.2.html -->
  <!-- int setrlimit(int resource, const struct rlimit *rlim); -->
  <function name="setrlimit">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man3/glob.3.html -->
  <!-- int glob(const char *pattern, int flags, int (*errfunc) (const char *epath, int eerrno), glob_t *pglob);-->
  <function name="glob">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
      <not-null/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
    </arg>
    <arg nr="4">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man3/glob.3.html -->
  <!--  void globfree(glob_t *pglob)-->
  <function name="globfree">
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
      <not-null/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man3/wcpncpy.3.html -->
  <!-- wchar_t *wcpncpy(wchar_t *dest, const wchar_t *src, size_t n); -->
  <function name="wcpncpy">
    <returnValue type="wchar_t *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
      <valid>0:</valid>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man3/stpncpy.3.html -->
  <!-- char *stpncpy(char *dest, const char *src, size_t n); -->
  <function name="stpncpy">
    <returnValue type="char *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
      <valid>0:</valid>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man3/memccpy.3.html -->
  <!-- void *memccpy(void *dest, const void *src, int c, size_t n);-->
  <function name="memccpy">
    <leak-ignore/>
    <returnValue type="void *"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <minsize type="sizeof" arg="2"/>
      <minsize type="argvalue" arg="4"/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <arg nr="4">
      <not-uninit/>
      <not-bool/>
      <valid>0:</valid>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man3/opterr.3.html-->
  <!-- int getopt(int argc, char * const argv[], const char *optstring); -->
  <function name="getopt">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-null/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man2/setitimer.2.html-->
  <!-- int getitimer(int which, struct itimerval *curr_value); -->
  <function name="getitimer">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man2/setitimer.2.html-->
  <!-- int setitimer(int which, const struct itimerval *new_value, struct itimerval *old_value); -->
  <function name="setitimer">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man2/sigaction.2.html -->
  <!-- int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact); -->
  <function name="sigaction">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-bool/>
    </arg>
  </function>
  <!-- http://pubs.opengroup.org/onlinepubs/9699919799/functions/sigaltstack.html -->
  <!-- int sigaltstack(const stack_t *restrict ss, stack_t *restrict oss); -->
  <function name="sigaltstack">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-bool/>
    </arg>
  </function>
  <!-- void siglongjmp(sigjmp_buf env, int val); -->
  <function name="siglongjmp,_longjmp">
    <noreturn>true</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
  </function>
  <!-- http://pubs.opengroup.org/onlinepubs/9699919799/functions/sigsetjmp.html -->
  <!-- int sigsetjmp(sigjmp_buf env, int savemask); -->
  <function name="sigsetjmp,_setjmp">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1"/>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int sigsuspend(const sigset_t *mask);-->
  <function name="sigsuspend">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://pubs.opengroup.org/onlinepubs/9699919799/functions/sigprocmask.html -->
  <!-- int pthread_sigmask(int how, const sigset_t *restrict set,
       sigset_t *restrict oset);
		int sigprocmask(int how, const sigset_t *restrict set,
       sigset_t *restrict oset); -->
  <function name="pthread_sigmask,sigprocmask">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man2/getrusage.2.html-->
  <!-- int getrusage(int who, struct rusage *usage);-->
  <function name="getrusage">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man3/sigsetops.3.html -->
  <!-- int sigemptyset(sigset_t *set); -->
  <function name="sigemptyset">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man3/sigsetops.3.html -->
  <!-- int sigfillset(sigset_t *set); -->
  <function name="sigfillset">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man3/sigsetops.3.html -->
  <!-- int sigaddset(sigset_t *set, int signum); -->
  <function name="sigaddset">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man3/sigsetops.3.html -->
  <!-- int sigdelset(sigset_t *set, int signum);-->
  <function name="sigdelset">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man3/sigsetops.3.html -->
  <!-- int sigismember(const sigset_t *set, int signum);-->
  <function name="sigismember">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int posix_spawn(pid_t *restrict pid, const char *restrict path,
                       const posix_spawn_file_actions_t *file_actions,
                       const posix_spawnattr_t *restrict attrp,
                       char *const argv[restrict], char *const envp[restrict]);
       int posix_spawnp(pid_t *restrict pid, const char *restrict file,
                       const posix_spawn_file_actions_t *file_actions,
                       const posix_spawnattr_t *restrict attrp,
                       char *const argv[restrict], char * const envp[restrict]); -->
  <function name="posix_spawn,posix_spawnp">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="6">
      <not-bool/>
    </arg>
  </function>
  <!-- int msgctl(int msqid, int cmd, struct msqid_ds *buf); -->
  <function name="msgctl">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int msgget(key_t key, int msgflg);-->
  <function name="msgget">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <use-retval/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,
               int msgflg); -->
  <function name="msgrcv">
    <returnValue type="ssize_t"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
    </arg>
    <arg nr="3">
      <not-uninit/>
    </arg>
    <arg nr="4">
      <not-uninit/>
    </arg>
    <arg nr="5">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg); -->
  <function name="msgsnd">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
    </arg>
    <arg nr="3">
      <not-uninit/>
    </arg>
    <arg nr="4">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man3/tcflow.3p.html -->
  <!-- int tcflow(int fildes, int action); -->
  <function name="tcflow">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man3/tcflush.3p.html -->
  <!-- int tcflush(int fildes, int queue_selector); -->
  <function name="tcflush">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man3/tcsendbreak.3p.html -->
  <!-- int tcsendbreak(int fildes, int duration); -->
  <function name="tcsendbreak">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man3/tcgetattr.3p.html -->
  <!-- int tcgetattr(int fildes, struct termios *termios_p); -->
  <function name="tcgetattr">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man3/tcsetattr.3p.html -->
  <!-- int tcsetattr(int fildes, int optional_actions, const struct termios *termios_p); -->
  <function name="tcsetattr">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man3/cfsetospeed.3p.html -->
  <!-- int cfsetospeed(struct termios *termios_p, speed_t speed); -->
  <!-- http://man7.org/linux/man-pages/man3/cfsetispeed.3p.html -->
  <!-- int cfsetispeed(struct termios *termios_p, speed_t speed); -->
  <function name="cfsetospeed,cfsetispeed">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
      <not-null/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://man7.org/linux/man-pages/man3/tcdrain.3p.html -->
  <!-- int tcdrain(int fildes); -->
  <function name="tcdrain">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- void swab(const void * src, void* dest, ssize_t bytes); -->
  <function name="swab">
    <returnValue type="void"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2">
      <not-null/>
    </arg>
    <arg nr="3">
      <not-uninit/>
    </arg>
  </function>
  <!-- void sync(void); -->
  <function name="sync">
    <returnValue type="void"/>
    <noreturn>false</noreturn>
  </function>
  <!-- int gethostname(char *name, size_t len); -->
  <function name="gethostname">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <arg nr="1">
      <not-null/>
      <minsize type="argvalue" arg="2"/>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <valid>1:</valid>
    </arg>
  </function>
  <!-- int posix_memalign(void **memptr, size_t alignment, size_t size); -->
  <function name="posix_memalign">
    <use-retval/>
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
    </arg>
    <arg nr="2">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
  </function>
  <memory>
    <alloc init="false">posix_memalign</alloc>
    <dealloc>free</dealloc>
  </memory>
  <memory>
    <alloc init="true">strdup</alloc>
    <alloc init="true">strndup</alloc>
    <alloc init="true">wcsdup</alloc>
    <dealloc>free</dealloc>
  </memory>
  <memory>
    <alloc init="true">mmap</alloc>
    <alloc init="true">mmap64</alloc>
    <dealloc>munmap</dealloc>
  </memory>
  <resource>
    <alloc init="true">open</alloc>
    <alloc init="true">creat</alloc>
    <alloc init="true">socket</alloc>
    <dealloc>close</dealloc>
  </resource>
  <resource>
    <alloc init="true">opendir</alloc>
    <alloc init="true">fdopendir</alloc>
    <dealloc>closedir</dealloc>
  </resource>
  <resource>
    <alloc init="true">fdopen</alloc>
    <dealloc>fclose</dealloc>
  </resource>
  <resource>
    <alloc init="true">popen</alloc>
    <dealloc>pclose</dealloc>
  </resource>
  <resource>
    <alloc init="true">mq_open</alloc>
    <dealloc>mq_close</dealloc>
  </resource>
  <memory>
    <alloc init="true" arg="4">getaddrinfo</alloc>
    <dealloc>freeaddrinfo</dealloc>
  </memory>
  <!-- This type definitions refer to http://pubs.opengroup.org/onlinepubs/009695399/basedefs/sys/types.h.html-->
  <podtype name="in_port_t" sign="u" size="2"/>
  <podtype name="in_addr_t" sign="u" size="4"/>
  <podtype name="socklen_t" sign="u" size="4"/>
  <podtype name="sa_family_t" sign="u" size="2"/>
  <podtype name="nlink_t" sign="s"/>
  <podtype name="mode_t" sign="s"/>
  <podtype name="pid_t" sign="s"/>
  <podtype name="uid_t" sign="s"/>
  <podtype name="gid_t" sign="s"/>
  <podtype name="id_t" sign="s"/>
  <podtype name="blkcnt_t" sign="s"/>
  <podtype name="off_t" sign="s"/>
  <podtype name="fsblkcnt_t" sign="u"/>
  <podtype name="fsfilcnt_t" sign="u"/>
  <podtype name="ino_t" sign="u"/>
  <podtype name="useconds_t" sign="u"/>
  <podtype name="suseconds_t" sign="u"/>
  <podtype name="blksize_t" sign="s"/>
  <podtype name="ssize_t" sign="s"/>
  <podtype name="dirent"/>
  <podtype name="DIR"/>
  <podtype name="clockid_t"/>
  <podtype name="dev_t"/>
  <podtype name="key_t"/>
  <podtype name="tms"/>
  <podtype name="utsname"/>
  <podtype name="pthread_attr_t"/>
  <podtype name="pthread_cond_t"/>
  <podtype name="pthread_condattr_t"/>
  <podtype name="pthread_key_t"/>
  <podtype name="pthread_mutexattr_t"/>
  <podtype name="pthread_mutex_t"/>
  <podtype name="pthread_barrier_t"/>
  <podtype name="pthread_barrierattr_t"/>
  <podtype name="pthread_once_t"/>
  <podtype name="pthread_rwlock_t"/>
  <podtype name="pthread_rwlockattr_t"/>
  <podtype name="pthread_spinlock_t"/>
  <podtype name="pthread_t"/>
  <podtype name="timer_t"/>
  <podtype name="trace_attr_t"/>
  <podtype name="trace_event_id_t"/>
  <podtype name="trace_event_set_t"/>
  <podtype name="trace_id_t"/>
  <podtype name="stat"/>
  <podtype name="sigjmp_buf"/>
  <podtype name="sigset_t"/>
  <podtype name="termios"/>
  <podtype name="intptr_t"/>
  <podtype name="timespec"/>
  <podtype name="timeval"/>
  <podtype name="timezone"/>
  <podtype name="sigaction"/>
  <podtype name="stack_t"/>
  <podtype name="mq_attr"/>
  <podtype name="mqd_t"/>
  <podtype name="datum"/>
  <podtype name="DBM"/>
  <podtype name="addrinfo"/>
  <podtype name="hostent"/>
  <podtype name="netent"/>
  <podtype name="protoent"/>
  <podtype name="servent"/>
  <podtype name="passwd"/>
  <podtype name="nl_catd"/>
  <podtype name="nl_item"/>
  <podtype name="regex_t"/>
  <podtype name="sched_param"/>
  <podtype name="glob_t"/>
  <podtype name="locale_t"/>
  <define name="MAP_FAILED" value="-1"/>
  <define name="RTLD_LAZY" value="0x01"/>
  <define name="RTLD_NOW" value="0x02"/>
  <define name="RTLD_GLOBAL" value="0x04"/>
  <define name="RTLD_LOCAL" value="0x08"/>
</def>