// 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 "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:

 // Name        : stdcpp_support.cpp

 // Part of     : standard c++ library.

 // 

 //

 #include <new>

 #include <stdcpp_support.h>

 #include <typeinfo>

 #include <string>

 #include <stdexcept>

 EXPORT_C void TranslateSymErrorToCppException(TInt aError)

 {

 	switch(aError)

 	{

 	case KErrNoMemory:

 		// This is about to use the emergency buffer!

 		__THROW(std::bad_alloc());

 	case KErrArgument:

 		__THROW(std::invalid_argument("Invalid argument"));

 	case KErrOverflow :

 		__THROW(std::overflow_error("Overflow error"));

 	case KErrUnderflow:

 		__THROW(std::underflow_error("Underflow error"));

 	default:

 		__THROW(Symbian_error(KErrGeneral));

 	}

 }

 EXPORT_C TInt TranslateCppExceptionToSymError(const std::exception& aThrow)

 {

 #ifndef __GCCXML__

 	const std::type_info& atype = typeid(aThrow);

 	if(atype == typeid (std::bad_alloc))

 		return KErrNoMemory;

 	else if(atype == typeid(std::invalid_argument))

 		return KErrArgument;

 	else if(atype == typeid(std::out_of_range))

 		// std::out_of_range is of type logic_error which by definition means that it is

 		// "presumably detectable before the program executes".

 		// std::out_of_range is used to report an argument is not within the expected range.

 		// The description of KErrArgument says an argument is out of range. Hence the mapping.

 		return KErrArgument;

 	else if(atype == typeid(std::overflow_error))

 		return KErrOverflow;

 	else if(atype == typeid(std::underflow_error))

 		return KErrUnderflow;

 	else

 		return KErrGeneral;

 #else

 	return KErrGeneral;

 #endif

 }

 #ifdef __WINSCW__

 /*

  * The StdC++ global new and delete operators defined here. They are done only for the emulator

  * as for EABI platforms, it is part of the runtime support(i.e., stdnew.dll).

  */

 #include <e32std.h>

 EXPORT_C const std::nothrow_t std::nothrow;

 EXPORT_C void* operator new(std::size_t a_size) __THROW(std::bad_alloc)

 	{

 	for (;;)

 		{

 		void* p = User::Alloc(a_size);

 		if (p)

 			{

 			return p;

 			}

 		std::new_handler nh_func ;

 		std::new_handler *ptr = reinterpret_cast<std::new_handler*>(Dll::Tls());

 		nh_func = (ptr)?(*ptr):NULL;

 		if (nh_func)

 			{

 			nh_func();

 			}

 		else

 			{

 			__THROW(std::bad_alloc());

 			}

 		}

 	}

 EXPORT_C void* operator new[](std::size_t a_size) __THROW(std::bad_alloc)

 	{

     return ::operator new(a_size);

 	}

 EXPORT_C void* operator new(std::size_t a_size, const std::nothrow_t&) __NO_THROW

 	{

 	for (;;)

 		{

 		void* p = User::Alloc(a_size);

 		if (p)

 			{

 			return p;

 			}

 		std::new_handler nh_func ;

 		std::new_handler *ptr = reinterpret_cast<std::new_handler*>(Dll::Tls());

 		nh_func = (ptr)?(*ptr):NULL;

 		if (nh_func)

 			{

 			try

 				{

 				nh_func();

 				}

 			catch (...)

 				{

 				return 0;

 				}

 			}

 		else

 			{

 			return 0;

 			}

 		}

 	}

 EXPORT_C void* operator new[](std::size_t a_size, const std::nothrow_t) __NO_THROW

 	{

     return ::operator new(a_size, std::nothrow);

 	}

 // Symbian-specific addition.

 EXPORT_C void* operator new(std::size_t a_size, std::size_t a_extra_size) __NO_THROW

 	{

     return ::operator new(a_size + a_extra_size, std::nothrow);

 	}

 EXPORT_C void operator delete(void* p) __NO_THROW

 	{

 	User::Free(p);

 	}

 EXPORT_C void operator delete(void* p, const std::nothrow_t&) __NO_THROW

 	{

 	User::Free(p);

 	}

 EXPORT_C void operator delete[](void* p) __NO_THROW

 	{

 	User::Free(p);

 	}

 EXPORT_C void operator delete[](void* p, const std::nothrow_t&) __NO_THROW

 	{

 	User::Free(p);

 	}

 // Symbian-specific addition.

 EXPORT_C void operator delete(void* p, std::size_t) __NO_THROW

 	{

 	User::Free(p);

 	}

 _LIT(K,"set_new_handler");

 using std::new_handler;

 EXPORT_C new_handler std::set_new_handler(new_handler a_new_nh) __NO_THROW

 	{

 	new_handler current_nh;

 	TAny* tls_word_p = Dll::Tls();

 	if (!tls_word_p)

 		{

 		// This is the first time we're called, so we need to set up the TLS.

 		tls_word_p = User::Alloc( sizeof(new_handler) );

 		if ( !tls_word_p )

 			{

 			User::Panic(K, KErrNoMemory);

 			}

 		Dll::SetTls(tls_word_p);

 		current_nh = 0;

 		}

 	else

 		{

 		// Get the currently installed new_handler function.

 		current_nh = *reinterpret_cast<new_handler*>(tls_word_p);

 		}

 	// Set the new new_handler.

 	*reinterpret_cast<new_handler*>(tls_word_p) = a_new_nh;

 	return current_nh;

 	}

 #endif //__WINSCW__