cppcheck/cfg/posix.cfg

<?xml version="1.0"?>
<!-- Description of the interfaces described by previous and current POSIX standards.
     Current reference: http://pubs.opengroup.org/onlinepubs/9699919799/ -->
<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" direction="in">
      <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" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="out">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="inout">
      <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" direction="in">
      <not-uninit/>
      <not-null/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="out">
      <not-bool/>
    </arg>
  </function>
  <resource>
    <alloc>dlopen</alloc>
    <dealloc>dlclose</dealloc>
  </resource>
  <!-- int bind(int socket, const struct sockaddr *address, socklen_t address_len); -->
  <function name="bind">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <leak-ignore/>
    <arg nr="1" direction="in">
      <not-bool/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-null/>
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
      <not-bool/>
      <valid>0:</valid>
    </arg>
  </function>
  <!-- int connect(int socket, const struct sockaddr *address, socklen_t address_len); -->
  <function name="connect">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <arg nr="1" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
    <arg nr="2" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
    </arg>
  </function>
  <!-- see http://pubs.opengroup.org/onlinepubs/9699919799/functions/dlopen.html -->
  <!-- void *dlopen(const char *file, int mode); -->
  <function name="dlopen">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="void*"/>
    <arg nr="1" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- see http://pubs.opengroup.org/onlinepubs/9699919799/functions/dlsym.html -->
  <!-- void *dlsym(void *restrict handle, const char *restrict name); -->
  <function name="dlsym">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <use-retval/>
    <returnValue type="void*"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
  </function>
  <!-- see http://pubs.opengroup.org/onlinepubs/9699919799/functions/dlclose.html -->
  <!-- int dlclose(void *handle); -->
  <function name="dlclose">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1">
      <not-uninit/>
    </arg>
  </function>
  <!-- int dup(int fildes);
     see http://pubs.opengroup.org/onlinepubs/9699919799/functions/dup.html -->
  <function name="dup">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <use-retval/>
    <arg nr="1" direction="in">
      <not-bool/>
      <not-uninit/>
    </arg>
  </function>
  <!-- int dup2(int fildes1, int filedes2);
     see http://pubs.opengroup.org/onlinepubs/9699919799/functions/dup.html -->
  <function name="dup2">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <arg nr="1" direction="in">
      <not-bool/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-bool/>
      <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" direction="out"/>
    <arg nr="2" direction="out">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- void FD_CLR(int fd, fd_set *set); -->
  <function name="FD_CLR">
    <noreturn>false</noreturn>
    <returnValue type="void"/>
    <leak-ignore/>
    <arg nr="1" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="inout">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- void FD_SET(int fd, fd_set *set); -->
  <function name="FD_SET">
    <noreturn>false</noreturn>
    <returnValue type="void"/>
    <leak-ignore/>
    <arg nr="1" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="inout">
      <not-null/>
    </arg>
  </function>
  <!-- void FD_ZERO(fd_set *set);-->
  <function name="FD_ZERO">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="void"/>
    <arg nr="1" direction="out">
      <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" direction="in">
      <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" direction="in">
      <not-uninit/>
      <not-null/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
      <not-null/>
    </arg>
    <arg nr="3" direction="in">
      <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" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://pubs.opengroup.org/onlinepubs/9699919799/functions/truncate.html -->
  <!-- int truncate(const char *path, off_t length); -->
  <function name="truncate">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
    <arg nr="3" default="0" direction="in">
      <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" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <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" direction="in">
      <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>
    <returnValue type="void"/>
    <arg nr="1" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="4" direction="in">
      <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" direction="in">
      <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" direction="in">
      <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" direction="in">
      <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" direction="in">
      <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" direction="in">
      <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" direction="in">
      <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" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <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" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <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 *"/>
    <use-retval/>
    <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 *"/>
    <use-retval/>
    <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 *"/>
    <use-retval/>
    <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" direction="in">
      <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" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <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" direction="in">
      <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" direction="in">
      <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" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <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" direction="in">
      <not-uninit/>
      <not-bool/>
      <valid>0:</valid>
    </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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <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" direction="in">
      <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" direction="in">
      <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>
    <returnValue type="void"/>
    <!-- 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/>
    <returnValue type="void"/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
  </function>
  <!-- void seekdir(DIR *dirp, long loc); -->
  <function name="seekdir">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="void"/>
    <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/>
    <use-retval/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int strncasecmp(const char *s1, const char *s2, size_t n); -->
  <function name="strncasecmp">
    <pure/>
    <use-retval/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="out">
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="3" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="3" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="out">
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="4" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="out">
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="4" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="5" direction="out"/>
    <arg nr="6" direction="inout">
      <not-bool/>
    </arg>
  </function>
  <!-- ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags); -->
  <function name="recvmsg">
    <returnValue type="ssize_t"/>
    <arg nr="1" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="inout"/>
    <arg nr="3" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="4" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="4" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="5" direction="in"/>
    <arg nr="6" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/mmap.html -->
  <!-- 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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
      <valid>1:</valid>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="4" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="5" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="6" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
      <valid>1:</valid>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="4" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="5" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="6" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/munmap.html -->
  <!-- int munmap(void *addr, size_t length); -->
  <function name="munmap">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
      <not-bool/>
      <valid>1:</valid>
    </arg>
  </function>
  <!-- void openlog(const char *ident, int option, int facility); -->
  <function name="openlog">
    <noreturn>false</noreturn>
    <returnValue type="void"/>
    <leak-ignore/>
    <arg nr="1" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <formatstr/>
    <arg nr="2" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <formatstr/>
    <arg nr="2" direction="in">
      <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" direction="in">
      <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" direction="in">
      <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" direction="in">
      <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" direction="in">
      <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" direction="in">
      <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" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int pipe(int fildes[2]); -->
  <function name="pipe">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1" direction="out">
      <not-null/>
      <not-bool/>
      <minsize type="value" value="2"/>
    </arg>
  </function>
  <!-- int pselect(int nfds, fd_set *restrict readfds,
       fd_set *restrict writefds, fd_set *restrict errorfds,
       const struct timespec *restrict timeout,
       const sigset_t *restrict sigmask);
	   see http://pubs.opengroup.org/onlinepubs/9699919799/functions/pselect.html -->
  <function name="pselect">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <leak-ignore/>
    <arg nr="1" direction="in">
      <not-bool/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="inout">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="inout">
      <not-uninit/>
    </arg>
    <arg nr="4" direction="inout">
      <not-uninit/>
    </arg>
    <arg nr="5" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="6" direction="in">
      <not-uninit/>
    </arg>
  </function>
  <!-- int select(int nfds, fd_set *restrict readfds, fd_set * writefds, fd_set * errorfds, struct timeval *timeout);
       see http://pubs.opengroup.org/onlinepubs/9699919799/functions/pselect.html -->
  <function name="select">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <leak-ignore/>
    <arg nr="1" direction="in">
      <not-bool/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="inout">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="inout">
      <not-uninit/>
    </arg>
    <arg nr="4" direction="inout">
      <not-uninit/>
    </arg>
    <arg nr="5" direction="inout">
      <not-uninit/>
    </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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <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" direction="in">
      <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" direction="out">
      <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>
    <use-retval/>
    <arg nr="1" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- uint16_t htons(uint16_t); -->
  <function name="htons">
    <returnValue type="uint16_t"/>
    <noreturn>false</noreturn>
    <use-retval/>
    <arg nr="1" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- uint32_t ntohl(uint32_t); -->
  <function name="ntohl">
    <returnValue type="uint32_t"/>
    <noreturn>false</noreturn>
    <use-retval/>
    <arg nr="1" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- uint16_t ntohs(uint16_t); -->
  <function name="ntohs">
    <returnValue type="uint16_t"/>
    <noreturn>false</noreturn>
    <use-retval/>
    <arg nr="1" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- in_addr_t inet_addr(const char *cp);
       http://pubs.opengroup.org/onlinepubs/009695399/functions/inet_addr.html -->
  <function name="inet_addr">
    <leak-ignore/>
    <pure/>
    <returnValue type="in_addr_t"/>
    <noreturn>false</noreturn>
    <use-retval/>
    <arg nr="1" direction="in">
      <not-uninit/>
      <not-bool/>
      <strz/>
    </arg>
  </function>
  <!-- char *inet_ntoa(struct in_addr in);
       http://pubs.opengroup.org/onlinepubs/009695399/functions/inet_addr.html -->
  <function name="inet_ntoa">
    <leak-ignore/>
    <returnValue type="char *"/>
    <noreturn>false</noreturn>
    <use-retval/>
    <arg nr="1" direction="in">
      <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" direction="out">
      <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" direction="in">
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_open.html -->
  <!-- mqd_t mq_open(const char *name, int oflag, ...); -->
  <function name="mq_open">
    <returnValue type="mqd_t"/>
    <noreturn>false</noreturn>
    <arg nr="1" direction="in">
      <not-uninit/>
      <strz/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="any"/>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_receive.html -->
  <!-- ssize_t mq_receive(mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned *msg_prio); -->
  <function name="mq_receive">
    <returnValue type="ssize_t"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="out">
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <arg nr="4" direction="out">
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_send.html -->
  <!-- int mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned msg_prio); -->
  <function name="mq_send">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="4" direction="in">
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_setattr.html -->
  <!-- int mq_setattr(mqd_t mqdes, const struct mq_attr *restrict mqstat, struct mq_attr *restrict omqstat); -->
  <function name="mq_setattr">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="out">
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_receive.html -->
  <!-- ssize_t mq_timedreceive(mqd_t mqdes, char *restrict msg_ptr, size_t msg_len, unsigned *restrict msg_prio, const struct timespec *restrict abstime); -->
  <function name="mq_timedreceive">
    <returnValue type="ssize_t"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="out">
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="4" direction="out"/>
    <arg nr="5" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_send.html -->
  <!-- int mq_timedsend(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned msg_prio, const struct timespec *abstime); -->
  <function name="mq_timedsend">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="4" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="5" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int mq_unlink(const char *name); -->
  <function name="mq_unlink">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1" direction="in">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/dbm_clearerr.html -->
  <!-- int dbm_clearerr(DBM *db); -->
  <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 *db); -->
  <function name="dbm_close">
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
  </function>
  <!-- int dbm_delete(DBM *db, datum key); -->
  <function name="dbm_delete">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
  </function>
  <!-- int dbm_error(DBM *db); -->
  <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 *db, datum key); -->
  <function name="dbm_fetch">
    <use-retval/>
    <returnValue type="datum"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
  </function>
  <!-- datum dbm_firstkey(DBM *db); -->
  <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 *db); -->
  <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 *file, int open_flags, mode_t file_mode); -->
  <function name="dbm_open">
    <returnValue type="DBM *"/>
    <noreturn>false</noreturn>
    <arg nr="1" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int dbm_store(DBM *db, datum key, datum content, int store_mode); -->
  <function name="dbm_store">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="4" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="4" direction="out">
      <not-bool/>
    </arg>
  </function>
  <!-- void endhostent(void); -->
  <function name="endhostent">
    <noreturn>false</noreturn>
    <returnValue type="void"/>
  </function>
  <!-- void sethostent(int stayopen); -->
  <function name="sethostent">
    <noreturn>false</noreturn>
    <returnValue type="void"/>
    <arg nr="1" direction="in">
      <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>
    <returnValue type="void"/>
  </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" direction="in">
      <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>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/strtok.html -->
  <!-- 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" direction="inout">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="3" direction="inout">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpwnam.html -->
  <!-- int getpwnam_r(const char *name, struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result); -->
  <function name="getpwnam_r">
    <use-retval/>
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="out"/>
    <arg nr="3" direction="out">
      <minsize type="argvalue" arg="4"/>
    </arg>
    <arg nr="4" direction="in">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <arg nr="5" direction="out">
      <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" direction="in">
      <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>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpwuid.html -->
  <!-- int getpwuid_r(uid_t uid, struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result); -->
  <function name="getpwuid_r">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="out"/>
    <arg nr="3" direction="out">
      <minsize type="argvalue" arg="4"/>
    </arg>
    <arg nr="4" direction="in">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <arg nr="5" direction="out">
      <not-bool/>
    </arg>
  </function>
  <!-- void setpwent(void); -->
  <function name="setpwent">
    <noreturn>false</noreturn>
    <returnValue type="void"/>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/catclose.html -->
  <!-- int catclose(nl_catd catd); -->
  <function name="catclose">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/catgets.html -->
  <!-- char *catgets(nl_catd catd, int set_id, int msg_id, const char *s); -->
  <function name="catgets">
    <returnValue type="char *"/>
    <use-retval/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="4" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/catopen.html -->
  <!-- nl_catd catopen(const char *name, int oflag); -->
  <function name="catopen">
    <returnValue type="nl_catd"/>
    <noreturn>false</noreturn>
    <arg nr="1" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/poll.h.html -->
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/poll.html -->
  <!-- int poll(struct pollfd fds[], nfds_t nfds, int timeout); -->
  <function name="poll">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1" direction="inout">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/regcomp.html -->
  <!-- int regcomp(regex_t *restrict preg, const char *restrict pattern, int cflags); -->
  <function name="regcomp">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1" direction="out">
      <not-null/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- size_t regerror(int errcode, const regex_t *restrict preg, char *restrict errbuf, size_t errbuf_size); -->
  <function name="regerror">
    <returnValue type="size_t"/>
    <noreturn>false</noreturn>
    <arg nr="1" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="out">
      <minsize type="argvalue" arg="4"/>
    </arg>
    <arg nr="4" direction="in">
      <not-uninit/>
      <valid>0:</valid>
      <not-bool/>
    </arg>
  </function>
  <!-- int regexec(const regex_t *restrict preg, const char *restrict string, size_t nmatch, regmatch_t pmatch[restrict], int eflags); -->
  <function name="regexec">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <arg nr="4" direction="out"/>
    <arg nr="5" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- void regfree(regex_t *preg); -->
  <function name="regfree">
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/sched_get_priority_max.html -->
  <!-- int sched_get_priority_max(int policy); -->
  <function name="sched_get_priority_max">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <use-retval/>
    <arg nr="1" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int sched_get_priority_min(int policy); -->
  <function name="sched_get_priority_min">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <use-retval/>
    <arg nr="1" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/sched_getparam.html -->
  <!-- int sched_getparam(pid_t pid, struct sched_param *param); -->
  <function name="sched_getparam">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1" direction="in">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <arg nr="2" direction="out">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/sched_getscheduler.html -->
  <!-- int sched_getscheduler(pid_t pid); -->
  <function name="sched_getscheduler">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1" direction="in">
      <not-uninit/>
      <not-bool/>
      <valid>0:</valid>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/sched_rr_get_interval.html -->
  <!-- int sched_rr_get_interval(pid_t pid, struct timespec *interval); -->
  <function name="sched_rr_get_interval">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <arg nr="1" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="out">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/sched_setparam.html# -->
  <!-- int sched_setparam(pid_t pid, const struct sched_param *param); -->
  <function name="sched_setparam">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/sched_setscheduler.html -->
  <!-- int sched_setscheduler(pid_t pid, int policy, const struct sched_param *param); -->
  <function name="sched_setscheduler">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1" direction="in">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/sched_yield.html -->
  <!-- int sched_yield(void); -->
  <function name="sched_yield">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/009696799/functions/ecvt.html -->
  <!-- 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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="out">
      <not-null/>
    </arg>
    <arg nr="4" direction="out">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="out">
      <not-null/>
    </arg>
    <arg nr="4" direction="out">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="out">
      <not-null/>
      <not-bool/>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="sprintf"/>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/lseek.html -->
  <!-- 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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <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" direction="in">
      <not-null/>
    </arg>
    <arg nr="2" direction="out">
      <not-bool/>
    </arg>
  </function>
  <!-- void setkey(const char *key); -->
  <function name="setkey">
    <noreturn>false</noreturn>
    <returnValue type="void"/>
    <leak-ignore/>
    <arg nr="1" direction="in">
      <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" direction="in">
      <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>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/putenv.html -->
  <!-- int putenv(char *string); -->
  <function name="putenv">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/setenv.html -->
  <!-- int setenv(const char *envname, const char *envval, int overwrite); -->
  <function name="setenv">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
    </arg>
  </function>
  <!-- int unsetenv(const char *name); -->
  <function name="unsetenv">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1" direction="in">
      <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" direction="in">
      <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" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="out">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/readdir.html -->
  <!-- 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" direction="out">
      <not-null/>
    </arg>
    <arg nr="3" direction="out">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/readlink.html -->
  <!-- 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" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="out">
      <not-null/>
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="3" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="3" direction="out">
      <not-null/>
      <minsize type="argvalue" arg="4"/>
    </arg>
    <arg nr="4" direction="in">
      <not-uninit/>
      <not-bool/>
      <valid>0:</valid>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/asctime.html -->
  <!-- char *asctime_r(const struct tm *tm, char *buf); -->
  <function name="asctime_r">
    <returnValue type="char *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="out">
      <not-null/>
      <not-bool/>
      <minsize type="value" value="26"/>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="strftime"/>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/ctime.html -->
  <!-- char *ctime_r(const time_t *timep, char *buf); -->
  <function name="ctime_r">
    <returnValue type="char *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="out">
      <not-null/>
      <not-bool/>
      <minsize type="value" value="26"/>
    </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" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="out">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/gmtime.html -->
  <!-- struct tm * gmtime(const time_t *tp); -->
  <function name="gmtime">
    <returnValue type="struct tm *"/>
    <use-retval/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1" direction="in">
      <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 -->
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/clock_settime.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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- int killpg(int pgrp, int sig); -->
  <function name="killpg">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <arg nr="1" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="out">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="out">
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/tmpnam.html -->
  <!-- char* tmpnam(char *s); -->
  <function name="tmpnam,tmpnam_r">
    <returnValue type="char *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1" direction="out">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <not-null/>
      <not-uninit/>
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="2" direction="out">
      <not-null/>
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="memcpy,memmove"/>
  </function>
  <!-- int bcmp(const void *s1, const void *s2, size_t n); -->
  <function name="bcmp">
    <use-retval/>
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <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" direction="out">
      <not-null/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <warn severity="style" reason="Obsolescent" alternatives="memset"/>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/007904875/functions/ftime.html -->
  <!-- int ftime(struct timeb *tp); -->
  <function name="ftime">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1" direction="out">
      <not-null/>
      <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" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="out">
      <not-null/>
      <minsize type="strlen" arg="2"/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <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>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_cond_broadcast.html -->
  <!-- int pthread_cond_signal(pthread_cond_t *cond);
       int pthread_cond_broadcast(pthread_cond_t *cond); -->
  <function name="pthread_cond_signal,pthread_cond_broadcast">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1">
      <not-null/>
      <not-uninit/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_create.html -->
  <!-- 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" direction="out">
      <not-null/>
    </arg>
    <arg nr="2" direction="in"/>
    <arg nr="3">
      <not-null/>
    </arg>
    <arg nr="4"/>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_detach.html -->
  <!-- int pthread_detach(pthread_t thread); -->
  <function name="pthread_detach">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <arg nr="1" direction="in">
      <not-uninit/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_equal.html -->
  <!-- int pthread_equal(pthread_t t1, pthread_t t2); -->
  <function name="pthread_equal">
    <noreturn>false</noreturn>
    <use-retval/>
    <returnValue type="int"/>
    <arg nr="1" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
  </function>
  <function name="pthread_exit">
    <noreturn>true</noreturn>
    <arg nr="1"/>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_join.html -->
  <!-- int pthread_join(pthread_t thread, void **value_ptr); -->
  <function name="pthread_join">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <arg nr="1" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="out">
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_kill.html -->
  <!-- int pthread_kill(pthread_t thread, int sig); -->
  <function name="pthread_kill">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <arg nr="1" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_self.html -->
  <!-- pthread_t pthread_self(void); -->
  <function name="pthread_self">
    <noreturn>false</noreturn>
    <use-retval/>
    <returnValue type="pthread_t"/>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_attr_destroy.html -->
  <!-- int pthread_attr_destroy(pthread_attr_t *attr); -->
  <function name="pthread_attr_destroy">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <arg nr="1" direction="inout">
      <not-null/>
    </arg>
  </function>
  <!-- int pthread_attr_init(pthread_attr_t *attr); -->
  <function name="pthread_attr_init">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <arg nr="1" direction="out">
      <not-null/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/009695399/functions/pthread_attr_getstackaddr.html -->
  <!-- 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" direction="in">
      <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" direction="out">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_mutex_init.html -->
  <!-- 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" direction="out">
      <not-null/>
    </arg>
    <arg nr="2" direction="in">
      <!-- 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" direction="inout">
      <not-null/>
      <not-uninit/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_mutex_lock.html -->
  <!-- int pthread_mutex_lock(pthread_mutex_t *mutex); -->
  <function name="pthread_mutex_lock">
    <noreturn>false</noreturn>
    <leak-ignore/>
    <returnValue type="int"/>
    <arg nr="1" direction="inout">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </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" direction="inout">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </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" direction="inout">
      <not-null/>
      <not-uninit/>
      <not-bool/>
    </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" direction="in">
      <not-uninit/>
      <strz/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
      <not-bool/>
      <strz/>
    </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" direction="in">
      <not-null/>
      <not-uninit/>
      <strz/>
    </arg>
    <arg nr="2" direction="in">
      <not-null/>
      <not-uninit/>
      <not-bool/>
      <strz/>
    </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" direction="in">
      <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" direction="in">
      <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" direction="in">
      <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="1" direction="out"/>
    <arg nr="2" direction="out">
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <arg nr="4" direction="out">
      <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" direction="out">
      <not-null/>
    </arg>
    <arg nr="2" direction="out">
      <not-null/>
    </arg>
    <arg nr="3" direction="out">
      <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" direction="in">
      <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" direction="in">
      <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" direction="out">
      <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>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/realpath.html -->
  <!-- char *realpath(const char *path, char *resolved_path); -->
  <function name="realpath">
    <returnValue type="char *"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1" direction="in">
      <not-uninit/>
      <not-null/>
    </arg>
    <arg nr="2" direction="out">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <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>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/exec.html -->
  <!-- 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" direction="in">
      <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" direction="out">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="out"/>
    <arg nr="3" direction="in">
      <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" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <!-- direction (in/out) depends on the value of arg2 "cmd" -->
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <arg nr="3" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in"/>
    <arg nr="3" direction="in">
      <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" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="out">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <not-uninit/>
      <not-null/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="4" direction="out">
      <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>
    <returnValue type="void"/>
    <arg nr="1">
      <not-uninit/>
      <not-null/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/wcpncpy.html -->
  <!-- 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" direction="out">
      <not-null/>
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="2" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <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" direction="out">
      <not-null/>
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="2" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <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" direction="out">
      <not-null/>
      <minsize type="sizeof" arg="2"/>
      <minsize type="argvalue" arg="4"/>
    </arg>
    <arg nr="2" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <arg nr="4" direction="in">
      <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">
    <leak-ignore/>
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <use-retval/>
    <arg nr="1" direction="in">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <arg nr="2">
      <not-uninit/>
      <not-null/>
    </arg>
    <arg nr="3" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="out">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="out">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in"/>
    <arg nr="3" direction="out">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="out">
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/siglongjmp.html -->
  <!-- void siglongjmp(sigjmp_buf env, int val); -->
  <function name="siglongjmp,_longjmp">
    <returnValue type="void"/>
    <noreturn>true</noreturn>
    <arg nr="1" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="out"/>
    <arg nr="2" direction="in">
      <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" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="out">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/getrusage.html -->
  <!-- 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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="out">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/sigemptyset.html -->
  <!-- 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" direction="out">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/sigfillset.html -->
  <!-- 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" direction="out">
      <not-null/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/sigaddset.html -->
  <!-- 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" direction="inout">
      <not-uninit/>
      <not-null/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/sigdelset.html -->
  <!-- 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" direction="inout">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- http://pubs.opengroup.org/onlinepubs/000095399/functions/sigismember.html -->
  <!-- int sigismember(const sigset_t *set, int signum);-->
  <function name="sigismember">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <use-retval/>
    <arg nr="1" direction="in">
      <not-null/>
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/posix_spawn.html -->
  <!-- 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="1" direction="out"/>
    <arg nr="2" direction="in"/>
    <arg nr="3" direction="in"/>
    <arg nr="4" direction="in"/>
    <arg nr="5"/>
    <arg nr="6">
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/msgctl.html -->
  <!-- int msgctl(int msqid, int cmd, struct msqid_ds *buf); -->
  <function name="msgctl">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3">
      <!-- direction (in/out) depends on the value of arg2 "cmd" -->
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/msgget.html -->
  <!-- int msgget(key_t key, int msgflg);-->
  <function name="msgget">
    <returnValue type="int"/>
    <noreturn>false</noreturn>
    <use-retval/>
    <arg nr="1" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/msgrcv.html -->
  <!-- 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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="out">
      <not-null/>
      <minsize type="argvalue" arg="3"/>
      <!-- TODO: sizeof(long) must be added to this value, but this can not be configured yet -->
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <arg nr="4" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="5" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/msgsnd.html -->
  <!-- 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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-null/>
      <not-uninit/>
      <minsize type="argvalue" arg="3"/>
      <!-- TODO: sizeof(long) must be added to this value, but this can not be configured yet -->
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <arg nr="4" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcsendbreak.html -->
  <!-- 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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcgetattr.html -->
  <!-- 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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="out">
      <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" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <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" direction="inout">
      <not-uninit/>
      <not-null/>
    </arg>
    <arg nr="2" direction="in">
      <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" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- These are defined as macros http://man7.org/linux/man-pages/man7/inode.7.html -->
  <!-- It is better to configure them as functions -->
  <function name="S_ISREG,S_ISDIR,S_ISCHR,S_ISBLK,S_ISFIFO,S_ISLNK,S_ISSOCK">
    <returnValue type="int"/>
    <use-retval/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1" direction="in">
      <not-uninit/>
      <not-bool/>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/swab.html -->
  <!-- void swab(const void * src, void* dest, ssize_t bytes); -->
  <function name="swab">
    <returnValue type="void"/>
    <noreturn>false</noreturn>
    <leak-ignore/>
    <arg nr="1" direction="in">
      <not-uninit/>
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="2" direction="out">
      <not-null/>
      <minsize type="argvalue" arg="3"/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
  </function>
  <!-- void sync(void); -->
  <function name="sync">
    <returnValue type="void"/>
    <noreturn>false</noreturn>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/gethostname.html -->
  <!-- int gethostname(char *name, size_t len); -->
  <function name="gethostname">
    <noreturn>false</noreturn>
    <returnValue type="int"/>
    <leak-ignore/>
    <arg nr="1" direction="out">
      <not-null/>
      <minsize type="argvalue" arg="2"/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
      <valid>1:</valid>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/posix_memalign.html -->
  <!-- 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" direction="out">
      <not-null/>
    </arg>
    <arg nr="2" direction="in">
      <not-uninit/>
    </arg>
    <arg nr="3" direction="in">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
  </function>
  <!-- https://pubs.opengroup.org/onlinepubs/7908799/xsh/valloc.html -->
  <!-- void *valloc(size_t size); -->
  <function name="valloc">
    <use-retval/>
    <returnValue type="void *"/>
    <noreturn>false</noreturn>
    <arg nr="1" direction="in">
      <not-uninit/>
      <valid>0:</valid>
    </arg>
    <warn severity="style" alternatives="malloc,mmap" reason="Obsolete"/>
  </function>
  <memory>
    <alloc init="false" buffer-size="malloc">valloc</alloc>
    <dealloc>free</dealloc>
  </memory>
  <memory>
    <alloc init="false" arg="1">posix_memalign</alloc>
    <dealloc>free</dealloc>
  </memory>
  <memory>
    <alloc init="true" buffer-size="strdup">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="nfds_t" sign="u"/>
  <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"/>
  <!-- struct: <podtype name="dirent"/> -->
  <!-- struct: <podtype name="DIR"/> -->
  <podtype name="clockid_t"/>
  <podtype name="dev_t"/>
  <podtype name="key_t"/>
  <podtype name="tms"/>
  <!-- struct: <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"/>
  <!-- struct: <podtype name="timeval"/> -->
  <podtype name="timezone"/>
  <!-- struct: <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"/>
  <define name="S_IFMT" value="0170000"/>
  <define name="S_IFSOCK" value="0140000"/>
  <define name="S_IFLNK" value="0120000"/>
  <define name="S_IFREG" value="0100000"/>
  <define name="S_IFBLK" value="0060000"/>
  <define name="S_IFDIR" value="0040000"/>
  <define name="S_IFCHR" value="0020000"/>
  <define name="S_IFIFO" value="0010000"/>
</def>