XenevaOS
Loading...
Searching...
No Matches
Macros | Functions
ftmemory.h File Reference
#include <ft2build.h>
Include dependency graph for ftmemory.h:

Go to the source code of this file.

Macros

#define FT_SET_ERROR(expression)    ( ( error = (expression) ) != 0 )
 
#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 ) )

◆ FT_ALLOC_MULT

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

◆ FT_ARRAY_CHECK

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

◆ FT_ARRAY_COPY

#define FT_ARRAY_COPY (   dest,
  source,
  count 
)
Value:
FT_MEM_COPY( dest, \
source, \
(FT_Offset)(count) * sizeof ( *(dest) ) )
FT_MEM_COPY
#define FT_MEM_COPY(dest, source, count)
Definition ftmemory.h:228
FT_Offset
size_t FT_Offset
Definition fttypes.h:323

◆ FT_ARRAY_MAX

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

◆ FT_ARRAY_MOVE

#define FT_ARRAY_MOVE (   dest,
  source,
  count 
)
Value:
FT_MEM_MOVE( dest, \
source, \
(FT_Offset)(count) * sizeof ( *(dest) ) )
FT_MEM_MOVE
#define FT_MEM_MOVE(dest, source, count)
Definition ftmemory.h:231

◆ 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:235

◆ FT_ASSIGNP

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

◆ FT_ASSIGNP_INNER

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

◆ FT_DEBUG_INNER

#define FT_DEBUG_INNER (   exp)    (exp)

◆ FT_DUP

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

◆ FT_FREE

#define FT_FREE (   ptr)    FT_MEM_FREE( ptr )

◆ FT_MEM_ALLOC

#define FT_MEM_ALLOC (   ptr,
  size 
)
Value:
FT_ASSIGNP_INNER( ptr, ft_mem_alloc( memory, \
(FT_Long)(size), \
&error ) )
ft_mem_alloc
ft_mem_alloc(FT_Memory memory, FT_Long size, FT_Error *p_error)
FT_ASSIGNP_INNER
#define FT_ASSIGNP_INNER(p, exp)
Definition ftmemory.h:104
FT_Long
signed long FT_Long
Definition fttypes.h:242

◆ 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 ) )
NULL
#define NULL
Definition actypes.h:561
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)

◆ FT_MEM_COPY

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

◆ FT_MEM_DUP

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

◆ FT_MEM_FREE

#define FT_MEM_FREE (   ptr)
Value:
FT_BEGIN_STMNT \
ft_mem_free( memory, (ptr) ); \
(ptr) = NULL; \
FT_END_STMNT
FT_END_STMNT
#define FT_END_STMNT
Definition ftconfig.h:352

◆ FT_MEM_MOVE

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

◆ FT_MEM_NEW

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

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

◆ FT_MEM_QALLOC

#define FT_MEM_QALLOC (   ptr,
  size 
)
Value:
FT_ASSIGNP_INNER( ptr, ft_mem_qalloc( memory, \
(FT_Long)(size), \
&error ) )
ft_mem_qalloc
ft_mem_qalloc(FT_Memory memory, FT_Long size, FT_Error *p_error)

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

◆ FT_MEM_QNEW

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

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

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

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

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

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

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

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

◆ FT_MEM_SET

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

◆ FT_MEM_SET_ERROR

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

◆ FT_MEM_STRDUP

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

◆ FT_MEM_ZERO

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

◆ FT_NEW

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

◆ FT_NEW_ARRAY

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

◆ FT_QALLOC

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

◆ FT_QALLOC_MULT

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

◆ FT_QNEW

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

◆ FT_QNEW_ARRAY

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

◆ FT_QREALLOC

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

◆ 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:222
FT_MEM_QREALLOC_MULT
#define FT_MEM_QREALLOC_MULT(ptr, oldcnt, newcnt, itmsz)
Definition ftmemory.h:213

◆ FT_QRENEW_ARRAY

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

◆ FT_REALLOC

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

◆ 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:197

◆ FT_RENEW_ARRAY

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

◆ FT_SET_ERROR

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

◆ FT_STRCPYN

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

◆ FT_STRDUP

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

◆ FT_ZERO

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

Function Documentation

◆ ft_mem_alloc()

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

◆ ft_mem_dup()

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

◆ ft_mem_free()

ft_mem_free ( FT_Memory  memory,
const void *  P 
)

◆ ft_mem_qalloc()

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

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

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

◆ ft_mem_strcpyn()

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

◆ ft_mem_strdup()

ft_mem_strdup ( FT_Memory  memory,
const char *  str,
FT_Error *  p_error 
)
Generated by doxygen 1.9.8