#include <ft2build.h>
#include <freetype/fttypes.h>
#include "compiler-macros.h"

Include dependency graph for ftmemory.h:

This graph shows which files directly or indirectly include this file:

Macros
#define	FT_SET_ERROR(expression) ( ( error = (expression) ) != 0 )

#define	FT_OFFSET(base, count) ( (base) ? (base) + (count) : NULL )

#define	FT_ASSIGNP(p, val) (p) = (val)

#define	FT_DEBUG_INNER(exp) (exp)

#define	FT_ASSIGNP_INNER(p, exp) FT_ASSIGNP( p, exp )

#define	FT_MEM_ALLOC(ptr, size)

#define	FT_MEM_FREE(ptr)

#define	FT_MEM_NEW(ptr) FT_MEM_ALLOC( ptr, sizeof ( *(ptr) ) )

#define	FT_MEM_REALLOC(ptr, cursz, newsz)

#define	FT_MEM_QALLOC(ptr, size)

#define	FT_MEM_QNEW(ptr) FT_MEM_QALLOC( ptr, sizeof ( *(ptr) ) )

#define	FT_MEM_QREALLOC(ptr, cursz, newsz)

#define	FT_MEM_ALLOC_MULT(ptr, count, item_size)

#define	FT_MEM_REALLOC_MULT(ptr, oldcnt, newcnt, itmsz)

#define	FT_MEM_QALLOC_MULT(ptr, count, item_size)

#define	FT_MEM_QREALLOC_MULT(ptr, oldcnt, newcnt, itmsz)

#define	FT_MEM_SET_ERROR(cond) ( (cond), error != 0 )

#define	FT_MEM_SET(dest, byte, count) ft_memset( dest, byte, (FT_Offset)(count) )

#define	FT_MEM_COPY(dest, source, count) ft_memcpy( dest, source, (FT_Offset)(count) )

#define	FT_MEM_MOVE(dest, source, count) ft_memmove( dest, source, (FT_Offset)(count) )

#define	FT_MEM_ZERO(dest, count) FT_MEM_SET( dest, 0, count )

#define	FT_ZERO(p) FT_MEM_ZERO( p, sizeof ( *(p) ) )

#define	FT_ARRAY_ZERO(dest, count)

#define	FT_ARRAY_COPY(dest, source, count)

#define	FT_ARRAY_MOVE(dest, source, count)

#define	FT_ARRAY_MAX(ptr) ( FT_INT_MAX / sizeof ( *(ptr) ) )

#define	FT_ARRAY_CHECK(ptr, count) ( (count) <= FT_ARRAY_MAX( ptr ) )

#define	FT_MEM_NEW_ARRAY(ptr, count)

#define	FT_MEM_RENEW_ARRAY(ptr, cursz, newsz)

#define	FT_MEM_QNEW_ARRAY(ptr, count)

#define	FT_MEM_QRENEW_ARRAY(ptr, cursz, newsz)

#define	FT_ALLOC(ptr, size) FT_MEM_SET_ERROR( FT_MEM_ALLOC( ptr, size ) )

#define	FT_REALLOC(ptr, cursz, newsz) FT_MEM_SET_ERROR( FT_MEM_REALLOC( ptr, cursz, newsz ) )

#define	FT_ALLOC_MULT(ptr, count, item_size) FT_MEM_SET_ERROR( FT_MEM_ALLOC_MULT( ptr, count, item_size ) )

#define	FT_REALLOC_MULT(ptr, oldcnt, newcnt, itmsz)

#define	FT_QALLOC(ptr, size) FT_MEM_SET_ERROR( FT_MEM_QALLOC( ptr, size ) )

#define	FT_QREALLOC(ptr, cursz, newsz) FT_MEM_SET_ERROR( FT_MEM_QREALLOC( ptr, cursz, newsz ) )

#define	FT_QALLOC_MULT(ptr, count, item_size) FT_MEM_SET_ERROR( FT_MEM_QALLOC_MULT( ptr, count, item_size ) )

#define	FT_QREALLOC_MULT(ptr, oldcnt, newcnt, itmsz)

#define	FT_FREE(ptr) FT_MEM_FREE( ptr )

#define	FT_NEW(ptr) FT_MEM_SET_ERROR( FT_MEM_NEW( ptr ) )

