/*

* Copyright (c) 2010 Ixonos Plc.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - Initial contribution

*

* Contributors:

* Ixonos Plc

*

* Description:  

* Wrappers for Symbian OS -specific system functions.

*

*/

#include <e32base.h>

#include <s32file.h>

#include "nrctyp32.h"

#include "epoclib.h"

#define NAMELEN 120

#define EL_EXPORT

EL_EXPORT void free(TAny *ptr)

    {

#ifdef MALLOC_DEBUG        

    if ( !ptr )

        return;

    unsigned *p32 = (unsigned*) (((unsigned) ptr) - (NAMELEN+8));

    if ( p32[0] != 0xdaded1d0 )

        User::Panic(_L("BadFree"), 1);

    ptr = (TAny*) p32;

#endif

    //  Dangling pointer check

//    User::Free(ptr);

    unsigned count = (unsigned) User::AllocLen(ptr);

    TUint8 *p;

    p = (TUint8*) ptr;

    while ( count >> 2 )

    {

        *((TUint32*)p) = 0xfeedf1d0;

        p += 4;

        count -= 4;

    }

    while ( count )

    {

        *(p++) = 0x17;

        count--;

    }

    User::Free(ptr);

    }

#ifdef MALLOC_DEBUG

EL_EXPORT TAny *debugMalloc(u_int32 size, char *file, int line)

#else    

EL_EXPORT TAny *malloc(u_int32 size)

#endif    

    {

    // Uninit checks        

//    return User::AllocL(size);

    TAny *ptr;

    unsigned count = size;

    TUint8 *p;

#ifdef MALLOC_DEBUG

    ptr = User::AllocL(size + NAMELEN+8);

    p = ((TUint8*) ptr) + NAMELEN+8;

#else

    ptr = User::AllocL(size);

    p = (TUint8*) ptr;

#endif    

    while ( count >> 2 )

    {

        *((TUint32*)p) = 0xdeadbeef;

        p += 4;

        count -= 4;

    }

    while ( count )

    {

        *(p++) = 0x42;

        count--;

    }

#ifdef MALLOC_DEBUG

    unsigned *p32 = (unsigned*) ptr;

    p32[0] = 0xdaded1d0;

    p32[1] = (unsigned) line;

    char *c = (char*) &p32[2];

    int n = NAMELEN;

    while ( (*file != 0) && n )

    {

        *(c++) = *(file++);

        n--;

    }

    return (TAny*) (((unsigned) p32) + NAMELEN + 8);

#else  

    return ptr;

#endif    

    }

EL_EXPORT TAny *realloc(void *memblock, u_int32 size)

    {

#ifdef MALLOC_DEBUG

    unsigned *p32 = (unsigned*) (((unsigned) memblock) - NAMELEN - 8);

    if ( p32[0] != 0xdaded1d0 )

        User::Panic(_L("BadRealloc"), 1);

    p32 = (unsigned*) User::ReAllocL((void*) p32, size+NAMELEN+8);

    return (TAny*) (((unsigned) p32) + NAMELEN + 8);

#else

    return User::ReAllocL(memblock, size);

#endif    

    }

#ifdef MALLOC_DEBUG

EL_EXPORT TAny *debugCalloc(u_int32 num, u_int32 size, char *file, int line)

{

    TAny *ptr;

    TUint8 *p;

    ptr = User::Alloc(num*size + NAMELEN+8);

    if ( !ptr )

        return 0;

    p = ((TUint8*) ptr) + NAMELEN+8;

    Mem::Fill(p, size*num, 0);

    unsigned *p32 = (unsigned*) ptr;

    p32[0] = 0xdaded1d0;

    p32[1] = (unsigned) line;

    char *c = (char*) &p32[2];

    int n = NAMELEN;

    while ( (*file != 0) && n )

    {

        *(c++) = *(file++);

        n--;

    }

    return (TAny*) p;

}

#else    

EL_EXPORT TAny *calloc(u_int32 num, u_int32 size)

    {

    TAny *dest = User::Alloc(size*num);

    Mem::Fill(dest, size*num, 0);

    return dest;

    }

#endif

EL_EXPORT TAny *memset(TAny *dest, TInt c, u_int32 size)

    {

    Mem::Fill(dest, size, c);

    return dest; //returning the value of dest as in windows

    }

EL_EXPORT TAny *memcpy(TAny *dest, const TAny *src, u_int32 size)

    {

    Mem::Copy(dest, src, size);

    return dest;

    }

EL_EXPORT TAny *memmove(TAny *dest, const TAny *src, u_int32 count)

    {

    Mem::Copy(dest,src,count);

    return dest;

    }

long atol(

        const char *nptr

        )

{

        int c;              // current char 

        long total;         // current total 

        int sign;           // if '-', then negative, otherwise positive 

        TLex8 string((unsigned char *)nptr);

        // skip whitespace 

        string.SkipSpace();

        //prendre un caratere dans string lui faire le sign

        c = (int)string.Peek();

        string.Inc();

        sign = c;           // save sign indication 

        if (c == '-' || c == '+')

        // skip sign 

            {c = (int)string.Peek();

              string.Inc();

            }

        else //If c is not a sign, it is necessary to go increment back into the descriptors to get the right

             //number 

            {

            string.UnGet();

            }

        total = 0;

        while (string.Peek().IsDigit())

            {

            total = 10 * total + (c - '0');

            string.Inc();

            c = (int)string.Peek();

            }

        if (sign == '-')

            return -total;

        else

            return total;   /* return result, negated if necessary */

}

/*

*int atoi(char *nptr) - Convert string to long

*

*Purpose:

*       Converts ASCII string pointed to by nptr to binary.

*       Overflow is not detected.  Because of this, we can just use

*       atol().

*

*Entry:

*       nptr = ptr to string to convert

*

*Exit:

*       return int value of the string

*

*Exceptions:

*       None - overflow is not detected.

*

*******************************************************************************/

EL_EXPORT int atoi(

        const char *nptr

        )

{

        return (int)atol(nptr);

}

// End of File