/usr/local/include/glib-2.0/glib/gmem.h

Source (jump to first uncovered line)
/* GLIB - Library of useful routines for C programming
 * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
 *
 * SPDX-License-Identifier: LGPL-2.1-or-later
 *
 * 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.1 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, see <http://www.gnu.org/licenses/>.
 */

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

#ifndef __G_MEM_H__
#define __G_MEM_H__

#if !defined (__GLIB_H_INSIDE__) && !defined (GLIB_COMPILATION)
#error "Only <glib.h> can be included directly."
#endif

#include <glib/gutils.h>
#include <glib/glib-typeof.h>

G_BEGIN_DECLS

/**
 * GMemVTable:
 * @malloc: function to use for allocating memory.
 * @realloc: function to use for reallocating memory.
 * @free: function to use to free memory.
 * @calloc: function to use for allocating zero-filled memory.
 * @try_malloc: function to use for allocating memory without a default error handler.
 * @try_realloc: function to use for reallocating memory without a default error handler.
 * 
 * A set of functions used to perform memory allocation. The same #GMemVTable must
 * be used for all allocations in the same program; a call to g_mem_set_vtable(),
 * if it exists, should be prior to any use of GLib.
 *
 * This functions related to this has been deprecated in 2.46, and no longer work.
 */
typedef struct _GMemVTable GMemVTable;


#if GLIB_SIZEOF_VOID_P > GLIB_SIZEOF_LONG
/**
 * G_MEM_ALIGN:
 *
 * Indicates the number of bytes to which memory will be aligned on the
 * current platform.
 */
#  define G_MEM_ALIGN GLIB_SIZEOF_VOID_P
#else /* GLIB_SIZEOF_VOID_P <= GLIB_SIZEOF_LONG */
#  define G_MEM_ALIGN GLIB_SIZEOF_LONG
#endif  /* GLIB_SIZEOF_VOID_P <= GLIB_SIZEOF_LONG */


/* Memory allocation functions
 */

GLIB_AVAILABLE_IN_ALL
void     (g_free)         (gpointer      mem);
GLIB_AVAILABLE_IN_2_76
void     g_free_sized     (gpointer      mem,
                           size_t        size);

GLIB_AVAILABLE_IN_2_34
void     g_clear_pointer  (gpointer      *pp,
                           GDestroyNotify destroy);

GLIB_AVAILABLE_IN_ALL
gpointer g_malloc         (gsize   n_bytes) G_GNUC_MALLOC G_GNUC_ALLOC_SIZE(1);
GLIB_AVAILABLE_IN_ALL
gpointer g_malloc0        (gsize   n_bytes) G_GNUC_MALLOC G_GNUC_ALLOC_SIZE(1);
GLIB_AVAILABLE_IN_ALL
gpointer g_realloc        (gpointer  mem,
         gsize   n_bytes) G_GNUC_WARN_UNUSED_RESULT;
GLIB_AVAILABLE_IN_ALL
gpointer g_try_malloc     (gsize   n_bytes) G_GNUC_MALLOC G_GNUC_ALLOC_SIZE(1);
GLIB_AVAILABLE_IN_ALL
gpointer g_try_malloc0    (gsize   n_bytes) G_GNUC_MALLOC G_GNUC_ALLOC_SIZE(1);
GLIB_AVAILABLE_IN_ALL
gpointer g_try_realloc    (gpointer  mem,
         gsize   n_bytes) G_GNUC_WARN_UNUSED_RESULT;

GLIB_AVAILABLE_IN_ALL
gpointer g_malloc_n       (gsize   n_blocks,
         gsize   n_block_bytes) G_GNUC_MALLOC G_GNUC_ALLOC_SIZE2(1,2);
GLIB_AVAILABLE_IN_ALL
gpointer g_malloc0_n      (gsize   n_blocks,
         gsize   n_block_bytes) G_GNUC_MALLOC G_GNUC_ALLOC_SIZE2(1,2);
GLIB_AVAILABLE_IN_ALL
gpointer g_realloc_n      (gpointer  mem,
         gsize   n_blocks,
         gsize   n_block_bytes) G_GNUC_WARN_UNUSED_RESULT;
GLIB_AVAILABLE_IN_ALL
gpointer g_try_malloc_n   (gsize   n_blocks,
         gsize   n_block_bytes) G_GNUC_MALLOC G_GNUC_ALLOC_SIZE2(1,2);
GLIB_AVAILABLE_IN_ALL
gpointer g_try_malloc0_n  (gsize   n_blocks,
         gsize   n_block_bytes) G_GNUC_MALLOC G_GNUC_ALLOC_SIZE2(1,2);