#define	FT_NEW_ARRAY(ptr, count) FT_MEM_SET_ERROR( FT_MEM_NEW_ARRAY( ptr, count ) )

#define	FT_RENEW_ARRAY(ptr, curcnt, newcnt) FT_MEM_SET_ERROR( FT_MEM_RENEW_ARRAY( ptr, curcnt, newcnt ) )

#define	FT_QNEW(ptr) FT_MEM_SET_ERROR( FT_MEM_QNEW( ptr ) )

#define	FT_QNEW_ARRAY(ptr, count) FT_MEM_SET_ERROR( FT_MEM_NEW_ARRAY( ptr, count ) )

#define	FT_QRENEW_ARRAY(ptr, curcnt, newcnt) FT_MEM_SET_ERROR( FT_MEM_RENEW_ARRAY( ptr, curcnt, newcnt ) )

#define	FT_MEM_STRDUP(dst, str) (dst) = (char)ft_mem_strdup( memory, (const char)(str), &error )

#define	FT_STRDUP(dst, str) FT_MEM_SET_ERROR( FT_MEM_STRDUP( dst, str ) )

#define	FT_MEM_DUP(dst, address, size) (dst) = ft_mem_dup( memory, (address), (FT_ULong)(size), &error )

#define	FT_DUP(dst, address, size) FT_MEM_SET_ERROR( FT_MEM_DUP( dst, address, size ) )

#define	FT_STRCPYN(dst, src, size) ft_mem_strcpyn( (char)dst, (const char)(src), (FT_ULong)(size) )

Functions
	ft_mem_alloc (FT_Memory memory, FT_Long size, FT_Error *p_error)

	ft_mem_qalloc (FT_Memory memory, FT_Long size, FT_Error *p_error)

	ft_mem_realloc (FT_Memory memory, FT_Long item_size, FT_Long cur_count, FT_Long new_count, void block, FT_Error p_error)

	ft_mem_qrealloc (FT_Memory memory, FT_Long item_size, FT_Long cur_count, FT_Long new_count, void block, FT_Error p_error)

	ft_mem_free (FT_Memory memory, const void *P)

	ft_mem_strdup (FT_Memory memory, const char str, FT_Error p_error)

	ft_mem_dup (FT_Memory memory, const void address, FT_ULong size, FT_Error p_error)

	ft_mem_strcpyn (char dst, const char src, FT_ULong size)

Macro Definition Documentation

◆ FT_ALLOC

#define FT_ALLOC	(	ptr,
		size
	)	FT_MEM_SET_ERROR( FT_MEM_ALLOC( ptr, size ) )

Definition at line 311 of file ftmemory.h.

◆ FT_ALLOC_MULT

#define FT_ALLOC_MULT	(	ptr,
		count,
		item_size
	)	FT_MEM_SET_ERROR( FT_MEM_ALLOC_MULT( ptr, count, item_size ) )

Definition at line 317 of file ftmemory.h.

◆ FT_ARRAY_CHECK

#define FT_ARRAY_CHECK	(	ptr,
		count
	)	( (count) <= FT_ARRAY_MAX( ptr ) )

Definition at line 270 of file ftmemory.h.

◆ FT_ARRAY_COPY

#define FT_ARRAY_COPY	(	dest,
		source,
		count
	)

Value:

          FT_MEM_COPY( dest,                                     \
                       source,                                   \
                       (FT_Offset)(count) * sizeof ( *(dest) ) )

Definition at line 253 of file ftmemory.h.

◆ FT_ARRAY_MAX

#define FT_ARRAY_MAX ( ptr ) ( FT_INT_MAX / sizeof ( *(ptr) ) )

Definition at line 268 of file ftmemory.h.

◆ FT_ARRAY_MOVE

#define FT_ARRAY_MOVE	(	dest,
		source,
		count
	)

Value:

          FT_MEM_MOVE( dest,                                     \
                       source,                                   \
                       (FT_Offset)(count) * sizeof ( *(dest) ) )

Definition at line 258 of file ftmemory.h.

◆ FT_ARRAY_ZERO

#define FT_ARRAY_ZERO	(	dest,
		count
	)

Value:

FT_MEM_ZERO( dest, \

(FT_Offset)(count) * sizeof ( *(dest) ) )

