/*

  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