GLIB_AVAILABLE_IN_ALL
gpointer g_try_realloc_n  (gpointer  mem,
         gsize   n_blocks,
         gsize   n_block_bytes) G_GNUC_WARN_UNUSED_RESULT;

GLIB_AVAILABLE_IN_2_72
gpointer g_aligned_alloc  (gsize         n_blocks,
                           gsize         n_block_bytes,
                           gsize         alignment) G_GNUC_WARN_UNUSED_RESULT G_GNUC_ALLOC_SIZE2(1,2);
GLIB_AVAILABLE_IN_2_72
gpointer g_aligned_alloc0 (gsize         n_blocks,
                           gsize         n_block_bytes,
                           gsize         alignment) G_GNUC_WARN_UNUSED_RESULT G_GNUC_ALLOC_SIZE2(1,2);
GLIB_AVAILABLE_IN_2_72
void     g_aligned_free   (gpointer      mem);
GLIB_AVAILABLE_IN_2_76
void     g_aligned_free_sized (gpointer  mem,
                               size_t    alignment,
                               size_t    size);

#if defined(glib_typeof) && GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_58
#define g_clear_pointer(pp, destroy)                     \
  G_STMT_START                                           \
  {                                                      \
    G_STATIC_ASSERT (sizeof *(pp) == sizeof (gpointer)); \
    glib_typeof ((pp)) _pp = (pp);                       \
    glib_typeof (*(pp)) _ptr = *_pp;                     \
    *_pp = NULL;                                         \
    if (_ptr)                                            \
      (destroy) (_ptr);                                  \
  }                                                      \
  G_STMT_END                                             \
  GLIB_AVAILABLE_MACRO_IN_2_34
#else /* __GNUC__ */
#define g_clear_pointer(pp, destroy) \
  G_STMT_START {                                                               \
    G_STATIC_ASSERT (sizeof *(pp) == sizeof (gpointer));                       \
    /* Only one access, please; work around type aliasing */                   \
    union { char *in; gpointer *out; } _pp;                                    \
    gpointer _p;                                                               \
    /* This assignment is needed to avoid a gcc warning */                     \
    GDestroyNotify _destroy = (GDestroyNotify) (destroy);                      \
                                                                               \
    _pp.in = (char *) (pp);                                                    \
    _p = *_pp.out;                                                             \
    if (_p)                        \
      {                        \
        *_pp.out = NULL;                                                       \
        _destroy (_p);                                                         \
      }                                                                        \
  } G_STMT_END                                                                 \
  GLIB_AVAILABLE_MACRO_IN_2_34
#endif /* __GNUC__ */


#if G_GNUC_CHECK_VERSION (4, 1) && GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_78 && defined(G_HAVE_FREE_SIZED)

#define g_free(mem)                                                            \
  (__builtin_object_size ((mem), 0) != ((size_t) - 1)) ?                       \
    g_free_sized (mem, __builtin_object_size ((mem), 0)) : (g_free) (mem)

#endif /* G_GNUC_CHECK_VERSION (4, 1) && && GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_78 && defined(G_HAVE_FREE_SIZED) */

/**
 * g_steal_pointer:
 * @pp: (not nullable): a pointer to a pointer
 *
 * Sets @pp to %NULL, returning the value that was there before.
 *
 * Conceptually, this transfers the ownership of the pointer from the
 * referenced variable to the "caller" of the macro (ie: "steals" the
 * reference).
 *
 * The return value will be properly typed, according to the type of
 * @pp.
 *
 * This can be very useful when combined with g_autoptr() to prevent the
 * return value of a function from being automatically freed.  Consider
 * the following example (which only works on GCC and clang):
 *
 * |[
 * GObject *
 * create_object (void)
 * {
 *   g_autoptr(GObject) obj = g_object_new (G_TYPE_OBJECT, NULL);
 *
 *   if (early_error_case)
 *     return NULL;
 *
 *   return g_steal_pointer (&obj);
 * }
 * ]|
 *
 * It can also be used in similar ways for 'out' parameters and is
 * particularly useful for dealing with optional out parameters:
 *
 * |[
 * gboolean
 * get_object (GObject **obj_out)
 * {
 *   g_autoptr(GObject) obj = g_object_new (G_TYPE_OBJECT, NULL);
 *
 *   if (early_error_case)
 *     return FALSE;
 *
 *   if (obj_out)
 *     *obj_out = g_steal_pointer (&obj);
 *
 *   return TRUE;
 * }
 * ]|
 *
 * In the above example, the object will be automatically freed in the
 * early error case and also in the case that %NULL was given for
 * @obj_out.
 *
 * Since: 2.44
 */