FT_MEM_ZERO

#define FT_MEM_ZERO(dest, count)

Definition: ftmemory.h:244

Definition at line 249 of file ftmemory.h.

◆ FT_ASSIGNP

#define FT_ASSIGNP	(	p,
		val
	)	(p) = (val)

Definition at line 91 of file ftmemory.h.

◆ FT_ASSIGNP_INNER

#define FT_ASSIGNP_INNER	(	p,
		exp
	)	FT_ASSIGNP( p, exp )

Definition at line 113 of file ftmemory.h.

◆ FT_DEBUG_INNER

#define FT_DEBUG_INNER ( exp ) (exp)

Definition at line 112 of file ftmemory.h.

◆ FT_DUP

#define FT_DUP	(	dst,
		address,
		size
	)	FT_MEM_SET_ERROR( FT_MEM_DUP( dst, address, size ) )

Definition at line 378 of file ftmemory.h.

◆ FT_FREE

#define FT_FREE ( ptr ) FT_MEM_FREE( ptr )

Definition at line 337 of file ftmemory.h.

◆ FT_MEM_ALLOC

#define FT_MEM_ALLOC	(	ptr,
		size
	)

Value:

          FT_ASSIGNP_INNER( ptr, ft_mem_alloc( memory,          \
                                               (FT_Long)(size), \
                                               &error ) )

Definition at line 160 of file ftmemory.h.

◆ FT_MEM_ALLOC_MULT

#define FT_MEM_ALLOC_MULT	(	ptr,
		count,
		item_size
	)

Value:

          FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory,               \
                                                 (FT_Long)(item_size), \
                                                 0,                    \
                                                 (FT_Long)(count),     \
                                                 NULL,                 \
                                                 &error ) )

Definition at line 198 of file ftmemory.h.

◆ FT_MEM_COPY

#define FT_MEM_COPY	(	dest,
		source,
		count
	)	ft_memcpy( dest, source, (FT_Offset)(count) )

Definition at line 237 of file ftmemory.h.

◆ FT_MEM_DUP

#define FT_MEM_DUP	(	dst,
		address,
		size
	)	(dst) = ft_mem_dup( memory, (address), (FT_ULong)(size), &error )

Definition at line 375 of file ftmemory.h.

◆ FT_MEM_FREE

#define FT_MEM_FREE ( ptr )

Value:

          FT_BEGIN_STMNT                                    \
            FT_DEBUG_INNER( ft_mem_free( memory, (ptr) ) ); \
            (ptr) = NULL;                                   \
          FT_END_STMNT

Definition at line 165 of file ftmemory.h.

◆ FT_MEM_MOVE

#define FT_MEM_MOVE	(	dest,
		source,
		count
	)	ft_memmove( dest, source, (FT_Offset)(count) )

Definition at line 240 of file ftmemory.h.

◆ FT_MEM_NEW

#define FT_MEM_NEW ( ptr ) FT_MEM_ALLOC( ptr, sizeof ( *(ptr) ) )

Definition at line 171 of file ftmemory.h.

◆ FT_MEM_NEW_ARRAY

#define FT_MEM_NEW_ARRAY	(	ptr,
		count
	)

Value:

          FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory,            \
                                                 sizeof ( *(ptr) ), \
                                                 0,                 \
                                                 (FT_Long)(count),  \
                                                 NULL,              \
                                                 &error ) )

Definition at line 279 of file ftmemory.h.

◆ FT_MEM_QALLOC

#define FT_MEM_QALLOC	(	ptr,
		size
	)

Value:

          FT_ASSIGNP_INNER( ptr, ft_mem_qalloc( memory,          \
                                                (FT_Long)(size), \
                                                &error ) )

Definition at line 182 of file ftmemory.h.

◆ FT_MEM_QALLOC_MULT

#define FT_MEM_QALLOC_MULT	(	ptr,
		count,
		item_size
	)

Value:

          FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory,               \
                                                  (FT_Long)(item_size), \
                                                  0,                    \
                                                  (FT_Long)(count),     \
                                                  NULL,                 \
                                                  &error ) )

Definition at line 214 of file ftmemory.h.

◆ FT_MEM_QNEW

#define FT_MEM_QNEW ( ptr ) FT_MEM_QALLOC( ptr, sizeof ( *(ptr) ) )

