/* GLIB - Library of useful routines for C programming

 * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald

 * Portions copyright (c) 2006 Nokia Corporation.  All rights reserved.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/*

 * Modified by the GLib Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GLib Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GLib at ftp://ftp.gtk.org/pub/gtk/. 

 */

/* 

 * MT safe

 */

#include "config.h"

#include <stdlib.h>

#include <string.h>

#ifndef __SYMBIAN32__

#include <signal.h>

#endif /* __SYMBIAN32__ */

#ifdef __SYMBIAN32__

#include <errno.h>

#endif /* __SYMBIAN32__ */

#include "glib.h"

#include "gthreadinit.h"

#include "galias.h"

#define MEM_PROFILE_TABLE_SIZE 4096

#ifdef __SYMBIAN32__

#include <glib_wsd.h>

#endif /* __SYMBIAN32__ */

#if EMULATOR

#define g_thread_functions_for_glib_use (*_g_thread_functions_for_glib_use())

#define g_thread_use_default_impl (*_g_thread_use_default_impl())

#endif /* EMULATOR */

#ifdef MOBILE_PORT

#include <glowmem.h>

#endif /* MOBILE_PORT */

/* notes on macros:

 * having G_DISABLE_CHECKS defined disables use of glib_mem_profiler_table and

 * g_mem_profile().

 * REALLOC_0_WORKS is defined if g_realloc (NULL, x) works.

 * SANE_MALLOC_PROTOS is defined if the systems malloc() and friends functions

 * match the corresponding GLib prototypes, keep configure.in and gmem.h in sync here.

 * g_mem_gc_friendly is TRUE, freed memory should be 0-wiped.

 */

/* --- prototypes --- */

#if EMULATOR

PLS(g_mem_initialized ,gmem,gboolean)

#define g_mem_initialized  (*FUNCTION_NAME(g_mem_initialized ,gmem)())

#else

static gboolean g_mem_initialized = FALSE;

#endif /* EMULATOR */

static void     g_mem_init_nomessage (void);

/* --- malloc wrappers --- */

#ifndef	REALLOC_0_WORKS

static gpointer

standard_realloc (gpointer mem,

		  gsize    n_bytes)

{

  if (!mem)

    return malloc (n_bytes);

  else

    return realloc (mem, n_bytes);

}

#endif	/* !REALLOC_0_WORKS */

#ifdef SANE_MALLOC_PROTOS

#  define standard_malloc	malloc

#  ifdef REALLOC_0_WORKS

#    define standard_realloc	realloc

#  endif /* REALLOC_0_WORKS */

#  define standard_free		free

#  define standard_calloc	calloc

#  define standard_try_malloc	malloc

#  define standard_try_realloc	realloc

#else	/* !SANE_MALLOC_PROTOS */

static gpointer

standard_malloc (gsize n_bytes)

{

  return malloc (n_bytes);

}

#  ifdef REALLOC_0_WORKS

static gpointer

standard_realloc (gpointer mem,

		  gsize    n_bytes)

{

  return realloc (mem, n_bytes);

}

#  endif /* REALLOC_0_WORKS */

static void

standard_free (gpointer mem)

{

  free (mem);

}

static gpointer

standard_calloc (gsize n_blocks,

		 gsize n_bytes)

{

  return calloc (n_blocks, n_bytes);

}

#define	standard_try_malloc	standard_malloc

#define	standard_try_realloc	standard_realloc

#endif	/* !SANE_MALLOC_PROTOS */

/* --- variables --- */

#if EMULATOR

PLS(glib_mem_vtable,gmem,GMemVTable)

#define glib_mem_vtable (*FUNCTION_NAME(glib_mem_vtable,gmem)())

const GMemVTable temp_glib_mem_vtable = {

  standard_malloc,

  standard_realloc,

  standard_free,

  standard_calloc,

  standard_try_malloc,

  standard_try_realloc,

};

#else

static GMemVTable glib_mem_vtable = {

  NULL,

  NULL,

  NULL,

  NULL,

  NULL,

  NULL,

};

static const GMemVTable glib_mem_vtable_def = {

  standard_malloc,

  standard_realloc,

  standard_free,

  standard_calloc,

  standard_try_malloc,

  standard_try_realloc,

};

#endif /* EMULATOR */

/* --- functions --- */

EXPORT_C gpointer

g_malloc (gulong n_bytes)

{

#ifdef MOBILE_PORT

  	return g_try_malloc(n_bytes);

#else

  if (G_UNLIKELY (!g_mem_initialized))

    g_mem_init_nomessage();

  if (G_LIKELY (n_bytes))

    {

      gpointer mem;

#if EMULATOR

			mem = glib_mem_vtable.malloc (n_bytes);

#else			

			if (glib_mem_vtable.malloc)

      	mem = glib_mem_vtable.malloc (n_bytes);

      else

      	mem = glib_mem_vtable_def.malloc (n_bytes);

#endif

      if (mem)

	return mem;

      g_error ("%s: failed to allocate %lu bytes", G_STRLOC, n_bytes);

    }

  return NULL;

#endif /* MOBILE_PORT*/

}