GLIB_AVAILABLE_STATIC_INLINE_IN_2_44
static inline gpointer g_steal_pointer (gpointer pp);

GLIB_AVAILABLE_STATIC_INLINE_IN_2_44
static inline gpointer
g_steal_pointer (gpointer pp)
{
  gpointer *ptr = (gpointer *) pp;
  gpointer ref;

  ref = *ptr;
  *ptr = NULL;

  return ref;
}

/* type safety */
#if defined(glib_typeof) && GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_58
#define g_steal_pointer(pp) ((glib_typeof (*pp)) (g_steal_pointer) (pp))
#else  /* __GNUC__ */
/* This version does not depend on gcc extensions, but gcc does not warn
 * about incompatible-pointer-types: */
#define g_steal_pointer(pp) \
  (0 ? (*(pp)) : (g_steal_pointer) (pp))
#endif /* __GNUC__ */

/* Optimise: avoid the call to the (slower) _n function if we can
 * determine at compile-time that no overflow happens.
 */
#if defined (__GNUC__) && (__GNUC__ >= 2) && defined (__OPTIMIZE__)
#  define _G_NEW(struct_type, n_structs, func) \
  (struct_type *) (G_GNUC_EXTENSION ({      \
    gsize __n = (gsize) (n_structs);      \
    gsize __s = sizeof (struct_type);     \
    gpointer __p;           \
    if (__s == 1)           \
      __p = g_##func (__n);       \
    else if (__builtin_constant_p (__n) &&    \
             (__s == 0 || __n <= G_MAXSIZE / __s))  \
      __p = g_##func (__n * __s);       \
    else              \
      __p = g_##func##_n (__n, __s);      \
    __p;              \
  }))
#  define _G_RENEW(struct_type, mem, n_structs, func) \
  (struct_type *) (G_GNUC_EXTENSION ({      \
    gsize __n = (gsize) (n_structs);      \
    gsize __s = sizeof (struct_type);     \
    gpointer __p = (gpointer) (mem);      \
    if (__s == 1)           \
      __p = g_##func (__p, __n);        \
    else if (__builtin_constant_p (__n) &&    \
             (__s == 0 || __n <= G_MAXSIZE / __s))  \
      __p = g_##func (__p, __n * __s);      \
    else              \
      __p = g_##func##_n (__p, __n, __s);     \
    __p;              \
  }))

#else

/* Unoptimised version: always call the _n() function. */