Definition at line 187 of file ftmemory.h.

◆ FT_MEM_QNEW_ARRAY

#define FT_MEM_QNEW_ARRAY	(	ptr,
		count
	)

Value:

          FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory,            \
                                                  sizeof ( *(ptr) ), \
                                                  0,                 \
                                                  (FT_Long)(count),  \
                                                  NULL,              \
                                                  &error ) )

Definition at line 295 of file ftmemory.h.

◆ FT_MEM_QREALLOC

#define FT_MEM_QREALLOC	(	ptr,
		cursz,
		newsz
	)

Value:

          FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory,           \
                                                  1,                \
                                                  (FT_Long)(cursz), \
                                                  (FT_Long)(newsz), \
                                                  (ptr),            \
                                                  &error ) )

Definition at line 190 of file ftmemory.h.

◆ FT_MEM_QREALLOC_MULT

#define FT_MEM_QREALLOC_MULT	(	ptr,
		oldcnt,
		newcnt,
		itmsz
	)

Value:

          FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory,            \
                                                  (FT_Long)(itmsz),  \
                                                  (FT_Long)(oldcnt), \
                                                  (FT_Long)(newcnt), \
                                                  (ptr),             \
                                                  &error ) )

Definition at line 222 of file ftmemory.h.

◆ FT_MEM_QRENEW_ARRAY

#define FT_MEM_QRENEW_ARRAY	(	ptr,
		cursz,
		newsz
	)

Value:

          FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory,            \
                                                  sizeof ( *(ptr) ), \
                                                  (FT_Long)(cursz),  \
                                                  (FT_Long)(newsz),  \
                                                  (ptr),             \
                                                  &error ) )

Definition at line 303 of file ftmemory.h.

◆ FT_MEM_REALLOC

#define FT_MEM_REALLOC	(	ptr,
		cursz,
		newsz
	)

Value:

          FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory,           \
                                                 1,                \
                                                 (FT_Long)(cursz), \
                                                 (FT_Long)(newsz), \
                                                 (ptr),            \
                                                 &error ) )

Definition at line 174 of file ftmemory.h.

◆ FT_MEM_REALLOC_MULT

#define FT_MEM_REALLOC_MULT	(	ptr,
		oldcnt,
		newcnt,
		itmsz
	)

Value:

          FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory,            \
                                                 (FT_Long)(itmsz),  \
                                                 (FT_Long)(oldcnt), \
                                                 (FT_Long)(newcnt), \
                                                 (ptr),             \
                                                 &error ) )

Definition at line 206 of file ftmemory.h.

◆ FT_MEM_RENEW_ARRAY

#define FT_MEM_RENEW_ARRAY	(	ptr,
		cursz,
		newsz
	)

Value:

          FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory,            \
                                                 sizeof ( *(ptr) ), \
                                                 (FT_Long)(cursz),  \
                                                 (FT_Long)(newsz),  \
                                                 (ptr),             \
                                                 &error ) )

Definition at line 287 of file ftmemory.h.

◆ FT_MEM_SET

#define FT_MEM_SET	(	dest,
		byte,
		count
	)	ft_memset( dest, byte, (FT_Offset)(count) )

Definition at line 234 of file ftmemory.h.

◆ FT_MEM_SET_ERROR

#define FT_MEM_SET_ERROR ( cond ) ( (cond), error != 0 )

Definition at line 231 of file ftmemory.h.

◆ FT_MEM_STRDUP

#define FT_MEM_STRDUP	(	dst,
		str
	)	(dst) = (char)ft_mem_strdup( memory, (const char)(str), &error )

Definition at line 369 of file ftmemory.h.

◆ FT_MEM_ZERO

#define FT_MEM_ZERO	(	dest,
		count
	)	FT_MEM_SET( dest, 0, count )

Definition at line 244 of file ftmemory.h.

◆ FT_NEW

#define FT_NEW ( ptr ) FT_MEM_SET_ERROR( FT_MEM_NEW( ptr ) )

Definition at line 339 of file ftmemory.h.

◆ FT_NEW_ARRAY

#define FT_NEW_ARRAY	(	ptr,
		count
	)	FT_MEM_SET_ERROR( FT_MEM_NEW_ARRAY( ptr, count ) )