EXPORT_C gpointer

g_malloc0 (gulong n_bytes)

{

  #ifdef MOBILE_PORT

  	return g_try_malloc0(n_bytes);

  #else

  if (G_UNLIKELY (!g_mem_initialized))

    g_mem_init_nomessage();

  if (G_LIKELY (n_bytes))

    {

      gpointer mem;

#if EMULATOR

		mem = glib_mem_vtable.calloc (1, n_bytes);

#else			

			if (glib_mem_vtable.calloc)

      	mem = glib_mem_vtable.calloc (1, n_bytes);

      else

      	mem = glib_mem_vtable_def.calloc (1, n_bytes);

#endif

      if (mem)

	return mem;

      g_error ("%s: failed to allocate %lu bytes", G_STRLOC, n_bytes);

    }

  return NULL;

  #endif  /* MOBILE_PORT*/

}

EXPORT_C gpointer

g_realloc (gpointer mem,

	   gulong   n_bytes)

{

  #ifdef MOBILE_PORT

  	return g_try_realloc(mem,n_bytes);

  #else 

  if (G_UNLIKELY (!g_mem_initialized))

    g_mem_init_nomessage();

  if (G_LIKELY (n_bytes))

    {

#if EMULATOR

			mem = glib_mem_vtable.realloc (mem, n_bytes);

#else    	

    	if (glib_mem_vtable.realloc)

      	mem = glib_mem_vtable.realloc (mem, n_bytes);

      else

      	mem = glib_mem_vtable_def.realloc (mem, n_bytes);

#endif

      if (mem)

	return mem;

      g_error ("%s: failed to allocate %lu bytes", G_STRLOC, n_bytes);

    }

  if (mem)

  {

#if EMULATOR

		glib_mem_vtable.free (mem);

#else

  	if (glib_mem_vtable.free)

    	glib_mem_vtable.free (mem);

    else

    	glib_mem_vtable_def.free (mem);

#endif

  return NULL;

  #endif  /* MOBILE_PORT*/

}

EXPORT_C void

g_free (gpointer mem)

{

  if (G_UNLIKELY (!g_mem_initialized))

    g_mem_init_nomessage();

  if (G_LIKELY (mem))

  {

#ifdef MOBILE_PORT

  {

  	mem_info * m = _get_thread_specific_data();

  	if(m && m->is_setjmp_called)

  		_findAndDestroy(&(m->stack),mem);

#endif /* MOBILE_PORT */

#if EMULATOR

		glib_mem_vtable.free (mem);

#else

  	if(glib_mem_vtable.free)

  		glib_mem_vtable.free (mem);

  	else

  		glib_mem_vtable_def.free (mem);

#endif

#ifdef MOBILE_PORT

  }

#endif /* MOBILE_PORT */   

	}

}

EXPORT_C gpointer

g_try_malloc (gulong n_bytes)

{

#ifdef MOBILE_PORT

  gpointer ptr;

#endif /* MOBILE_PORT */

  if (G_UNLIKELY (!g_mem_initialized))

    g_mem_init_nomessage();

  if (G_LIKELY (n_bytes))

#ifdef MOBILE_PORT

  {

	errno = 0;

#if EMULATOR

		ptr = glib_mem_vtable.try_malloc (n_bytes);

#else

	  if (glib_mem_vtable.try_malloc)

  		ptr = glib_mem_vtable.try_malloc (n_bytes);

  	else

  		ptr = glib_mem_vtable_def.try_malloc (n_bytes);

#endif  	

  	if(ENOMEM == errno)

  	{

  		mem_info *m = _get_thread_specific_data();

  		if(!m)

  			return NULL;

  		if(TRUE == m->is_setjmp_called)

  		{

  			longjmp(m->buf,1);

  		}

  	}

  	else

  	{

  		mem_info *m = _get_thread_specific_data();

  		if(m && m->is_setjmp_called)

  		{

  			if(_push(&(m->stack),ptr))

			{	

				free(ptr);

				longjmp(m->buf,1);

			}	

  		}

  	}

  	return ptr;

#else

	{

#if EMULATOR

		return glib_mem_vtable.try_malloc (n_bytes);

#else

		if (glib_mem_vtable.try_malloc)

			return glib_mem_vtable.try_malloc (n_bytes);

		else

			return glib_mem_vtable_def.try_malloc (n_bytes);

#endif

	}

#endif /* MOBILE_PORT */

#ifdef MOBILE_PORT

  }

#endif /* MOBILE_PORT */

  else

    return NULL;

}

EXPORT_C gpointer

g_try_malloc0 (gulong n_bytes)

{ 

  gpointer mem;

  mem = g_try_malloc (n_bytes);

  if (mem)

    memset (mem, 0, n_bytes);

  return mem;

}

EXPORT_C gpointer

g_try_realloc (gpointer mem,

	       gulong   n_bytes)

{

  if (G_UNLIKELY (!g_mem_initialized))

    g_mem_init_nomessage();

  if (G_LIKELY (n_bytes))

  {

#if EMULATOR

		return glib_mem_vtable.try_realloc (mem, n_bytes);

#else

  	if (glib_mem_vtable.try_realloc)

    	return glib_mem_vtable.try_realloc (mem, n_bytes);

    else

    	return glib_mem_vtable_def.try_realloc (mem, n_bytes);

#endif

	}

  if (mem)

  {

#if EMULATOR

		glib_mem_vtable.free (mem);

#else

  	if (glib_mem_vtable.free)

    	glib_mem_vtable.free (mem);

    else

    	glib_mem_vtable_def.free (mem);

#endif

  }

  return NULL;

}

static gpointer

fallback_calloc (gsize n_blocks,

		 gsize n_block_bytes)

{

  gsize l = n_blocks * n_block_bytes;

  gpointer mem;

#if EMULATOR

	mem = glib_mem_vtable.malloc (l);

#else

  if (glib_mem_vtable.malloc)

  	mem = glib_mem_vtable.malloc (l);

  else

  	mem = glib_mem_vtable_def.malloc (l);

#endif

  if (mem)

    memset (mem, 0, l);

  return mem;

}

#if EMULATOR

PLS(vtable_set ,gmem,gboolean )

#define vtable_set  (*FUNCTION_NAME(vtable_set ,gmem)())

#else

static gboolean vtable_set = FALSE;

#endif /* EMULATOR */

/**

 * g_mem_is_system_malloc

 * 

 * Checks whether the allocator used by g_malloc() is the system's

 * malloc implementation. If it returns %TRUE memory allocated with

 * malloc() can be used interchangeable with memory allocated using g_malloc(). 

 * This function is useful for avoiding an extra copy of allocated memory returned

 * by a non-GLib-based API.

 *

 * A different allocator can be set using g_mem_set_vtable().

 *

 * Return value: if %TRUE, malloc() and g_malloc() can be mixed.

 **/

EXPORT_C gboolean

g_mem_is_system_malloc (void)

{

  return !vtable_set;

}

EXPORT_C void

g_mem_set_vtable (GMemVTable *vtable)

{

  if (!vtable_set)

    {

      if (vtable->malloc && vtable->realloc && vtable->free)

	{

#if EMULATOR

		glib_mem_vtable.malloc = vtable->malloc;

	  glib_mem_vtable.realloc = vtable->realloc;

	  glib_mem_vtable.free = vtable->free;

	  glib_mem_vtable.calloc = vtable->calloc ? vtable->calloc : fallback_calloc;

	  glib_mem_vtable.try_malloc = vtable->try_malloc ? vtable->try_malloc : glib_mem_vtable.malloc;

	  glib_mem_vtable.try_realloc = vtable->try_realloc ? vtable->try_realloc : glib_mem_vtable.realloc;

#else

	  if (vtable->malloc)

	  	glib_mem_vtable.malloc = vtable->malloc;

	  else

	  	glib_mem_vtable.malloc = glib_mem_vtable_def.malloc;

	  if (vtable->realloc)	

	  	glib_mem_vtable.realloc = vtable->realloc;

	  else

	  	glib_mem_vtable.realloc = glib_mem_vtable_def.realloc;

	  if (vtable->free)	

	  	glib_mem_vtable.free = vtable->free;

	  else

	  	glib_mem_vtable.free = glib_mem_vtable_def.free;

	  if (vtable->calloc)

	  	glib_mem_vtable.calloc = vtable->calloc;

	  else

	  	glib_mem_vtable.calloc = fallback_calloc;

	  if (vtable->try_malloc)

	  	glib_mem_vtable.try_malloc = vtable->try_malloc;

	  else

	  	glib_mem_vtable.try_malloc = glib_mem_vtable_def.try_malloc;

	  if (vtable->try_realloc)	

	  	glib_mem_vtable.try_realloc = vtable->try_realloc;

	  else

	  	glib_mem_vtable.try_realloc = glib_mem_vtable_def.try_realloc;

#endif

	  vtable_set = TRUE;

	}

      else

	g_warning (G_STRLOC ": memory allocation vtable lacks one of malloc(), realloc() or free()");

    }

  else

    g_warning (G_STRLOC ": memory allocation vtable can only be set once at startup");

}

/* --- memory profiling and checking --- */

#if EMULATOR

PLS(glib_mem_profiler_table,gmem,GMemVTable *)