// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

//

// Description:

// This file implements the array helper functions defined in "C++ ABI for the ARM

// Architecture."

// 

//

#ifdef __KERNEL_MODE__

    #define RT_NO_EXCEPTIONS 1

#endif

// TODO:

//

// 1. If you prefer, you could use __KERNEL_MODE__ directly instead of

//    RT_NO_EXCEPTIONS.

// 2. If this code is only used kernel-side, you might delete all exception handling

//    code (thereby getting rid of any macro).

namespace std

{

    typedef unsigned size_t;

#if !RT_NO_EXCEPTIONS

    IMPORT_C void terminate();

#endif

}

using std::size_t;

namespace

{

    struct Cookie

    {

        size_t elem_size;

        size_t elem_count;

    };

    typedef void* (*Ctor)(void*);

    typedef void* (*Dtor)(void*);

    inline Cookie* _array_to_cookie(void* p)

    {

        return ( reinterpret_cast<Cookie*>(p) - 1 );

    }

    inline void* _cookie_to_array(Cookie* p)

    {

        return (p + 1);

    }

    inline void _init_cookie(void* p, size_t elem_size, size_t elem_count)

    {

        Cookie* cp = _array_to_cookie(p);

        cp->elem_size  = elem_size;

        cp->elem_count = elem_count;

    }

    inline void _maybe_init_cookie(void* p, size_t cookie_size, size_t elem_size, size_t elem_count)

    {

        if (cookie_size > 0)

        {

            _init_cookie(p, elem_size, elem_count);

        }

    }

}

namespace __cxxabiv1

{

    extern "C" EXPORT_C void __cxa_vec_cleanup(void *array, size_t elem_count, size_t elem_size, Dtor dtor)

    {

        if (dtor)

        {

            // The elemens of an array should be destroyed in reverse order.

            // Pointer to the last element.

            char* p = static_cast<char*>(array) + (elem_count - 1) * elem_size;

            #if RT_NO_EXCEPTIONS

            for (size_t i = elem_count; i > 0; i--, p -= elem_size)

            {

                (*dtor)(p);

            }

            #else

            try

            {

                for (size_t i = elem_count; i > 0; i--, p -= elem_size)

                {

                    (*dtor)(p);

                }

            }

            catch (...)

            {

                std::terminate();

            }

            #endif

        }

    }

    extern "C" EXPORT_C void __cxa_vec_dtor(void* array, size_t elem_count, size_t elem_size, Dtor dtor)

    {

        #if RT_NO_EXCEPTIONS

        __cxa_vec_cleanup(array, elem_count, elem_size, dtor);

        #else

        if (dtor)

        {

            char* p = static_cast<char*>(array) + (elem_count - 1) * elem_size;

            size_t i = elem_count;

            try

            {

                for ( ; i > 0; i--, p -= elem_size)

                {

                    (*dtor)(p);

                }

            }

            catch (...)

            {

                // An exeception was throw when destroying element i; ignore this

                // element and try to destroy the rest of the array.

                i--;

                p -= elem_size;

                try

                {

                    for ( ; i > 0; i--, p -= elem_size)

                    {

                        (*dtor)(p);

                    }

                }

                catch (...)

                {

                    std::terminate();

                }

                throw;

            }

        }

        #endif

    }

    extern "C" EXPORT_C void __cxa_vec_delete2(void* array, size_t elem_size, size_t, Dtor dtor, void (*dealloc)(void*))

    {

        if (!array)

        {

            return;

        }

        Cookie* cp = _array_to_cookie(array);

        if (dtor)

        {

            char* p = static_cast<char*>(array) + (cp->elem_count - 1) * elem_size;

            size_t i = cp->elem_count;

            #if RT_NO_EXCEPTIONS

            for ( ; i > 0; i--, p -= elem_size)

            {

                (*dtor)(p);

            }

            #else

            try

            {

                for ( ; i > 0; i--, p -= elem_size)

                {

                    (*dtor)(p);

                }

            }

            catch (...)

            {

                i--;

                p -= elem_size;

                try

                {

                    for ( ; i > 0; i--, p -= elem_size)

                    {

                        (*dtor)(p);

                    }

                }

                catch (...)

                {

                    std::terminate();

                }

                throw;

            }

            #endif

        }

        (*dealloc)(cp);

    }

    extern "C" EXPORT_C void __cxa_vec_delete(void* array, size_t elem_size, size_t cookie_size, Dtor dtor)

    {

        __cxa_vec_delete2(array, elem_size, cookie_size, dtor, &::operator delete[]);

    }