Definition at line 341 of file ftmemory.h.

◆ FT_OFFSET

#define FT_OFFSET	(	base,
		count
	)	( (base) ? (base) + (count) : NULL )

Definition at line 66 of file ftmemory.h.

◆ FT_QALLOC

#define FT_QALLOC	(	ptr,
		size
	)	FT_MEM_SET_ERROR( FT_MEM_QALLOC( ptr, size ) )

Definition at line 324 of file ftmemory.h.

◆ FT_QALLOC_MULT

#define FT_QALLOC_MULT	(	ptr,
		count,
		item_size
	)	FT_MEM_SET_ERROR( FT_MEM_QALLOC_MULT( ptr, count, item_size ) )

Definition at line 330 of file ftmemory.h.

◆ FT_QNEW

#define FT_QNEW ( ptr ) FT_MEM_SET_ERROR( FT_MEM_QNEW( ptr ) )

Definition at line 347 of file ftmemory.h.

◆ FT_QNEW_ARRAY

#define FT_QNEW_ARRAY	(	ptr,
		count
	)	FT_MEM_SET_ERROR( FT_MEM_NEW_ARRAY( ptr, count ) )

Definition at line 350 of file ftmemory.h.

◆ FT_QREALLOC

#define FT_QREALLOC	(	ptr,
		cursz,
		newsz
	)	FT_MEM_SET_ERROR( FT_MEM_QREALLOC( ptr, cursz, newsz ) )

Definition at line 327 of file ftmemory.h.

◆ FT_QREALLOC_MULT

#define FT_QREALLOC_MULT	(	ptr,
		oldcnt,
		newcnt,
		itmsz
	)

Value:

FT_MEM_SET_ERROR( FT_MEM_QREALLOC_MULT( ptr, oldcnt, \

newcnt, itmsz ) )

FT_MEM_SET_ERROR

#define FT_MEM_SET_ERROR(cond)

Definition: ftmemory.h:231

FT_MEM_QREALLOC_MULT

#define FT_MEM_QREALLOC_MULT(ptr, oldcnt, newcnt, itmsz)

Definition: ftmemory.h:222

Definition at line 333 of file ftmemory.h.

◆ FT_QRENEW_ARRAY

#define FT_QRENEW_ARRAY	(	ptr,
		curcnt,
		newcnt
	)	FT_MEM_SET_ERROR( FT_MEM_RENEW_ARRAY( ptr, curcnt, newcnt ) )

Definition at line 353 of file ftmemory.h.

◆ FT_REALLOC

#define FT_REALLOC	(	ptr,
		cursz,
		newsz
	)	FT_MEM_SET_ERROR( FT_MEM_REALLOC( ptr, cursz, newsz ) )

Definition at line 314 of file ftmemory.h.

◆ FT_REALLOC_MULT

#define FT_REALLOC_MULT	(	ptr,
		oldcnt,
		newcnt,
		itmsz
	)

Value:

FT_MEM_SET_ERROR( FT_MEM_REALLOC_MULT( ptr, oldcnt, \

newcnt, itmsz ) )

FT_MEM_REALLOC_MULT

#define FT_MEM_REALLOC_MULT(ptr, oldcnt, newcnt, itmsz)

Definition: ftmemory.h:206

Definition at line 320 of file ftmemory.h.

◆ FT_RENEW_ARRAY

#define FT_RENEW_ARRAY	(	ptr,
		curcnt,
		newcnt
	)	FT_MEM_SET_ERROR( FT_MEM_RENEW_ARRAY( ptr, curcnt, newcnt ) )

Definition at line 344 of file ftmemory.h.

◆ FT_SET_ERROR

#define FT_SET_ERROR ( expression ) ( ( error = (expression) ) != 0 )

Definition at line 43 of file ftmemory.h.

◆ FT_STRCPYN

#define FT_STRCPYN	(	dst,
		src,
		size
	)	ft_mem_strcpyn( (char)dst, (const char)(src), (FT_ULong)(size) )

Definition at line 390 of file ftmemory.h.

◆ FT_STRDUP

#define FT_STRDUP	(	dst,
		str
	)	FT_MEM_SET_ERROR( FT_MEM_STRDUP( dst, str ) )

Definition at line 372 of file ftmemory.h.

◆ FT_ZERO

