/* GLIB - Library of useful routines for C programming

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

 * Portions copyright (c) 2006-2009 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>

#include <signal.h>

#ifdef __SYMBIAN32__

#include <errno.h>

#endif /* __SYMBIAN32__ */

#include "glib.h"

#include "gthreadprivate.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)())

#else

static GMemVTable glib_mem_vtable = {

  NULL,//standard_malloc,

  NULL,//standard_realloc,

  NULL,//standard_free,

  NULL,//standard_calloc,

  NULL,//standard_try_malloc,

  NULL,//standard_try_realloc,

};

#endif /* EMULATOR */

#ifdef __SYMBIAN32__

const GMemVTable glib_mem_vtable_temp = {

  standard_malloc,

  standard_realloc,

  standard_free,

  standard_calloc,

  standard_try_malloc,

  standard_try_realloc,

};

#endif//__SYMBIAN32__

/* --- functions --- */

EXPORT_C gpointer

g_malloc (gsize 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;

      mem = glib_mem_vtable.malloc (n_bytes);

      if (mem)

	return mem;

      g_error ("%s: failed to allocate %"G_GSIZE_FORMAT" bytes",

               G_STRLOC, n_bytes);

    }

  return NULL;

#endif /* MOBILE_PORT*/

}

EXPORT_C gpointer

g_malloc0 (gsize 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;

      mem = glib_mem_vtable.calloc (1, n_bytes);

      if (mem)

	return mem;

      g_error ("%s: failed to allocate %"G_GSIZE_FORMAT" bytes",

               G_STRLOC, n_bytes);

    }

  return NULL;

  #endif  /* MOBILE_PORT*/

}

EXPORT_C gpointer

g_realloc (gpointer mem,

	   gsize    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))

    {

      mem = glib_mem_vtable.realloc (mem, n_bytes);

      if (mem)

	return mem;

      g_error ("%s: failed to allocate %"G_GSIZE_FORMAT" bytes",

               G_STRLOC, n_bytes);

    }

  if (mem)

    glib_mem_vtable.free (mem);

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

    glib_mem_vtable.free (mem);

#ifdef MOBILE_PORT

  }

#endif /* MOBILE_PORT */   

	}

}

EXPORT_C gpointer

g_try_malloc (gsize 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;

  		ptr = glib_mem_vtable.try_malloc (n_bytes);

  	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

	{

    return glib_mem_vtable.try_malloc (n_bytes);

  else

	}

#endif /* MOBILE_PORT */

#ifdef MOBILE_PORT

  }

#endif /* MOBILE_PORT */

  else

    return NULL;

}

EXPORT_C gpointer

g_try_malloc0 (gsize 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,

	       gsize    n_bytes)

{

  if (G_UNLIKELY (!g_mem_initialized))

    g_mem_init_nomessage();

  if (G_LIKELY (n_bytes))

    return glib_mem_vtable.try_realloc (mem, n_bytes);

  if (mem)

    glib_mem_vtable.free (mem);

  return NULL;

}

static gpointer

fallback_calloc (gsize n_blocks,

		 gsize n_block_bytes)

{

  gsize l = n_blocks * n_block_bytes;

  gpointer mem = glib_mem_vtable.malloc (l);

  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)

	{

	  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;

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

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

#endif /* EMULATOR */

#ifdef	G_DISABLE_CHECKS

#if !(EMULATOR)

GMemVTable *glib_mem_profiler_table = &glib_mem_vtable;

#endif /* EMULATOR */

EXPORT_C void

g_mem_profile (void)

{

}

#else	/* !G_DISABLE_CHECKS */

typedef enum {

  PROFILER_FREE		= 0,

  PROFILER_ALLOC	= 1,

  PROFILER_RELOC	= 2,

  PROFILER_ZINIT	= 4

} ProfilerJob;

#if (EMULATOR)

PLS(profile_data ,gmem,guint *)

PLS(profile_allocs  ,gmem,gulong)

PLS(profile_zinit ,gmem,gulong)

PLS(profile_frees  ,gmem,gulong)

PLS(gmem_profile_mutex  ,gmem,GMutex *)

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

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

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

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

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

#else

static guint *profile_data = NULL;

static gsize profile_allocs = 0;

static gsize profile_zinit = 0;

static gsize profile_frees = 0;

static GMutex *gmem_profile_mutex = NULL;

#endif /* EMULATOR */

#ifdef  G_ENABLE_DEBUG

#if (EMULATOR)

PLS(g_trap_free_size ,gmem,gsize)

PLS(g_trap_realloc_size  ,gmem,gsize)

PLS(g_trap_malloc_size ,gmem,gsize)

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

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

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

#else

static volatile gsize g_trap_free_size = 0;

static volatile gsize g_trap_realloc_size = 0;

static volatile gsize g_trap_malloc_size = 0;

#endif//EMULATOR

#endif  /* G_ENABLE_DEBUG */

#define	PROFILE_TABLE(f1,f2,f3)   ( ( ((f3) << 2) | ((f2) << 1) | (f1) ) * (MEM_PROFILE_TABLE_SIZE + 1))

static void

profiler_log (ProfilerJob job,

	      gsize       n_bytes,

	      gboolean    success)

{

  g_mutex_lock (gmem_profile_mutex);

  if (!profile_data)

    {

      profile_data = standard_calloc ((MEM_PROFILE_TABLE_SIZE + 1) * 8, 

                                      sizeof (profile_data[0]));

      if (!profile_data)	/* memory system kiddin' me, eh? */

	{

	  g_mutex_unlock (gmem_profile_mutex);

	  return;

	}

    }

  if (n_bytes < MEM_PROFILE_TABLE_SIZE)

    profile_data[n_bytes + PROFILE_TABLE ((job & PROFILER_ALLOC) != 0,

                                          (job & PROFILER_RELOC) != 0,

                                          success != 0)] += 1;

  else

    profile_data[MEM_PROFILE_TABLE_SIZE + PROFILE_TABLE ((job & PROFILER_ALLOC) != 0,

                                                         (job & PROFILER_RELOC) != 0,

                                                         success != 0)] += 1;

  if (success)

    {

      if (job & PROFILER_ALLOC)

        {

          profile_allocs += n_bytes;

          if (job & PROFILER_ZINIT)

            profile_zinit += n_bytes;

        }

      else

        profile_frees += n_bytes;

    }

  g_mutex_unlock (gmem_profile_mutex);

}

static void

profile_print_locked (guint   *local_data,

		      gboolean success)

{

  gboolean need_header = TRUE;

  guint i;

  for (i = 0; i <= MEM_PROFILE_TABLE_SIZE; i++)

    {

      glong t_malloc = local_data[i + PROFILE_TABLE (1, 0, success)];

      glong t_realloc = local_data[i + PROFILE_TABLE (1, 1, success)];

      glong t_free = local_data[i + PROFILE_TABLE (0, 0, success)];

      glong t_refree = local_data[i + PROFILE_TABLE (0, 1, success)];