    extern "C" EXPORT_C void* __cxa_vec_ctor(void* array, size_t elem_count, size_t elem_size, Ctor ctor, Dtor dtor)

    {

        if (ctor)

        {

            char* p = static_cast<char*>(array);

            size_t i = 0;

            #if RT_NO_EXCEPTIONS

            for ( ; i < elem_count; i++, p += elem_size)

            {

                (*ctor)(p);

            }

            #else

            try

            {

                for ( ; i < elem_count; i++, p += elem_size)

                {

                    (*ctor)(p);

                }

            }

            catch (...)

            {

                // When the exception was thrown, elements [0,i) had already been

                // constructed. Those elements should be destroyed.

                __cxa_vec_cleanup(array, i, elem_size, dtor);

                throw;

            }

            #endif

        }

        return array;

    }

    extern "C" EXPORT_C void* __cxa_vec_new2(size_t elem_count, size_t elem_size, size_t cookie_size, Ctor ctor, Dtor dtor, void* (*alloc)(size_t), void (*dealloc)(void*))

    {

        char* p = static_cast<char*>( (*alloc)(elem_count*elem_size + cookie_size) );

        if (!p)

        {

            return 0;

        }

        p += cookie_size;

        _maybe_init_cookie(p, cookie_size, elem_size, elem_count);

        #if RT_NO_EXCEPTIONS

        (void) __cxa_vec_ctor(p, elem_count, elem_size, ctor, dtor);

        #else

        try

        {

            (void) __cxa_vec_ctor(p, elem_count, elem_size, ctor, dtor);

        }

        catch (...)

        {

            (*dealloc)(p - cookie_size);

            throw;

        }

        #endif

        return p;

    }

    extern "C" EXPORT_C void* __cxa_vec_new(size_t elem_count, size_t elem_size, size_t cookie_size, Ctor ctor, Dtor dtor)

    {

        return __cxa_vec_new2(elem_count, elem_size, cookie_size, ctor, dtor, &::operator new[], &::operator delete[]);

    }

    extern "C" EXPORT_C void* __cxa_vec_new3( size_t elem_count, size_t elem_size, size_t cookie_size, Ctor ctor, Dtor dtor, void* (*alloc)(size_t), void (*dealloc)(void*, size_t))

    {

        const size_t mem_size = elem_count*elem_size + cookie_size;

        char* p = static_cast<char*>( (*alloc)(mem_size) );

        if (!p)

        {

            return 0;

        }

        p += cookie_size;

        _maybe_init_cookie(p, cookie_size, elem_size, elem_count);

        #if RT_NO_EXCEPTIONS

        (void) __cxa_vec_ctor(p, elem_count, elem_size, ctor, dtor);

        #else

        try

        {

            (void) __cxa_vec_ctor(p, elem_count, elem_size, ctor, dtor);

        }

        catch (...)

        {

            (*dealloc)(p - cookie_size, mem_size);

            throw;

        }

        #endif

        return p;

    }

    extern "C" EXPORT_C void __cxa_vec_delete3(void* array, size_t elem_size, size_t, Dtor dtor, void (*dealloc)(void*, size_t))

    {

        if (!array)

        {

            return;

        }

        Cookie* cp = _array_to_cookie(array);

        if (dtor)

        {

            size_t i = cp->elem_count;

            char* p = static_cast<char*>(array) + (i - 1) * elem_size;

            #if RT_NO_EXCEPTIONS

            for ( ; i > 0; i--, p -= elem_size)

            {

                (*dtor)(p);

            }

            #else

            try

            {

                for ( ; i > 0; i--, p -= elem_size)

                {

                    (*dtor)(p);

                }

            }

            catch (...)

            {

                i--;

                p -= elem_size;

                try

                {

                    for ( ; i > 0; i--, p -= elem_size)

                    {

                        (*dtor)(p);

                    }

                }

                catch (...)

                {

                    std::terminate();

                }

                throw;

            }

            #endif

        }

        (*dealloc)(cp, elem_size);

    }

    extern "C" EXPORT_C void* __cxa_vec_cctor(void* dest, void* source, size_t elem_count, size_t elem_size, void* (*cctor)(void* to, void* from), Dtor dtor)

