/*

 * 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:

 * Name       : new

 * Part of    : standard c++ library.

 *

 */

#ifndef _SYMCPP_NEW_H_

#define _SYMCPP_NEW_H_

#ifndef _STLP_FEATURES_H

#  include <stl/config/features.h>

#endif

# ifdef __EABI__

#  include <stl/_cstddef.h> //Include the STLP internal header to make macros/typedefs expected of <csddef> available.

#  define _STLP_CSTDDEF		//Define this macro so that <cstddef> doesn't get included by new_eabi.h

#include "exception"

namespace std

{

	typedef unsigned size_t;

	class bad_alloc : public exception

		{

	public:

		IMPORT_C bad_alloc() __NO_THROW;

		IMPORT_C bad_alloc(const bad_alloc&) __NO_THROW;

		IMPORT_C bad_alloc& operator=(const bad_alloc&) __NO_THROW;  // { return *this;}

		IMPORT_C virtual ~bad_alloc() __NO_THROW;  // {}

		IMPORT_C virtual const char* what() const __NO_THROW; //  { return "bad_alloc";}

		};

	struct nothrow_t {};

	extern const nothrow_t nothrow;

	typedef void (*new_handler)();

	IMPORT_C new_handler set_new_handler(new_handler) __NO_THROW;

}

// Single-object form

IMPORT_C void* operator new(std::size_t) __THROW(std::bad_alloc);

IMPORT_C void  operator delete(void*) __NO_THROW;

IMPORT_C void* operator new(std::size_t, const std::nothrow_t&) __NO_THROW;

IMPORT_C void  operator delete(void*, const std::nothrow_t&) __NO_THROW;

#ifndef __PLACEMENT_NEW_INLINE

	#define __PLACEMENT_NEW_INLINE

	inline void* operator new(std::size_t, void* p) __NO_THROW

		{

		return p;

		}

	inline void operator delete(void*, void*) __NO_THROW

		{

		}

#endif

// Array form

IMPORT_C void* operator new[](std::size_t) __THROW(std::bad_alloc);

IMPORT_C void  operator delete[](void*) __NO_THROW;

IMPORT_C void* operator new[](std::size_t, const std::nothrow_t&) __NO_THROW;

IMPORT_C void  operator delete[](void*, const std::nothrow_t&) __NO_THROW;

#ifndef __PLACEMENT_VEC_NEW_INLINE

	#define __PLACEMENT_VEC_NEW_INLINE 

	inline void* operator new[](std::size_t, void* p) __NO_THROW

		{

		return p;

		}

	inline void operator delete[](void*, void*) __NO_THROW

		{

		}

#endif

// Symbian additions (not part of standard C++).

IMPORT_C void* operator new(std::size_t, std::size_t) __NO_THROW;

IMPORT_C void  operator delete(void*, std::size_t) __NO_THROW;

# else

#  include <exception>

#  include <stl/_cstddef.h>

#  include <e32def.h>

namespace std {

	struct nothrow_t { };

	extern const nothrow_t nothrow;

	class bad_alloc : public exception {

	public :

		bad_alloc () __NO_THROW {};

		bad_alloc ( const bad_alloc &) __NO_THROW {};

		bad_alloc & operator =( const bad_alloc &) __NO_THROW { return *this;}

		virtual const char * what () const __NO_THROW { return "bad_alloc";}

	};

	typedef void (* new_handler )();

	new_handler set_new_handler ( new_handler new_p ) __NO_THROW;

}

IMPORT_C void* operator new    (std::size_t) __THROW(std::bad_alloc);

IMPORT_C void  operator delete (void*)       __NO_THROW;

IMPORT_C void* operator new    (std::size_t, const std::nothrow_t&) __NO_THROW;

IMPORT_C void  operator delete (void*, const std::nothrow_t&)       __NO_THROW;

IMPORT_C void* operator new[]    (std::size_t) __THROW(std::bad_alloc);

IMPORT_C void  operator delete[] (void*)       __NO_THROW;

IMPORT_C void* operator new[]    (std::size_t, const std::nothrow_t&) __NO_THROW;

IMPORT_C void  operator delete[] (void*, const std::nothrow_t&)       __NO_THROW;

#   ifndef __PLACEMENT_NEW_INLINE

#   define __PLACEMENT_NEW_INLINE

inline void* operator new(std::size_t, void* aBase) __NO_THROW

	{return aBase;}

inline void operator delete(void*,  void*)  __NO_THROW	{} 

#   endif //__PLACEMENT_NEW_INLINE

#   ifndef __PLACEMENT_VEC_NEW_INLINE

#   define __PLACEMENT_VEC_NEW_INLINE

inline void* operator new[](std::size_t, void* aBase)  __NO_THROW

	{return aBase;}

inline void operator delete[](void* , void*)  __NO_THROW {}

#   endif //__PLACEMENT_VEC_NEW_INLINE

# endif //__EABI__

#endif //_SYMCPP_NEW_H_