#define _G_NEW(struct_type, n_structs, func) \
        ((struct_type *) g_##func##_n ((n_structs), sizeof (struct_type)))
#define _G_RENEW(struct_type, mem, n_structs, func) \
        ((struct_type *) g_##func##_n (mem, (n_structs), sizeof (struct_type)))

#endif

/**
 * g_new:
 * @struct_type: the type of the elements to allocate
 * @n_structs: the number of elements to allocate
 * 
 * Allocates @n_structs elements of type @struct_type.
 * The returned pointer is cast to a pointer to the given type.
 * If @n_structs is 0 it returns %NULL.
 * Care is taken to avoid overflow when calculating the size of the allocated block.
 * 
 * Since the returned pointer is already casted to the right type,
 * it is normally unnecessary to cast it explicitly, and doing
 * so might hide memory allocation errors.
 * 
 * Returns: a pointer to the allocated memory, cast to a pointer to @struct_type
 */
#define g_new(struct_type, n_structs)     _G_NEW (struct_type, n_structs, malloc)
/**
 * g_new0:
 * @struct_type: the type of the elements to allocate.
 * @n_structs: the number of elements to allocate.
 * 
 * Allocates @n_structs elements of type @struct_type, initialized to 0's.
 * The returned pointer is cast to a pointer to the given type.
 * If @n_structs is 0 it returns %NULL.
 * Care is taken to avoid overflow when calculating the size of the allocated block.
 * 
 * Since the returned pointer is already casted to the right type,
 * it is normally unnecessary to cast it explicitly, and doing
 * so might hide memory allocation errors.
 * 
 * Returns: a pointer to the allocated memory, cast to a pointer to @struct_type.
 */
#define g_new0(struct_type, n_structs)      _G_NEW (struct_type, n_structs, malloc0)
/**
 * g_renew:
 * @struct_type: the type of the elements to allocate
 * @mem: the currently allocated memory
 * @n_structs: the number of elements to allocate
 * 
 * Reallocates the memory pointed to by @mem, so that it now has space for
 * @n_structs elements of type @struct_type. It returns the new address of
 * the memory, which may have been moved.
 * Care is taken to avoid overflow when calculating the size of the allocated block.
 * 
 * Returns: a pointer to the new allocated memory, cast to a pointer to @struct_type
 */
#define g_renew(struct_type, mem, n_structs)    _G_RENEW (struct_type, mem, n_structs, realloc)
/**
 * g_try_new:
 * @struct_type: the type of the elements to allocate
 * @n_structs: the number of elements to allocate
 * 
 * Attempts to allocate @n_structs elements of type @struct_type, and returns
 * %NULL on failure. Contrast with g_new(), which aborts the program on failure.
 * The returned pointer is cast to a pointer to the given type.
 * The function returns %NULL when @n_structs is 0 of if an overflow occurs.
 * 
 * Since: 2.8
 * Returns: a pointer to the allocated memory, cast to a pointer to @struct_type
 */
#define g_try_new(struct_type, n_structs)   _G_NEW (struct_type, n_structs, try_malloc)
/**
 * g_try_new0:
 * @struct_type: the type of the elements to allocate
 * @n_structs: the number of elements to allocate
 * 
 * Attempts to allocate @n_structs elements of type @struct_type, initialized
 * to 0's, and returns %NULL on failure. Contrast with g_new0(), which aborts
 * the program on failure.
 * The returned pointer is cast to a pointer to the given type.
 * The function returns %NULL when @n_structs is 0 or if an overflow occurs.
 * 
 * Since: 2.8
 * Returns: a pointer to the allocated memory, cast to a pointer to @struct_type
 */
#define g_try_new0(struct_type, n_structs)    _G_NEW (struct_type, n_structs, try_malloc0)
/**
 * g_try_renew:
 * @struct_type: the type of the elements to allocate
 * @mem: the currently allocated memory
 * @n_structs: the number of elements to allocate
 * 
 * Attempts to reallocate the memory pointed to by @mem, so that it now has
 * space for @n_structs elements of type @struct_type, and returns %NULL on
 * failure. Contrast with g_renew(), which aborts the program on failure.
 * It returns the new address of the memory, which may have been moved.
 * The function returns %NULL if an overflow occurs.
 * 
 * Since: 2.8
 * Returns: a pointer to the new allocated memory, cast to a pointer to @struct_type
 */
#define g_try_renew(struct_type, mem, n_structs)  _G_RENEW (struct_type, mem, n_structs, try_realloc)


/* Memory allocation virtualization for debugging purposes
 * g_mem_set_vtable() has to be the very first GLib function called
 * if being used
 */
struct _GMemVTable {
  gpointer (*malloc)      (gsize    n_bytes);
  gpointer (*realloc)     (gpointer mem,
         gsize    n_bytes);
  void     (*free)        (gpointer mem);
  /* optional; set to NULL if not used ! */
  gpointer (*calloc)      (gsize    n_blocks,
         gsize    n_block_bytes);
  gpointer (*try_malloc)  (gsize    n_bytes);
  gpointer (*try_realloc) (gpointer mem,
         gsize    n_bytes);
};
GLIB_DEPRECATED_IN_2_46
void   g_mem_set_vtable (GMemVTable *vtable);
GLIB_DEPRECATED_IN_2_46
gboolean g_mem_is_system_malloc (void);

GLIB_VAR gboolean g_mem_gc_friendly;

/* Memory profiler and checker, has to be enabled via g_mem_set_vtable()
 */
GLIB_VAR GMemVTable *glib_mem_profiler_table;
GLIB_DEPRECATED_IN_2_46
void  g_mem_profile (void);

G_END_DECLS

#endif /* __G_MEM_H__ */

Coverage Report

Created: 2025-01-28 06:43

Line	Count	Source (jump to first uncovered line)
1		/* GLIB - Library of useful routines for C programming
2		* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
3		*
4		* SPDX-License-Identifier: LGPL-2.1-or-later
5		*
6		* This library is free software; you can redistribute it and/or
7		* modify it under the terms of the GNU Lesser General Public
8		* License as published by the Free Software Foundation; either
9		* version 2.1 of the License, or (at your option) any later version.
10		*
11		* This library is distributed in the hope that it will be useful,
12		* but WITHOUT ANY WARRANTY; without even the implied warranty of
13		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14		* Lesser General Public License for more details.
15		*
16		* You should have received a copy of the GNU Lesser General Public
17		* License along with this library; if not, see <http://www.gnu.org/licenses/>.
18		*/
19
20		/*
21		* Modified by the GLib Team and others 1997-2000. See the AUTHORS
22		* file for a list of people on the GLib Team. See the ChangeLog
23		* files for a list of changes. These files are distributed with
24		* GLib at ftp://ftp.gtk.org/pub/gtk/.
25		*/
26
27		#ifndef __G_MEM_H__
28		#define __G_MEM_H__
29
30		#if !defined (__GLIB_H_INSIDE__) && !defined (GLIB_COMPILATION)
31		#error "Only <glib.h> can be included directly."
32		#endif
33
34		#include <glib/gutils.h>
35		#include <glib/glib-typeof.h>
36
37		G_BEGIN_DECLS
38
39		/**
40		* GMemVTable:
41		* @malloc: function to use for allocating memory.
42		* @realloc: function to use for reallocating memory.
43		* @free: function to use to free memory.
44		* @calloc: function to use for allocating zero-filled memory.
45		* @try_malloc: function to use for allocating memory without a default error handler.
46		* @try_realloc: function to use for reallocating memory without a default error handler.
47		*
48		* A set of functions used to perform memory allocation. The same #GMemVTable must
49		* be used for all allocations in the same program; a call to g_mem_set_vtable(),
50		* if it exists, should be prior to any use of GLib.
51		*
52		* This functions related to this has been deprecated in 2.46, and no longer work.
53		*/
54		typedef struct _GMemVTable GMemVTable;
55
56
57		#if GLIB_SIZEOF_VOID_P > GLIB_SIZEOF_LONG
58		/**
59		* G_MEM_ALIGN:
60		*
61		* Indicates the number of bytes to which memory will be aligned on the
62		* current platform.
63		*/
64		# define G_MEM_ALIGN GLIB_SIZEOF_VOID_P
65		#else /* GLIB_SIZEOF_VOID_P <= GLIB_SIZEOF_LONG */
66		# define G_MEM_ALIGN GLIB_SIZEOF_LONG
67		#endif /* GLIB_SIZEOF_VOID_P <= GLIB_SIZEOF_LONG */
68
69
70		/* Memory allocation functions
71		*/
72
73		GLIB_AVAILABLE_IN_ALL
74		void (g_free) (gpointer mem);
75		GLIB_AVAILABLE_IN_2_76
76		void g_free_sized (gpointer mem,
77		size_t size);
78
79		GLIB_AVAILABLE_IN_2_34
80		void g_clear_pointer (gpointer *pp,
81		GDestroyNotify destroy);
82
83		GLIB_AVAILABLE_IN_ALL
84		gpointer g_malloc (gsize n_bytes) G_GNUC_MALLOC G_GNUC_ALLOC_SIZE(1);
85		GLIB_AVAILABLE_IN_ALL
86		gpointer g_malloc0 (gsize n_bytes) G_GNUC_MALLOC G_GNUC_ALLOC_SIZE(1);
87		GLIB_AVAILABLE_IN_ALL
88		gpointer g_realloc (gpointer mem,
89		gsize n_bytes) G_GNUC_WARN_UNUSED_RESULT;
90		GLIB_AVAILABLE_IN_ALL
91		gpointer g_try_malloc (gsize n_bytes) G_GNUC_MALLOC G_GNUC_ALLOC_SIZE(1);
92		GLIB_AVAILABLE_IN_ALL
93		gpointer g_try_malloc0 (gsize n_bytes) G_GNUC_MALLOC G_GNUC_ALLOC_SIZE(1);
94		GLIB_AVAILABLE_IN_ALL
95		gpointer g_try_realloc (gpointer mem,
96		gsize n_bytes) G_GNUC_WARN_UNUSED_RESULT;
97
98		GLIB_AVAILABLE_IN_ALL
99		gpointer g_malloc_n (gsize n_blocks,
100		gsize n_block_bytes) G_GNUC_MALLOC G_GNUC_ALLOC_SIZE2(1,2);
101		GLIB_AVAILABLE_IN_ALL
102		gpointer g_malloc0_n (gsize n_blocks,
103		gsize n_block_bytes) G_GNUC_MALLOC G_GNUC_ALLOC_SIZE2(1,2);
104		GLIB_AVAILABLE_IN_ALL
105		gpointer g_realloc_n (gpointer mem,
106		gsize n_blocks,
107		gsize n_block_bytes) G_GNUC_WARN_UNUSED_RESULT;
108		GLIB_AVAILABLE_IN_ALL
109		gpointer g_try_malloc_n (gsize n_blocks,
110		gsize n_block_bytes) G_GNUC_MALLOC G_GNUC_ALLOC_SIZE2(1,2);
111		GLIB_AVAILABLE_IN_ALL
112		gpointer g_try_malloc0_n (gsize n_blocks,
113		gsize n_block_bytes) G_GNUC_MALLOC G_GNUC_ALLOC_SIZE2(1,2);
114		GLIB_AVAILABLE_IN_ALL
115		gpointer g_try_realloc_n (gpointer mem,
116		gsize n_blocks,
117		gsize n_block_bytes) G_GNUC_WARN_UNUSED_RESULT;
118
119		GLIB_AVAILABLE_IN_2_72
120		gpointer g_aligned_alloc (gsize n_blocks,
121		gsize n_block_bytes,
122		gsize alignment) G_GNUC_WARN_UNUSED_RESULT G_GNUC_ALLOC_SIZE2(1,2);
123		GLIB_AVAILABLE_IN_2_72
124		gpointer g_aligned_alloc0 (gsize n_blocks,
125		gsize n_block_bytes,
126		gsize alignment) G_GNUC_WARN_UNUSED_RESULT G_GNUC_ALLOC_SIZE2(1,2);
127		GLIB_AVAILABLE_IN_2_72
128		void g_aligned_free (gpointer mem);
129		GLIB_AVAILABLE_IN_2_76
130		void g_aligned_free_sized (gpointer mem,
131		size_t alignment,
132		size_t size);
133
134		#if defined(glib_typeof) && GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_58
135		#define g_clear_pointer(pp, destroy) \
136		G_STMT_START \
137		{ \
138		G_STATIC_ASSERT (sizeof *(pp) == sizeof (gpointer)); \
139		glib_typeof ((pp)) _pp = (pp); \
140		glib_typeof ((pp)) _ptr = _pp; \
141		*_pp = NULL; \
142		if (_ptr) \
143		(destroy) (_ptr); \
144		} \
145		G_STMT_END \
146		GLIB_AVAILABLE_MACRO_IN_2_34
147		#else /* __GNUC__ */
148		#define g_clear_pointer(pp, destroy) \
149		G_STMT_START { \
150		G_STATIC_ASSERT (sizeof *(pp) == sizeof (gpointer)); \
151		/* Only one access, please; work around type aliasing */ \
152		union { char in; gpointer out; } _pp; \
153		gpointer _p; \
154		/* This assignment is needed to avoid a gcc warning */ \
155		GDestroyNotify _destroy = (GDestroyNotify) (destroy); \
156		\
157		_pp.in = (char *) (pp); \
158		_p = *_pp.out; \
159		if (_p) \
160		{ \
161		*_pp.out = NULL; \
162		_destroy (_p); \
163		} \
164		} G_STMT_END \
165		GLIB_AVAILABLE_MACRO_IN_2_34
166		#endif /* __GNUC__ */
167
168
169		#if G_GNUC_CHECK_VERSION (4, 1) && GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_78 && defined(G_HAVE_FREE_SIZED)
170
171		#define g_free(mem) \
172		(__builtin_object_size ((mem), 0) != ((size_t) - 1)) ? \
173		g_free_sized (mem, __builtin_object_size ((mem), 0)) : (g_free) (mem)
174
175		#endif /* G_GNUC_CHECK_VERSION (4, 1) && && GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_78 && defined(G_HAVE_FREE_SIZED) */
176
177		/**
178		* g_steal_pointer:
179		* @pp: (not nullable): a pointer to a pointer
180		*
181		* Sets @pp to %NULL, returning the value that was there before.
182		*
183		* Conceptually, this transfers the ownership of the pointer from the
184		* referenced variable to the "caller" of the macro (ie: "steals" the
185		* reference).
186		*
187		* The return value will be properly typed, according to the type of
188		* @pp.
189		*
190		* This can be very useful when combined with g_autoptr() to prevent the
191		* return value of a function from being automatically freed. Consider
192		* the following example (which only works on GCC and clang):
193		*
194		* \|[
195		* GObject *
196		* create_object (void)
197		* {
198		* g_autoptr(GObject) obj = g_object_new (G_TYPE_OBJECT, NULL);
199		*
200		* if (early_error_case)
201		* return NULL;
202		*
203		* return g_steal_pointer (&obj);
204		* }
205		* ]\|
206		*
207		* It can also be used in similar ways for 'out' parameters and is
208		* particularly useful for dealing with optional out parameters:
209		*
210		* \|[
211		* gboolean
212		* get_object (GObject **obj_out)
213		* {
214		* g_autoptr(GObject) obj = g_object_new (G_TYPE_OBJECT, NULL);
215		*
216		* if (early_error_case)
217		* return FALSE;
218		*
219		* if (obj_out)
220		* *obj_out = g_steal_pointer (&obj);
221		*
222		* return TRUE;
223		* }
224		* ]\|
225		*
226		* In the above example, the object will be automatically freed in the
227		* early error case and also in the case that %NULL was given for
228		* @obj_out.
229		*
230		* Since: 2.44
231		*/
232		GLIB_AVAILABLE_STATIC_INLINE_IN_2_44
233		static inline gpointer g_steal_pointer (gpointer pp);
234
235		GLIB_AVAILABLE_STATIC_INLINE_IN_2_44
236		static inline gpointer
237		g_steal_pointer (gpointer pp)
238	0	{
239	0	gpointer ptr = (gpointer ) pp;
240	0	gpointer ref;
241	0
242	0	ref = *ptr;
243	0	*ptr = NULL;
244	0
245	0	return ref;
246	0	}
247
248		/* type safety */
249		#if defined(glib_typeof) && GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_58
250		#define g_steal_pointer(pp) ((glib_typeof (*pp)) (g_steal_pointer) (pp))
251		#else /* __GNUC__ */
252		/* This version does not depend on gcc extensions, but gcc does not warn
253		* about incompatible-pointer-types: */
254		#define g_steal_pointer(pp) \
255		(0 ? (*(pp)) : (g_steal_pointer) (pp))
256		#endif /* __GNUC__ */
257
258		/* Optimise: avoid the call to the (slower) _n function if we can
259		* determine at compile-time that no overflow happens.
260		*/
261		#if defined (__GNUC__) && (__GNUC__ >= 2) && defined (__OPTIMIZE__)
262		# define _G_NEW(struct_type, n_structs, func) \
263		(struct_type *) (G_GNUC_EXTENSION ({ \
264		gsize __n = (gsize) (n_structs); \
265		gsize __s = sizeof (struct_type); \
266		gpointer __p; \
267		if (__s == 1) \
268		__p = g_##func (__n); \
269		else if (__builtin_constant_p (__n) && \
270		(__s == 0 \|\| __n <= G_MAXSIZE / __s)) \
271		__p = g_##func (__n * __s); \
272		else \
273		__p = g_##func##_n (__n, __s); \
274		__p; \
275		}))
276		# define _G_RENEW(struct_type, mem, n_structs, func) \
277		(struct_type *) (G_GNUC_EXTENSION ({ \
278		gsize __n = (gsize) (n_structs); \
279		gsize __s = sizeof (struct_type); \
280		gpointer __p = (gpointer) (mem); \
281		if (__s == 1) \
282		__p = g_##func (__p, __n); \
283		else if (__builtin_constant_p (__n) && \
284		(__s == 0 \|\| __n <= G_MAXSIZE / __s)) \
285		__p = g_##func (__p, __n * __s); \
286		else \
287		__p = g_##func##_n (__p, __n, __s); \
288		__p; \
289		}))
290
291		#else
292
293		/* Unoptimised version: always call the _n() function. */
294
295		#define _G_NEW(struct_type, n_structs, func) \
296		((struct_type *) g_##func##_n ((n_structs), sizeof (struct_type)))
297		#define _G_RENEW(struct_type, mem, n_structs, func) \
298		((struct_type *) g_##func##_n (mem, (n_structs), sizeof (struct_type)))
299
300		#endif
301
302		/**
303		* g_new:
304		* @struct_type: the type of the elements to allocate
305		* @n_structs: the number of elements to allocate
306		*
307		* Allocates @n_structs elements of type @struct_type.
308		* The returned pointer is cast to a pointer to the given type.
309		* If @n_structs is 0 it returns %NULL.
310		* Care is taken to avoid overflow when calculating the size of the allocated block.
311		*
312		* Since the returned pointer is already casted to the right type,
313		* it is normally unnecessary to cast it explicitly, and doing
314		* so might hide memory allocation errors.
315		*
316		* Returns: a pointer to the allocated memory, cast to a pointer to @struct_type
317		*/
318		#define g_new(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc)
319		/**
320		* g_new0:
321		* @struct_type: the type of the elements to allocate.
322		* @n_structs: the number of elements to allocate.
323		*
324		* Allocates @n_structs elements of type @struct_type, initialized to 0's.
325		* The returned pointer is cast to a pointer to the given type.
326		* If @n_structs is 0 it returns %NULL.
327		* Care is taken to avoid overflow when calculating the size of the allocated block.
328		*
329		* Since the returned pointer is already casted to the right type,
330		* it is normally unnecessary to cast it explicitly, and doing
331		* so might hide memory allocation errors.
332		*
333		* Returns: a pointer to the allocated memory, cast to a pointer to @struct_type.
334		*/
335		#define g_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc0)
336		/**
337		* g_renew:
338		* @struct_type: the type of the elements to allocate
339		* @mem: the currently allocated memory
340		* @n_structs: the number of elements to allocate
341		*
342		* Reallocates the memory pointed to by @mem, so that it now has space for
343		* @n_structs elements of type @struct_type. It returns the new address of
344		* the memory, which may have been moved.
345		* Care is taken to avoid overflow when calculating the size of the allocated block.
346		*
347		* Returns: a pointer to the new allocated memory, cast to a pointer to @struct_type
348		*/
349		#define g_renew(struct_type, mem, n_structs) _G_RENEW (struct_type, mem, n_structs, realloc)
350		/**
351		* g_try_new:
352		* @struct_type: the type of the elements to allocate
353		* @n_structs: the number of elements to allocate
354		*
355		* Attempts to allocate @n_structs elements of type @struct_type, and returns
356		* %NULL on failure. Contrast with g_new(), which aborts the program on failure.
357		* The returned pointer is cast to a pointer to the given type.
358		* The function returns %NULL when @n_structs is 0 of if an overflow occurs.
359		*
360		* Since: 2.8
361		* Returns: a pointer to the allocated memory, cast to a pointer to @struct_type
362		*/
363		#define g_try_new(struct_type, n_structs) _G_NEW (struct_type, n_structs, try_malloc)
364		/**
365		* g_try_new0:
366		* @struct_type: the type of the elements to allocate
367		* @n_structs: the number of elements to allocate
368		*
369		* Attempts to allocate @n_structs elements of type @struct_type, initialized
370		* to 0's, and returns %NULL on failure. Contrast with g_new0(), which aborts
371		* the program on failure.
372		* The returned pointer is cast to a pointer to the given type.
373		* The function returns %NULL when @n_structs is 0 or if an overflow occurs.
374		*
375		* Since: 2.8
376		* Returns: a pointer to the allocated memory, cast to a pointer to @struct_type
377		*/
378		#define g_try_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, try_malloc0)
379		/**
380		* g_try_renew:
381		* @struct_type: the type of the elements to allocate
382		* @mem: the currently allocated memory
383		* @n_structs: the number of elements to allocate
384		*
385		* Attempts to reallocate the memory pointed to by @mem, so that it now has
386		* space for @n_structs elements of type @struct_type, and returns %NULL on
387		* failure. Contrast with g_renew(), which aborts the program on failure.
388		* It returns the new address of the memory, which may have been moved.
389		* The function returns %NULL if an overflow occurs.
390		*
391		* Since: 2.8
392		* Returns: a pointer to the new allocated memory, cast to a pointer to @struct_type
393		*/
394		#define g_try_renew(struct_type, mem, n_structs) _G_RENEW (struct_type, mem, n_structs, try_realloc)
395
396
397		/* Memory allocation virtualization for debugging purposes
398		* g_mem_set_vtable() has to be the very first GLib function called
399		* if being used
400		*/
401		struct _GMemVTable {
402		gpointer (*malloc) (gsize n_bytes);
403		gpointer (*realloc) (gpointer mem,
404		gsize n_bytes);
405		void (*free) (gpointer mem);
406		/* optional; set to NULL if not used ! */
407		gpointer (*calloc) (gsize n_blocks,
408		gsize n_block_bytes);
409		gpointer (*try_malloc) (gsize n_bytes);
410		gpointer (*try_realloc) (gpointer mem,
411		gsize n_bytes);
412		};
413		GLIB_DEPRECATED_IN_2_46
414		void g_mem_set_vtable (GMemVTable *vtable);
415		GLIB_DEPRECATED_IN_2_46
416		gboolean g_mem_is_system_malloc (void);
417
418		GLIB_VAR gboolean g_mem_gc_friendly;
419
420		/* Memory profiler and checker, has to be enabled via g_mem_set_vtable()
421		*/
422		GLIB_VAR GMemVTable *glib_mem_profiler_table;
423		GLIB_DEPRECATED_IN_2_46
424		void g_mem_profile (void);
425
426		G_END_DECLS
427
428		#endif /* __G_MEM_H__ */