#define FT_ZERO ( p ) FT_MEM_ZERO( p, sizeof ( *(p) ) )

Definition at line 246 of file ftmemory.h.

Function Documentation

◆ ft_mem_alloc()

ft_mem_alloc	(	FT_Memory	memory,
		FT_Long	size,
		FT_Error *	p_error
	)

Definition at line 49 of file ftutil.c.

  {
    FT_Error    error;
    FT_Pointer  block = ft_mem_qalloc( memory, size, &error );
 
    if ( !error && block && size > 0 )
      FT_MEM_ZERO( block, size );
 
    *p_error = error;
    return block;
  }

◆ ft_mem_dup()

ft_mem_dup	(	FT_Memory	memory,
		const void *	address,
		FT_ULong	size,
		FT_Error *	p_error
	)

Definition at line 178 of file ftutil.c.

  {
    FT_Error    error;
    FT_Pointer  p = ft_mem_qalloc( memory, (FT_Long)size, &error );
 
 
    if ( !error && address && size > 0 )
      ft_memcpy( p, address, size );
 
    *p_error = error;
    return p;
  }

Referenced by ft_mem_strdup().

◆ ft_mem_free()

ft_mem_free	(	FT_Memory	memory,
		const void *	P
	)

Definition at line 169 of file ftutil.c.

  {
    if ( P )
      memory->free( memory, (void*)P );
  }

Referenced by ft_mem_qrealloc(), FT_Stream_ExitFrame(), and FT_Stream_ReleaseFrame().

◆ ft_mem_qalloc()

ft_mem_qalloc	(	FT_Memory	memory,
		FT_Long	size,
		FT_Error *	p_error
	)

Definition at line 65 of file ftutil.c.

  {
    FT_Error    error = FT_Err_Ok;
    FT_Pointer  block = NULL;
 
 
    if ( size > 0 )
    {
      block = memory->alloc( memory, size );
      if ( !block )
        error = FT_THROW( Out_Of_Memory );
    }
    else if ( size < 0 )
    {
      /* may help catch/prevent security issues */
      error = FT_THROW( Invalid_Argument );
    }
 
    *p_error = error;
    return block;
  }

Referenced by ft_mem_alloc(), ft_mem_dup(), and FT_Stream_EnterFrame().

◆ ft_mem_qrealloc()

ft_mem_qrealloc	(	FT_Memory	memory,
		FT_Long	item_size,
		FT_Long	cur_count,
		FT_Long	new_count,
		void *	block,
		FT_Error *	p_error
	)

Definition at line 113 of file ftutil.c.

  {
    FT_Error  error = FT_Err_Ok;
 
 
    /* Note that we now accept `item_size == 0' as a valid parameter, in
     * order to cover very weird cases where an ALLOC_MULT macro would be
     * called.
     */
    if ( cur_count < 0 || new_count < 0 || item_size < 0 )
    {
      /* may help catch/prevent nasty security issues */
      error = FT_THROW( Invalid_Argument );
    }
    else if ( new_count == 0 || item_size == 0 )
    {
      ft_mem_free( memory, block );
      block = NULL;
    }
    else if ( new_count > FT_INT_MAX / item_size )
    {
      error = FT_THROW( Array_Too_Large );
    }
    else if ( cur_count == 0 )
    {
      FT_ASSERT( !block );
 
      block = memory->alloc( memory, new_count * item_size );
      if ( block == NULL )
        error = FT_THROW( Out_Of_Memory );
    }
    else
    {
      FT_Pointer  block2;
      FT_Long     cur_size = cur_count * item_size;
      FT_Long     new_size = new_count * item_size;
 
 
      block2 = memory->realloc( memory, cur_size, new_size, block );
      if ( !block2 )
        error = FT_THROW( Out_Of_Memory );
      else
        block = block2;
    }
 
    *p_error = error;
    return block;
  }

Referenced by ft_mem_realloc().

◆ ft_mem_realloc()

ft_mem_realloc	(	FT_Memory	memory,
		FT_Long	item_size,
		FT_Long	cur_count,
		FT_Long	new_count,
		void *	block,
		FT_Error *	p_error
	)