    {

        if (cctor) 

        {

            char* p1 = static_cast<char*>(dest);

            char* p2 = static_cast<char*>(source);

            size_t i = 0;

            #if RT_NO_EXCEPTIONS

            for ( ; i < elem_count; i++, p1 += elem_size, p2 += elem_size)

            {

                (*cctor)(p1, p2);

            }

            #else

            try

            {

                for ( ; i < elem_count; i++, p1 += elem_size, p2 += elem_size)

                {

                    (*cctor)(p1, p2);

                }

            }

            catch (...)

            {

                __cxa_vec_cleanup(dest, i, elem_size, dtor);

                throw;

            }

            #endif

        }

        return dest;

    }

} // namespace __cxxabiv1

namespace __aeabiv1

{

    extern "C" EXPORT_C void* __aeabi_vec_ctor_nocookie_nodtor(void* array, Ctor ctor, size_t elem_size, size_t elem_count)

    {

        return __cxxabiv1::__cxa_vec_ctor(array, elem_count, elem_size, ctor, 0);

    }

    extern "C" EXPORT_C void* __aeabi_vec_ctor_cookie_nodtor(Cookie* cp, Ctor ctor, size_t elem_size, size_t elem_count)

    {

        if (!cp)

        {

            return 0;

        }

        else

        {

            cp->elem_size  = elem_size;

            cp->elem_count = elem_count;

            return __aeabi_vec_ctor_nocookie_nodtor( _cookie_to_array(cp), ctor, elem_count, elem_size);

        }

    }

    extern "C" EXPORT_C void* __aeabi_vec_cctor_nocookie_nodtor(void* dest, void* source, size_t elem_size, size_t elem_count, void* (*cctor)(void*, void*))

    {

        return __cxxabiv1::__cxa_vec_cctor(dest, source, elem_count, elem_size, cctor, 0);

    }

    extern "C" EXPORT_C void* __aeabi_vec_new_cookie_noctor(size_t elem_size, size_t elem_count)

    {

        char* p = static_cast<char*>( ::operator new[]( elem_count*elem_size + sizeof(Cookie) ) );

        p += sizeof(Cookie);

        _init_cookie(p, elem_size, elem_count);

        return p;

    }

    extern "C" EXPORT_C void* __aeabi_vec_new_nocookie(size_t elem_size, size_t elem_count, Ctor ctor)

    {

        return __cxxabiv1::__cxa_vec_new(elem_count, elem_size, 0, ctor, 0);

    }

    extern "C" EXPORT_C void* __aeabi_vec_new_cookie_nodtor(size_t elem_size, size_t elem_count, Ctor ctor)

    {

        return __cxxabiv1::__cxa_vec_new(elem_count, elem_size, sizeof(Cookie), ctor, 0);

    }

    extern "C" EXPORT_C void* __aeabi_vec_new_cookie(size_t elem_size, size_t elem_count, Ctor ctor, Dtor dtor)

    {

        return __cxxabiv1::__cxa_vec_new(elem_count, elem_size, sizeof(Cookie), ctor, dtor);

    }

    extern "C" EXPORT_C void* __aeabi_vec_dtor(void* array, Dtor dtor, size_t elem_size, size_t elem_count)

    {

        char* p = static_cast<char*>(array) + (elem_count - 1) * elem_size;

        size_t i = elem_count;

        #if RT_NO_EXCEPTIONS

        for ( ; i > 0; i--, p -= elem_size)

        {

            (*dtor)(p);

        }

        #else

        try

        {

            for ( ; i > 0; i--, p -= elem_size)

            {

                (*dtor)(p);

            }

        }

        catch (...)

        {

            i--;

            p -= elem_size;

            try

            {

                for ( ; i > 0; i--, p -= elem_size)

                {

                    (*dtor)(p);

                }

            }

            catch (...)

            {

                std::terminate();

            }

            throw;

        }

        #endif

        return _array_to_cookie(array);

    }

    extern "C" EXPORT_C void* __aeabi_vec_dtor_cookie(void* array, Dtor dtor)

    {

        if (!array)

        {

            return 0;

        }

        Cookie* cp = _array_to_cookie(array);

        return __aeabi_vec_dtor(array, dtor, cp->elem_size, cp->elem_count);

    }

    extern "C" EXPORT_C void __aeabi_vec_delete(void* array, Dtor dtor)

    {

        #if RT_NO_EXCEPTIONS

        ::operator delete[]( __aeabi_vec_dtor_cookie(array, dtor) );

        #else

        try

        {

            ::operator delete[]( __aeabi_vec_dtor_cookie(array, dtor) );

        }

        catch (...)

        {

            if (array)

            {

                ::operator delete[]( _array_to_cookie(array) );

            }

            throw;

        }

        #endif

    }