text: /*
   * Wine porting definitions
   *
   * Copyright 1996 Alexandre Julliard
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
   * This library is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
   */
  
  #ifndef __WINE_WINE_PORT_H
  #define __WINE_WINE_PORT_H
  
  #ifndef __WINE_CONFIG_H
  # error You must include config.h to use this header
  #endif
  
  #ifdef __WINE_BASETSD_H
  # error You must include port.h before all other headers
  #endif
  
  #ifndef _GNU_SOURCE
  # define _GNU_SOURCE  /* for pread/pwrite, isfinite */
  #endif
  #include <fcntl.h>
  #include <math.h>
  #include <sys/types.h>
  #include <sys/stat.h>
  #ifdef HAVE_DIRECT_H
  # include <direct.h>
  #endif
  #ifdef HAVE_IO_H
  # include <io.h>
  #endif
  #ifdef HAVE_PROCESS_H
  # include <process.h>
  #endif
  #include <string.h>
  #include <stdlib.h>
  #ifdef HAVE_UNISTD_H
  # include <unistd.h>
  #endif
  
  
  /****************************************************************
   * Type definitions
   */
  
  #if !defined(_MSC_VER) && !defined(__int64)
  #  if defined(__x86_64__) || defined(__aarch64__) || defined(_WIN64)
  #    define __int64 long
  #  else
  #    define __int64 long long
  #  endif
  #endif
  
  #ifndef HAVE_MODE_T
  typedef int mode_t;
  #endif
  #ifndef HAVE_OFF_T
  typedef long off_t;
  #endif
  #ifndef HAVE_PID_T
  typedef int pid_t;
  #endif
  #ifndef HAVE_SIZE_T
  typedef unsigned int size_t;
  #endif
  #ifndef HAVE_SSIZE_T
  typedef int ssize_t;
  #endif
  #ifndef HAVE_FSBLKCNT_T
  typedef unsigned long fsblkcnt_t;
  #endif
  #ifndef HAVE_FSFILCNT_T
  typedef unsigned long fsfilcnt_t;
  #endif
  
  #ifndef HAVE_STRUCT_STATVFS_F_BLOCKS
  struct statvfs
  {
      unsigned long f_bsize;
      unsigned long f_frsize;
      fsblkcnt_t    f_blocks;
      fsblkcnt_t    f_bfree;
      fsblkcnt_t    f_bavail;
      fsfilcnt_t    f_files;
      fsfilcnt_t    f_ffree;
      fsfilcnt_t    f_favail;
      unsigned long f_fsid;
      unsigned long f_flag;
      unsigned long f_namemax;
  };
  #endif /* HAVE_STRUCT_STATVFS_F_BLOCKS */
  
  
  /****************************************************************
   * Macro definitions
   */
  
  #ifdef HAVE_DLFCN_H
  #include <dlfcn.h>
  #else
  #define RTLD_LAZY    0x001
  #define RTLD_NOW     0x002
  #define RTLD_GLOBAL  0x100
  #endif
  
  #ifdef HAVE_ONE_ARG_MKDIR
  #define mkdir(path,mode) mkdir(path)
  #endif
  
  #if !defined(HAVE_FTRUNCATE) && defined(HAVE_CHSIZE)
  #define ftruncate chsize
  #endif
  
  #if !defined(HAVE_POPEN) && defined(HAVE__POPEN)
  #define popen _popen
  #endif
  
  #if !defined(HAVE_PCLOSE) && defined(HAVE__PCLOSE)
  #define pclose _pclose
  #endif
  
  #if !defined(HAVE_STRDUP) && defined(HAVE__STRDUP)
  #define strdup _strdup
  #endif
  
  #if !defined(HAVE_SNPRINTF) && defined(HAVE__SNPRINTF)
  #define snprintf _snprintf
  #endif
  
  #if !defined(HAVE_VSNPRINTF) && defined(HAVE__VSNPRINTF)
  #define vsnprintf _vsnprintf
  #endif
  
  #if !defined(HAVE_STRTOLL) && defined(HAVE__STRTOI64)
  #define strtoll _strtoi64
  #endif
  
  #if !defined(HAVE_STRTOULL) && defined(HAVE__STRTOUI64)
  #define strtoull _strtoui64
  #endif
  
  #ifndef S_ISLNK
  # define S_ISLNK(mod) (0)
  #endif
  
  #ifndef S_ISSOCK
  # define S_ISSOCK(mod) (0)
  #endif
  
  #ifndef S_ISDIR
  # define S_ISDIR(mod) (((mod) & _S_IFMT) == _S_IFDIR)
  #endif
  
  #ifndef S_ISCHR
  # define S_ISCHR(mod) (((mod) & _S_IFMT) == _S_IFCHR)
  #endif
  
  #ifndef S_ISFIFO
  # define S_ISFIFO(mod) (((mod) & _S_IFMT) == _S_IFIFO)
  #endif
  
  #ifndef S_ISREG
  # define S_ISREG(mod) (((mod) & _S_IFMT) == _S_IFREG)
  #endif
  
  /* So we open files in 64 bit access mode on Linux */
  #ifndef O_LARGEFILE
  # define O_LARGEFILE 0
  #endif
  
  #ifndef O_NONBLOCK
  # define O_NONBLOCK 0
  #endif
  
  #ifndef O_BINARY
  # define O_BINARY 0
  #endif
  
  
  /****************************************************************
   * Constants
   */
  
  #ifndef M_PI
  #define M_PI 3.14159265358979323846
  #endif
  
  #ifndef M_PI_2
  #define M_PI_2 1.570796326794896619
  #endif
  
  #ifndef INFINITY
  static inline float __port_infinity(void)
  {
      static const unsigned __inf_bytes = 0x7f800000;
      return *(const float *)&__inf_bytes;
  }
  #define INFINITY __port_infinity()
  #endif
  
  #ifndef NAN
  static inline float __port_nan(void)
  {
      static const unsigned __nan_bytes = 0x7fc00000;
      return *(const float *)&__nan_bytes;
  }
  #define NAN __port_nan()
  #endif
  
  
  /****************************************************************
   * Function definitions (only when using libwine_port)
   */
  
  #ifndef NO_LIBWINE_PORT
  
  #ifndef HAVE_FSTATVFS
  int fstatvfs( int fd, struct statvfs *buf );
  #endif
  
  #ifndef HAVE_GETOPT_LONG_ONLY
  extern char *optarg;
  extern int optind;
  extern int opterr;
  extern int optopt;
  struct option;
  
  #ifndef HAVE_STRUCT_OPTION_NAME
  struct option
  {
      const char *name;
      int has_arg;
      int *flag;
      int val;
  };
  #endif
  
  extern int getopt_long (int ___argc, char *const *___argv,
                          const char *__shortopts,
                          const struct option *__longopts, int *__longind);
  extern int getopt_long_only (int ___argc, char *const *___argv,
                               const char *__shortopts,
                               const struct option *__longopts, int *__longind);
  #endif  /* HAVE_GETOPT_LONG_ONLY */
  
  #ifndef HAVE_FFS
  int ffs( int x );
  #endif
  
  #ifndef HAVE_ISFINITE
  int isfinite(double x);
  #endif
  
  #ifndef HAVE_ISINF
  int isinf(double x);
  #endif
  
  #ifndef HAVE_ISNAN
  int isnan(double x);
  #endif
  
  #ifndef HAVE_LSTAT
  int lstat(const char *file_name, struct stat *buf);
  #endif /* HAVE_LSTAT */
  
  #ifndef HAVE_MEMMOVE
  void *memmove(void *dest, const void *src, size_t len);
  #endif /* !defined(HAVE_MEMMOVE) */
  
  #ifndef HAVE_POLL
  struct pollfd
  {
      int fd;
      short events;
      short revents;
  };
  #define POLLIN   0x01
  #define POLLPRI  0x02
  #define POLLOUT  0x04
  #define POLLERR  0x08
  #define POLLHUP  0x10
  #define POLLNVAL 0x20
  int poll( struct pollfd *fds, unsigned int count, int timeout );
  #endif /* HAVE_POLL */
  
  #ifndef HAVE_PREAD
  ssize_t pread( int fd, void *buf, size_t count, off_t offset );
  #endif /* HAVE_PREAD */
  
  #ifndef HAVE_PWRITE
  ssize_t pwrite( int fd, const void *buf, size_t count, off_t offset );
  #endif /* HAVE_PWRITE */
  
  #ifndef HAVE_READLINK
  int readlink( const char *path, char *buf, size_t size );
  #endif /* HAVE_READLINK */
  
  #ifndef HAVE_STATVFS
  int statvfs( const char *path, struct statvfs *buf );
  #endif
  
  #ifndef HAVE_STRNCASECMP
  # ifndef HAVE__STRNICMP
  int strncasecmp(const char *str1, const char *str2, size_t n);
  # else
  # define strncasecmp _strnicmp
  # endif
  #endif /* !defined(HAVE_STRNCASECMP) */
  
  #ifndef HAVE_STRERROR
  const char *strerror(int err);
  #endif /* !defined(HAVE_STRERROR) */
  
  #ifndef HAVE_STRCASECMP
  # ifndef HAVE__STRICMP
  int strcasecmp(const char *str1, const char *str2);
  # else
  # define strcasecmp _stricmp
  # endif
  #endif /* !defined(HAVE_STRCASECMP) */
  
  #ifndef HAVE_SYMLINK
  int symlink(const char *from, const char *to);
  #endif
  
  #ifndef HAVE_USLEEP
  int usleep (unsigned int useconds);
  #endif /* !defined(HAVE_USLEEP) */
  
  #ifdef __i386__
  static inline void *memcpy_unaligned( void *dst, const void *src, size_t size )
  {
      return memcpy( dst, src, size );
  }
  #else
  extern void *memcpy_unaligned( void *dst, const void *src, size_t size );
  #endif /* __i386__ */
  
  extern int mkstemps(char *template, int suffix_len);
  
  /* Process creation flags */
  #ifndef _P_WAIT
  # define _P_WAIT    0
  # define _P_NOWAIT  1
  # define _P_OVERLAY 2
  # define _P_NOWAITO 3
  # define _P_DETACH  4
  #endif
  #ifndef HAVE__SPAWNVP
  extern int _spawnvp(int mode, const char *cmdname, const char * const argv[]);
  #endif
  
  /* Interlocked functions */
  
  #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
  
  extern __int64 interlocked_cmpxchg64( __int64 *dest, __int64 xchg, __int64 compare );
  
  static inline int interlocked_cmpxchg( int *dest, int xchg, int compare )
  {
      int ret;
      __asm__ __volatile__( "lock; cmpxchgl %2,(%1)"
                            : "=a" (ret) : "r" (dest), "r" (xchg), "0" (compare) : "memory" );
      return ret;
  }
  
  static inline void *interlocked_cmpxchg_ptr( void **dest, void *xchg, void *compare )
  {
      void *ret;
  #ifdef __x86_64__
      __asm__ __volatile__( "lock; cmpxchgq %2,(%1)"
                            : "=a" (ret) : "r" (dest), "r" (xchg), "0" (compare) : "memory" );
  #else
      __asm__ __volatile__( "lock; cmpxchgl %2,(%1)"
                            : "=a" (ret) : "r" (dest), "r" (xchg), "0" (compare) : "memory" );
  #endif
      return ret;
  }
  
  static inline int interlocked_xchg( int *dest, int val )
  {
      int ret;
      __asm__ __volatile__( "lock; xchgl %0,(%1)"
                            : "=r" (ret) : "r" (dest), "0" (val) : "memory" );
      return ret;
  }
  
  static inline void *interlocked_xchg_ptr( void **dest, void *val )
  {
      void *ret;
  #ifdef __x86_64__
      __asm__ __volatile__( "lock; xchgq %0,(%1)"
                            : "=r" (ret) :"r" (dest), "0" (val) : "memory" );
  #else
      __asm__ __volatile__( "lock; xchgl %0,(%1)"
                            : "=r" (ret) : "r" (dest), "0" (val) : "memory" );
  #endif
      return ret;
  }
  
  static inline int interlocked_xchg_add( int *dest, int incr )
  {
      int ret;
      __asm__ __volatile__( "lock; xaddl %0,(%1)"
                            : "=r" (ret) : "r" (dest), "0" (incr) : "memory" );
      return ret;
  }
  
  #ifdef __x86_64__
  static inline unsigned char interlocked_cmpxchg128( __int64 *dest, __int64 xchg_high,
                                                      __int64 xchg_low, __int64 *compare )
  {
      unsigned char ret;
      __asm__ __volatile__( "lock cmpxchg16b %0; setz %b2"
                            : "=m" (dest[0]), "=m" (dest[1]), "=r" (ret),
                              "=a" (compare[0]), "=d" (compare[1])
                            : "m" (dest[0]), "m" (dest[1]), "3" (compare[0]), "4" (compare[1]),
                              "c" (xchg_high), "b" (xchg_low) );
      return ret;
  }
  #endif
  
  #else  /* __GNUC__ */
  
  extern int interlocked_cmpxchg( int *dest, int xchg, int compare );
  extern void *interlocked_cmpxchg_ptr( void **dest, void *xchg, void *compare );
  extern __int64 interlocked_cmpxchg64( __int64 *dest, __int64 xchg, __int64 compare );
  extern int interlocked_xchg( int *dest, int val );
  extern void *interlocked_xchg_ptr( void **dest, void *val );
  extern int interlocked_xchg_add( int *dest, int incr );
  #if defined(__x86_64__) || defined(__aarch64__) || defined(_WIN64)
  extern unsigned char interlocked_cmpxchg128( __int64 *dest, __int64 xchg_high,
                                               __int64 xchg_low, __int64 *compare );
  #endif
  
  #endif  /* __GNUC__ */
  
  #else /* NO_LIBWINE_PORT */
  
  #define __WINE_NOT_PORTABLE(func) func##_is_not_portable func##_is_not_portable
  
  #define ffs                     __WINE_NOT_PORTABLE(ffs)
  #define fstatvfs                __WINE_NOT_PORTABLE(fstatvfs)
  #define getopt_long             __WINE_NOT_PORTABLE(getopt_long)
  #define getopt_long_only        __WINE_NOT_PORTABLE(getopt_long_only)
  #define interlocked_cmpxchg     __WINE_NOT_PORTABLE(interlocked_cmpxchg)
  #define interlocked_cmpxchg_ptr __WINE_NOT_PORTABLE(interlocked_cmpxchg_ptr)
  #define interlocked_xchg        __WINE_NOT_PORTABLE(interlocked_xchg)
  #define interlocked_xchg_ptr    __WINE_NOT_PORTABLE(interlocked_xchg_ptr)
  #define interlocked_xchg_add    __WINE_NOT_PORTABLE(interlocked_xchg_add)
  #define lstat                   __WINE_NOT_PORTABLE(lstat)
  #define memcpy_unaligned        __WINE_NOT_PORTABLE(memcpy_unaligned)
  #undef memmove
  #define memmove                 __WINE_NOT_PORTABLE(memmove)
  #define pread                   __WINE_NOT_PORTABLE(pread)
  #define pwrite                  __WINE_NOT_PORTABLE(pwrite)
  #define spawnvp                 __WINE_NOT_PORTABLE(spawnvp)
  #define statvfs                 __WINE_NOT_PORTABLE(statvfs)
  #define strcasecmp              __WINE_NOT_PORTABLE(strcasecmp)
  #define strerror                __WINE_NOT_PORTABLE(strerror)
  #define strncasecmp             __WINE_NOT_PORTABLE(strncasecmp)
  #define usleep                  __WINE_NOT_PORTABLE(usleep)
  
  #endif /* NO_LIBWINE_PORT */
  
  #endif /* !defined(__WINE_WINE_PORT_H) */
  