Definition at line 91 of file ftutil.c.

  {
    FT_Error  error = FT_Err_Ok;
 
 
    block = ft_mem_qrealloc( memory, item_size,
                             cur_count, new_count, block, &error );
    if ( !error && block && new_count > cur_count )
      FT_MEM_ZERO( (char*)block + cur_count * item_size,
                   ( new_count - cur_count ) * item_size );
 
    *p_error = error;
    return block;
  }

◆ ft_mem_strcpyn()

ft_mem_strcpyn	(	char *	dst,
		const char *	src,
		FT_ULong	size
	)

Definition at line 209 of file ftutil.c.

  {
    while ( size > 1 && *src != 0 )
    {
      *dst++ = *src++;
      size--;
    }
 
    *dst = 0;  /* always zero-terminate */
 
    return *src != 0;
  }

◆ ft_mem_strdup()

ft_mem_strdup	(	FT_Memory	memory,
		const char *	str,
		FT_Error *	p_error
	)

Definition at line 196 of file ftutil.c.

  {
    FT_ULong  len = str ? (FT_ULong)ft_strlen( str ) + 1
                        : 0;
 
 
    return ft_mem_dup( memory, str, len, p_error );
  }

Functions
	ft_mem_alloc (FT_Memory memory, FT_Long size, FT_Error *p_error)

	ft_mem_qalloc (FT_Memory memory, FT_Long size, FT_Error *p_error)

	ft_mem_realloc (FT_Memory memory, FT_Long item_size, FT_Long cur_count, FT_Long new_count, void block, FT_Error p_error)

	ft_mem_qrealloc (FT_Memory memory, FT_Long item_size, FT_Long cur_count, FT_Long new_count, void block, FT_Error p_error)

	ft_mem_free (FT_Memory memory, const void *P)

	ft_mem_strdup (FT_Memory memory, const char str, FT_Error p_error)

	ft_mem_dup (FT_Memory memory, const void address, FT_ULong size, FT_Error p_error)

	ft_mem_strcpyn (char dst, const char src, FT_ULong size)

Macros

Functions

Macro Definition Documentation

◆ FT_ALLOC

◆ FT_ALLOC_MULT

◆ FT_ARRAY_CHECK

◆ FT_ARRAY_COPY

◆ FT_ARRAY_MAX

◆ FT_ARRAY_MOVE

◆ FT_ARRAY_ZERO

◆ FT_ASSIGNP

◆ FT_ASSIGNP_INNER

◆ FT_DEBUG_INNER

◆ FT_DUP

◆ FT_FREE

◆ FT_MEM_ALLOC

◆ FT_MEM_ALLOC_MULT

◆ FT_MEM_COPY

◆ FT_MEM_DUP

◆ FT_MEM_FREE

◆ FT_MEM_MOVE

◆ FT_MEM_NEW

◆ FT_MEM_NEW_ARRAY

◆ FT_MEM_QALLOC

◆ FT_MEM_QALLOC_MULT

◆ FT_MEM_QNEW

◆ FT_MEM_QNEW_ARRAY

◆ FT_MEM_QREALLOC

◆ FT_MEM_QREALLOC_MULT

◆ FT_MEM_QRENEW_ARRAY

◆ FT_MEM_REALLOC

◆ FT_MEM_REALLOC_MULT

◆ FT_MEM_RENEW_ARRAY

◆ FT_MEM_SET

◆ FT_MEM_SET_ERROR

◆ FT_MEM_STRDUP

◆ FT_MEM_ZERO

◆ FT_NEW

◆ FT_NEW_ARRAY

◆ FT_OFFSET

◆ FT_QALLOC

◆ FT_QALLOC_MULT

◆ FT_QNEW

◆ FT_QNEW_ARRAY

◆ FT_QREALLOC

◆ FT_QREALLOC_MULT

◆ FT_QRENEW_ARRAY

◆ FT_REALLOC

◆ FT_REALLOC_MULT

◆ FT_RENEW_ARRAY

◆ FT_SET_ERROR

◆ FT_STRCPYN

◆ FT_STRDUP

◆ FT_ZERO

Function Documentation

◆ ft_mem_alloc()

◆ ft_mem_dup()

◆ ft_mem_free()

◆ ft_mem_qalloc()

◆ ft_mem_qrealloc()

◆ ft_mem_realloc()

◆ ft_mem_strcpyn()

◆ ft_mem_strdup()