kc3-lang/SDL/src/stdlib/SDL_stdlib.c

• Show log

  Commit

• Hash : e2fd1c0f
  Author :
  Date : 2016-01-02T11:17:06
  

  Backed out commit 80ce90dbc266, this causes Visual Studio build failure on buildbot
  

Download

• src/stdlib/SDL_stdlib.c

• /*
    Simple DirectMedia Layer
    Copyright (C) 1997-2016 Sam Lantinga <slouken@libsdl.org>
  
    This software is provided 'as-is', without any express or implied
    warranty.  In no event will the authors be held liable for any damages
    arising from the use of this software.
  
    Permission is granted to anyone to use this software for any purpose,
    including commercial applications, and to alter it and redistribute it
    freely, subject to the following restrictions:
  
    1. The origin of this software must not be misrepresented; you must not
       claim that you wrote the original software. If you use this software
       in a product, an acknowledgment in the product documentation would be
       appreciated but is not required.
    2. Altered source versions must be plainly marked as such, and must not be
       misrepresented as being the original software.
    3. This notice may not be removed or altered from any source distribution.
  */
  
  #if defined(__clang_analyzer__) && !defined(SDL_DISABLE_ANALYZE_MACROS)
  #define SDL_DISABLE_ANALYZE_MACROS 1
  #endif
  
  #include "../SDL_internal.h"
  
  /* This file contains portable stdlib functions for SDL */
  
  #include "SDL_stdinc.h"
  #include "../libm/math_libm.h"
  
  
  double
  SDL_atan(double x)
  {
  #ifdef HAVE_ATAN
      return atan(x);
  #else
      return SDL_uclibc_atan(x);
  #endif /* HAVE_ATAN */
  }
  
  double
  SDL_atan2(double x, double y)
  {
  #if defined(HAVE_ATAN2)
      return atan2(x, y);
  #else
      return SDL_uclibc_atan2(x, y);
  #endif /* HAVE_ATAN2 */
  }
  
  double
  SDL_acos(double val)
  {
  #if defined(HAVE_ACOS)
      return acos(val);
  #else
      double result;
      if (val == -1.0) {
          result = M_PI;
      } else {
          result = SDL_atan(SDL_sqrt(1.0 - val * val) / val);
          if (result < 0.0)
          {
              result += M_PI;
          }
      }
      return result;
  #endif
  }
  
  double
  SDL_asin(double val)
  {
  #if defined(HAVE_ASIN)
      return asin(val);
  #else
      double result;
      if (val == -1.0) {
          result = -(M_PI / 2.0);
      } else {
          result = (M_PI / 2.0) - SDL_acos(val);
      }
      return result;
  #endif
  }
  
  double
  SDL_ceil(double x)
  {
  #ifdef HAVE_CEIL
      return ceil(x);
  #else
      double integer = SDL_floor(x);
      double fraction = x - integer;
      if (fraction > 0.0) {
          integer += 1.0;
      }
      return integer;
  #endif /* HAVE_CEIL */
  }
  
  double
  SDL_copysign(double x, double y)
  {
  #if defined(HAVE_COPYSIGN)
      return copysign(x, y);
  #elif defined(HAVE__COPYSIGN)
      return _copysign(x, y);
  #else
      return SDL_uclibc_copysign(x, y);
  #endif /* HAVE_COPYSIGN */
  }
  
  double
  SDL_cos(double x)
  {
  #if defined(HAVE_COS)
      return cos(x);
  #else
      return SDL_uclibc_cos(x);
  #endif /* HAVE_COS */
  }
  
  float
  SDL_cosf(float x)
  {
  #ifdef HAVE_COSF
      return cosf(x);
  #else
      return (float)SDL_cos((double)x);
  #endif
  }
  
  double
  SDL_fabs(double x)
  {
  #if defined(HAVE_FABS)
      return fabs(x); 
  #else
      return SDL_uclibc_fabs(x);
  #endif /* HAVE_FABS */
  }
  
  double
  SDL_floor(double x)
  {
  #if defined(HAVE_FLOOR)
      return floor(x);
  #else
      return SDL_uclibc_floor(x);
  #endif /* HAVE_FLOOR */
  }
  
  double
  SDL_log(double x)
  {
  #if defined(HAVE_LOG)
      return log(x);
  #else
      return SDL_uclibc_log(x);
  #endif /* HAVE_LOG */
  }
  
  double
  SDL_pow(double x, double y)
  {
  #if defined(HAVE_POW)
      return pow(x, y);
  #else
      return SDL_uclibc_pow(x, y);
  #endif /* HAVE_POW */
  }
  
  double
  SDL_scalbn(double x, int n)
  {
  #if defined(HAVE_SCALBN)
      return scalbn(x, n);
  #elif defined(HAVE__SCALB)
      return _scalb(x, n);
  #else
      return SDL_uclibc_scalbn(x, n);
  #endif /* HAVE_SCALBN */
  }
  
  double
  SDL_sin(double x)
  {
  #if defined(HAVE_SIN)
      return sin(x);
  #else
      return SDL_uclibc_sin(x);
  #endif /* HAVE_SIN */
  }
  
  float 
  SDL_sinf(float x)
  {
  #ifdef HAVE_SINF
      return sinf(x);
  #else
      return (float)SDL_sin((double)x);
  #endif /* HAVE_SINF */
  }
  
  double
  SDL_sqrt(double x)
  {
  #if defined(HAVE_SQRT)
      return sqrt(x);
  #else
      return SDL_uclibc_sqrt(x);
  #endif
  }
  
  float
  SDL_sqrtf(float x)
  {
  #if defined(HAVE_SQRTF)
      return sqrtf(x);
  #else
      return (float)SDL_sqrt((double)x);
  #endif
  }
  
  double
  SDL_tan(double x)
  {
  #if defined(HAVE_TAN)
      return tan(x);
  #else
      return SDL_uclibc_tan(x);
  #endif
  }
  
  float
  SDL_tanf(float x)
  {
  #if defined(HAVE_TANF)
      return tanf(x);
  #else
      return (float)SDL_tan((double)x);
  #endif
  }
  
  int SDL_abs(int x)
  {
  #ifdef HAVE_ABS
      return abs(x);
  #else
      return ((x) < 0 ? -(x) : (x));
  #endif
  }
  
  #ifdef HAVE_CTYPE_H
  int SDL_isdigit(int x) { return isdigit(x); }
  int SDL_isspace(int x) { return isspace(x); }
  int SDL_toupper(int x) { return toupper(x); }
  int SDL_tolower(int x) { return tolower(x); }
  #else
  int SDL_isdigit(int x) { return ((x) >= '0') && ((x) <= '9'); }
  int SDL_isspace(int x) { return ((x) == ' ') || ((x) == '\t') || ((x) == '\r') || ((x) == '\n') || ((x) == '\f') || ((x) == '\v'); }
  int SDL_toupper(int x) { return ((x) >= 'a') && ((x) <= 'z') ? ('A'+((x)-'a')) : (x); }
  int SDL_tolower(int x) { return ((x) >= 'A') && ((x) <= 'Z') ? ('a'+((x)-'A')) : (x); }
  #endif
  
  
  #ifndef HAVE_LIBC
  /* These are some C runtime intrinsics that need to be defined */
  
  #if defined(_MSC_VER)
  
  #ifndef __FLTUSED__
  #define __FLTUSED__
  __declspec(selectany) int _fltused = 1;
  #endif
  
  /* The optimizer on Visual Studio 2005 and later generates memcpy() calls */
  #if (_MSC_VER >= 1400) && defined(_WIN64) && !defined(_DEBUG)
  #include <intrin.h>
  
  #pragma function(memcpy)
  void * memcpy ( void * destination, const void * source, size_t num )
  {
      const Uint8 *src = (const Uint8 *)source;
      Uint8 *dst = (Uint8 *)destination;
      size_t i;
      
      /* All WIN64 architectures have SSE, right? */
      if (!((uintptr_t) src & 15) && !((uintptr_t) dst & 15)) {
          __m128 values[4];
          for (i = num / 64; i--;) {
              _mm_prefetch(src, _MM_HINT_NTA);
              values[0] = *(__m128 *) (src + 0);
              values[1] = *(__m128 *) (src + 16);
              values[2] = *(__m128 *) (src + 32);
              values[3] = *(__m128 *) (src + 48);
              _mm_stream_ps((float *) (dst + 0), values[0]);
              _mm_stream_ps((float *) (dst + 16), values[1]);
              _mm_stream_ps((float *) (dst + 32), values[2]);
              _mm_stream_ps((float *) (dst + 48), values[3]);
              src += 64;
              dst += 64;
          }
          num &= 63;
      }
  
      while (num--) {
          *dst++ = *src++;
      }
      return destination;
  }
  #endif /* _MSC_VER == 1600 && defined(_WIN64) && !defined(_DEBUG) */
  
  #ifdef _M_IX86
  
  /* Float to long */
  void
  __declspec(naked)
  _ftol()
  {
      /* *INDENT-OFF* */
      __asm {
          push        ebp
          mov         ebp,esp
          sub         esp,20h
          and         esp,0FFFFFFF0h
          fld         st(0)
          fst         dword ptr [esp+18h]
          fistp       qword ptr [esp+10h]
          fild        qword ptr [esp+10h]
          mov         edx,dword ptr [esp+18h]
          mov         eax,dword ptr [esp+10h]
          test        eax,eax
          je          integer_QnaN_or_zero
  arg_is_not_integer_QnaN:
          fsubp       st(1),st
          test        edx,edx
          jns         positive
          fstp        dword ptr [esp]
          mov         ecx,dword ptr [esp]
          xor         ecx,80000000h
          add         ecx,7FFFFFFFh
          adc         eax,0
          mov         edx,dword ptr [esp+14h]
          adc         edx,0
          jmp         localexit
  positive:
          fstp        dword ptr [esp]
          mov         ecx,dword ptr [esp]
          add         ecx,7FFFFFFFh
          sbb         eax,0
          mov         edx,dword ptr [esp+14h]
          sbb         edx,0
          jmp         localexit
  integer_QnaN_or_zero:
          mov         edx,dword ptr [esp+14h]
          test        edx,7FFFFFFFh
          jne         arg_is_not_integer_QnaN
          fstp        dword ptr [esp+18h]
          fstp        dword ptr [esp+18h]
  localexit:
          leave
          ret
      }
      /* *INDENT-ON* */
  }
  
  void
  _ftol2_sse()
  {
      _ftol();
  }
  
  /* 64-bit math operators for 32-bit systems */
  void
  __declspec(naked)
  _allmul()
  {
      /* *INDENT-OFF* */
      __asm {
          mov         eax, dword ptr[esp+8]
          mov         ecx, dword ptr[esp+10h]
          or          ecx, eax
          mov         ecx, dword ptr[esp+0Ch]
          jne         hard
          mov         eax, dword ptr[esp+4]
          mul         ecx
          ret         10h
  hard:
          push        ebx
          mul         ecx
          mov         ebx, eax
          mov         eax, dword ptr[esp+8]
          mul         dword ptr[esp+14h]
          add         ebx, eax
          mov         eax, dword ptr[esp+8]
          mul         ecx
          add         edx, ebx
          pop         ebx
          ret         10h
      }
      /* *INDENT-ON* */
  }
  
  void
  __declspec(naked)
  _alldiv()
  {
      /* *INDENT-OFF* */
      __asm {
          push        edi
          push        esi
          push        ebx
          xor         edi,edi
          mov         eax,dword ptr [esp+14h]
          or          eax,eax
          jge         L1
          inc         edi
          mov         edx,dword ptr [esp+10h]
          neg         eax
          neg         edx
          sbb         eax,0
          mov         dword ptr [esp+14h],eax
          mov         dword ptr [esp+10h],edx
  L1:
          mov         eax,dword ptr [esp+1Ch]
          or          eax,eax
          jge         L2
          inc         edi
          mov         edx,dword ptr [esp+18h]
          neg         eax
          neg         edx
          sbb         eax,0
          mov         dword ptr [esp+1Ch],eax
          mov         dword ptr [esp+18h],edx
  L2:
          or          eax,eax
          jne         L3
          mov         ecx,dword ptr [esp+18h]
          mov         eax,dword ptr [esp+14h]
          xor         edx,edx
          div         ecx
          mov         ebx,eax
          mov         eax,dword ptr [esp+10h]
          div         ecx
          mov         edx,ebx
          jmp         L4
  L3:
          mov         ebx,eax
          mov         ecx,dword ptr [esp+18h]
          mov         edx,dword ptr [esp+14h]
          mov         eax,dword ptr [esp+10h]
  L5:
          shr         ebx,1
          rcr         ecx,1
          shr         edx,1
          rcr         eax,1
          or          ebx,ebx
          jne         L5
          div         ecx
          mov         esi,eax
          mul         dword ptr [esp+1Ch]
          mov         ecx,eax
          mov         eax,dword ptr [esp+18h]
          mul         esi
          add         edx,ecx
          jb          L6
          cmp         edx,dword ptr [esp+14h]
          ja          L6
          jb          L7
          cmp         eax,dword ptr [esp+10h]
          jbe         L7
  L6:
          dec         esi
  L7:
          xor         edx,edx
          mov         eax,esi
  L4:
          dec         edi
          jne         L8
          neg         edx
          neg         eax
          sbb         edx,0
  L8:
          pop         ebx
          pop         esi
          pop         edi
          ret         10h
      }
      /* *INDENT-ON* */
  }
  
  void
  __declspec(naked)
  _aulldiv()
  {
      /* *INDENT-OFF* */
      __asm {
          push        ebx
          push        esi
          mov         eax,dword ptr [esp+18h]
          or          eax,eax
          jne         L1
          mov         ecx,dword ptr [esp+14h]
          mov         eax,dword ptr [esp+10h]
          xor         edx,edx
          div         ecx
          mov         ebx,eax
          mov         eax,dword ptr [esp+0Ch]
          div         ecx
          mov         edx,ebx
          jmp         L2
  L1:
          mov         ecx,eax
          mov         ebx,dword ptr [esp+14h]
          mov         edx,dword ptr [esp+10h]
          mov         eax,dword ptr [esp+0Ch]
  L3:
          shr         ecx,1
          rcr         ebx,1
          shr         edx,1
          rcr         eax,1
          or          ecx,ecx
          jne         L3
          div         ebx
          mov         esi,eax
          mul         dword ptr [esp+18h]
          mov         ecx,eax
          mov         eax,dword ptr [esp+14h]
          mul         esi
          add         edx,ecx
          jb          L4
          cmp         edx,dword ptr [esp+10h]
          ja          L4
          jb          L5
          cmp         eax,dword ptr [esp+0Ch]
          jbe         L5
  L4:
          dec         esi
  L5:
          xor         edx,edx
          mov         eax,esi
  L2:
          pop         esi
          pop         ebx
          ret         10h
      }
      /* *INDENT-ON* */
  }
  
  void
  __declspec(naked)
  _allrem()
  {
      /* *INDENT-OFF* */
      __asm {
          push        ebx
          push        edi
          xor         edi,edi
          mov         eax,dword ptr [esp+10h]
          or          eax,eax
          jge         L1
          inc         edi
          mov         edx,dword ptr [esp+0Ch]
          neg         eax
          neg         edx
          sbb         eax,0
          mov         dword ptr [esp+10h],eax
          mov         dword ptr [esp+0Ch],edx
  L1:
          mov         eax,dword ptr [esp+18h]
          or          eax,eax
          jge         L2
          mov         edx,dword ptr [esp+14h]
          neg         eax
          neg         edx
          sbb         eax,0
          mov         dword ptr [esp+18h],eax
          mov         dword ptr [esp+14h],edx
  L2:
          or          eax,eax
          jne         L3
          mov         ecx,dword ptr [esp+14h]
          mov         eax,dword ptr [esp+10h]
          xor         edx,edx
          div         ecx
          mov         eax,dword ptr [esp+0Ch]
          div         ecx
          mov         eax,edx
          xor         edx,edx
          dec         edi
          jns         L4
          jmp         L8
  L3:
          mov         ebx,eax
          mov         ecx,dword ptr [esp+14h]
          mov         edx,dword ptr [esp+10h]
          mov         eax,dword ptr [esp+0Ch]
  L5:
          shr         ebx,1
          rcr         ecx,1
          shr         edx,1
          rcr         eax,1
          or          ebx,ebx
          jne         L5
          div         ecx
          mov         ecx,eax
          mul         dword ptr [esp+18h]
          xchg        eax,ecx
          mul         dword ptr [esp+14h]
          add         edx,ecx
          jb          L6
          cmp         edx,dword ptr [esp+10h]
          ja          L6
          jb          L7
          cmp         eax,dword ptr [esp+0Ch]
          jbe         L7
  L6:
          sub         eax,dword ptr [esp+14h]
          sbb         edx,dword ptr [esp+18h]
  L7:
          sub         eax,dword ptr [esp+0Ch]
          sbb         edx,dword ptr [esp+10h]
          dec         edi
          jns         L8
  L4:
          neg         edx
          neg         eax
          sbb         edx,0
  L8:
          pop         edi
          pop         ebx
          ret         10h
      }
      /* *INDENT-ON* */
  }
  
  void
  __declspec(naked)
  _aullrem()
  {
      /* *INDENT-OFF* */
      __asm {
          push        ebx
          mov         eax,dword ptr [esp+14h]
          or          eax,eax
          jne         L1
          mov         ecx,dword ptr [esp+10h]
          mov         eax,dword ptr [esp+0Ch]
          xor         edx,edx
          div         ecx
          mov         eax,dword ptr [esp+8]
          div         ecx
          mov         eax,edx
          xor         edx,edx
          jmp         L2
  L1:
          mov         ecx,eax
          mov         ebx,dword ptr [esp+10h]
          mov         edx,dword ptr [esp+0Ch]
          mov         eax,dword ptr [esp+8]
  L3:
          shr         ecx,1
          rcr         ebx,1
          shr         edx,1
          rcr         eax,1
          or          ecx,ecx
          jne         L3
          div         ebx
          mov         ecx,eax
          mul         dword ptr [esp+14h]
          xchg        eax,ecx
          mul         dword ptr [esp+10h]
          add         edx,ecx
          jb          L4
          cmp         edx,dword ptr [esp+0Ch]
          ja          L4
          jb          L5
          cmp         eax,dword ptr [esp+8]
          jbe         L5
  L4:
          sub         eax,dword ptr [esp+10h]
          sbb         edx,dword ptr [esp+14h]
  L5:
          sub         eax,dword ptr [esp+8]
          sbb         edx,dword ptr [esp+0Ch]
          neg         edx
          neg         eax
          sbb         edx,0
  L2:
          pop         ebx
          ret         10h
      }
      /* *INDENT-ON* */
  }
  
  void
  __declspec(naked)
  _alldvrm()
  {
      /* *INDENT-OFF* */
      __asm {
          push        edi
          push        esi
          push        ebp
          xor         edi,edi
          xor         ebp,ebp
          mov         eax,dword ptr [esp+14h]
          or          eax,eax
          jge         L1
          inc         edi
          inc         ebp
          mov         edx,dword ptr [esp+10h]
          neg         eax
          neg         edx
          sbb         eax,0
          mov         dword ptr [esp+14h],eax
          mov         dword ptr [esp+10h],edx
  L1:
          mov         eax,dword ptr [esp+1Ch]
          or          eax,eax
          jge         L2
          inc         edi
          mov         edx,dword ptr [esp+18h]
          neg         eax
          neg         edx
          sbb         eax,0
          mov         dword ptr [esp+1Ch],eax
          mov         dword ptr [esp+18h],edx
  L2:
          or          eax,eax
          jne         L3
          mov         ecx,dword ptr [esp+18h]
          mov         eax,dword ptr [esp+14h]
          xor         edx,edx
          div         ecx
          mov         ebx,eax
          mov         eax,dword ptr [esp+10h]
          div         ecx
          mov         esi,eax
          mov         eax,ebx
          mul         dword ptr [esp+18h]
          mov         ecx,eax
          mov         eax,esi
          mul         dword ptr [esp+18h]
          add         edx,ecx
          jmp         L4
  L3:
          mov         ebx,eax
          mov         ecx,dword ptr [esp+18h]
          mov         edx,dword ptr [esp+14h]
          mov         eax,dword ptr [esp+10h]
  L5:
          shr         ebx,1
          rcr         ecx,1
          shr         edx,1
          rcr         eax,1
          or          ebx,ebx
          jne         L5
          div         ecx
          mov         esi,eax
          mul         dword ptr [esp+1Ch]
          mov         ecx,eax
          mov         eax,dword ptr [esp+18h]
          mul         esi
          add         edx,ecx
          jb          L6
          cmp         edx,dword ptr [esp+14h]
          ja          L6
          jb          L7
          cmp         eax,dword ptr [esp+10h]
          jbe         L7
  L6:
          dec         esi
          sub         eax,dword ptr [esp+18h]
          sbb         edx,dword ptr [esp+1Ch]
  L7:
          xor         ebx,ebx
  L4:
          sub         eax,dword ptr [esp+10h]
          sbb         edx,dword ptr [esp+14h]
          dec         ebp
          jns         L9
          neg         edx
          neg         eax
          sbb         edx,0
  L9:
          mov         ecx,edx
          mov         edx,ebx
          mov         ebx,ecx
          mov         ecx,eax
          mov         eax,esi
          dec         edi
          jne         L8
          neg         edx
          neg         eax
          sbb         edx,0
  L8:
          pop         ebp
          pop         esi
          pop         edi
          ret         10h
      }
      /* *INDENT-ON* */
  }
  
  void
  __declspec(naked)
  _aulldvrm()
  {
      /* *INDENT-OFF* */
      __asm {
          push        esi
          mov         eax,dword ptr [esp+14h]
          or          eax,eax
          jne         L1
          mov         ecx,dword ptr [esp+10h]
          mov         eax,dword ptr [esp+0Ch]
          xor         edx,edx
          div         ecx
          mov         ebx,eax
          mov         eax,dword ptr [esp+8]
          div         ecx
          mov         esi,eax
          mov         eax,ebx
          mul         dword ptr [esp+10h]
          mov         ecx,eax
          mov         eax,esi
          mul         dword ptr [esp+10h]
          add         edx,ecx
          jmp         L2
  L1:
          mov         ecx,eax
          mov         ebx,dword ptr [esp+10h]
          mov         edx,dword ptr [esp+0Ch]
          mov         eax,dword ptr [esp+8]
  L3:
          shr         ecx,1
          rcr         ebx,1
          shr         edx,1
          rcr         eax,1
          or          ecx,ecx
          jne         L3
          div         ebx
          mov         esi,eax
          mul         dword ptr [esp+14h]
          mov         ecx,eax
          mov         eax,dword ptr [esp+10h]
          mul         esi
          add         edx,ecx
          jb          L4
          cmp         edx,dword ptr [esp+0Ch]
          ja          L4
          jb          L5
          cmp         eax,dword ptr [esp+8]
          jbe         L5
  L4:
          dec         esi
          sub         eax,dword ptr [esp+10h]
          sbb         edx,dword ptr [esp+14h]
  L5:
          xor         ebx,ebx
  L2:
          sub         eax,dword ptr [esp+8]
          sbb         edx,dword ptr [esp+0Ch]
          neg         edx
          neg         eax
          sbb         edx,0
          mov         ecx,edx
          mov         edx,ebx
          mov         ebx,ecx
          mov         ecx,eax
          mov         eax,esi
          pop         esi
          ret         10h
      }
      /* *INDENT-ON* */
  }
  
  void
  __declspec(naked)
  _allshl()
  {
      /* *INDENT-OFF* */
      __asm {
          cmp         cl,40h
          jae         RETZERO
          cmp         cl,20h
          jae         MORE32
          shld        edx,eax,cl
          shl         eax,cl
          ret
  MORE32:
          mov         edx,eax
          xor         eax,eax
          and         cl,1Fh
          shl         edx,cl
          ret
  RETZERO:
          xor         eax,eax
          xor         edx,edx
          ret
      }
      /* *INDENT-ON* */
  }
  
  void
  __declspec(naked)
  _allshr()
  {
      /* *INDENT-OFF* */
      __asm {
          cmp         cl,40h
          jae         RETZERO
          cmp         cl,20h
          jae         MORE32
          shrd        eax,edx,cl
          sar         edx,cl
          ret
  MORE32:
          mov         eax,edx
          xor         edx,edx
          and         cl,1Fh
          sar         eax,cl
          ret
  RETZERO:
          xor         eax,eax
          xor         edx,edx
          ret
      }
      /* *INDENT-ON* */
  }
  
  void
  __declspec(naked)
  _aullshr()
  {
      /* *INDENT-OFF* */
      __asm {
          cmp         cl,40h
          jae         RETZERO
          cmp         cl,20h
          jae         MORE32
          shrd        eax,edx,cl
          shr         edx,cl
          ret
  MORE32:
          mov         eax,edx
          xor         edx,edx
          and         cl,1Fh
          shr         eax,cl
          ret
  RETZERO:
          xor         eax,eax
          xor         edx,edx
          ret
      }
      /* *INDENT-ON* */
  }
  
  #endif /* _M_IX86 */
  
  #endif /* MSC_VER */
  
  #endif /* !HAVE_LIBC */
  
  /* vi: set ts=4 sw=4 expandtab: */
  

Download