Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. /***************************************************************************/
  2. /*                                                                         */
  3. /*  ftmemory.h                                                             */
  4. /*                                                                         */
  5. /*    The FreeType memory management macros (specification).               */
  6. /*                                                                         */
  7. /*  Copyright 1996-2002, 2004-2007, 2010, 2013 by                          */
  8. /*  David Turner, Robert Wilhelm, and Werner Lemberg                       */
  9. /*                                                                         */
  10. /*  This file is part of the FreeType project, and may only be used,       */
  11. /*  modified, and distributed under the terms of the FreeType project      */
  12. /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
  13. /*  this file you indicate that you have read the license and              */
  14. /*  understand and accept it fully.                                        */
  15. /*                                                                         */
  16. /***************************************************************************/
  17.  
  18.  
  19. #ifndef __FTMEMORY_H__
  20. #define __FTMEMORY_H__
  21.  
  22.  
  23. #include <ft2build.h>
  24. #include FT_CONFIG_CONFIG_H
  25. #include FT_TYPES_H
  26.  
  27.  
  28. FT_BEGIN_HEADER
  29.  
  30.  
  31.   /*************************************************************************/
  32.   /*                                                                       */
  33.   /* <Macro>                                                               */
  34.   /*    FT_SET_ERROR                                                       */
  35.   /*                                                                       */
  36.   /* <Description>                                                         */
  37.   /*    This macro is used to set an implicit `error' variable to a given  */
  38.   /*    expression's value (usually a function call), and convert it to a  */
  39.   /*    boolean which is set whenever the value is != 0.                   */
  40.   /*                                                                       */
  41. #undef  FT_SET_ERROR
  42. #define FT_SET_ERROR( expression ) \
  43.           ( ( error = (expression) ) != 0 )
  44.  
  45.  
  46.  
  47.   /*************************************************************************/
  48.   /*************************************************************************/
  49.   /*************************************************************************/
  50.   /****                                                                 ****/
  51.   /****                                                                 ****/
  52.   /****                           M E M O R Y                           ****/
  53.   /****                                                                 ****/
  54.   /****                                                                 ****/
  55.   /*************************************************************************/
  56.   /*************************************************************************/
  57.   /*************************************************************************/
  58.  
  59.  
  60.   /*
  61.    *  C++ refuses to handle statements like p = (void*)anything, with `p' a
  62.    *  typed pointer.  Since we don't have a `typeof' operator in standard
  63.    *  C++, we have to use a template to emulate it.
  64.    */
  65.  
  66. #ifdef __cplusplus
  67.  
  68.   extern "C++"
  69.   template <typename T> inline T*
  70.   cplusplus_typeof(        T*,
  71.                     void  *v )
  72.   {
  73.     return static_cast <T*> ( v );
  74.   }
  75.  
  76. #define FT_ASSIGNP( p, val )  (p) = cplusplus_typeof( (p), (val) )
  77.  
  78. #else
  79.  
  80. #define FT_ASSIGNP( p, val )  (p) = (val)
  81.  
  82. #endif
  83.  
  84.  
  85.  
  86. #ifdef FT_DEBUG_MEMORY
  87.  
  88.   FT_BASE( const char* )  _ft_debug_file;
  89.   FT_BASE( long )         _ft_debug_lineno;
  90.  
  91. #define FT_DEBUG_INNER( exp )  ( _ft_debug_file   = __FILE__, \
  92.                                  _ft_debug_lineno = __LINE__, \
  93.                                  (exp) )
  94.  
  95. #define FT_ASSIGNP_INNER( p, exp )  ( _ft_debug_file   = __FILE__, \
  96.                                       _ft_debug_lineno = __LINE__, \
  97.                                       FT_ASSIGNP( p, exp ) )
  98.  
  99. #else /* !FT_DEBUG_MEMORY */
  100.  
  101. #define FT_DEBUG_INNER( exp )       (exp)
  102. #define FT_ASSIGNP_INNER( p, exp )  FT_ASSIGNP( p, exp )
  103.  
  104. #endif /* !FT_DEBUG_MEMORY */
  105.  
  106.  
  107.   /*
  108.    *  The allocation functions return a pointer, and the error code
  109.    *  is written to through the `p_error' parameter.  See below for
  110.    *  for documentation.
  111.    */
  112.  
  113.   FT_BASE( FT_Pointer )
  114.   ft_mem_alloc( FT_Memory  memory,
  115.                 FT_Long    size,
  116.                 FT_Error  *p_error );
  117.  
  118.   FT_BASE( FT_Pointer )
  119.   ft_mem_qalloc( FT_Memory  memory,
  120.                  FT_Long    size,
  121.                  FT_Error  *p_error );
  122.  
  123.   FT_BASE( FT_Pointer )
  124.   ft_mem_realloc( FT_Memory  memory,
  125.                   FT_Long    item_size,
  126.                   FT_Long    cur_count,
  127.                   FT_Long    new_count,
  128.                   void*      block,
  129.                   FT_Error  *p_error );
  130.  
  131.   FT_BASE( FT_Pointer )
  132.   ft_mem_qrealloc( FT_Memory  memory,
  133.                    FT_Long    item_size,
  134.                    FT_Long    cur_count,
  135.                    FT_Long    new_count,
  136.                    void*      block,
  137.                    FT_Error  *p_error );
  138.  
  139.   FT_BASE( void )
  140.   ft_mem_free( FT_Memory    memory,
  141.                const void*  P );
  142.  
  143.  
  144. #define FT_MEM_ALLOC( ptr, size )                               \
  145.           FT_ASSIGNP_INNER( ptr, ft_mem_alloc( memory,          \
  146.                                                (FT_Long)(size), \
  147.                                                &error ) )
  148.  
  149. #define FT_MEM_FREE( ptr )                \
  150.           FT_BEGIN_STMNT                  \
  151.             ft_mem_free( memory, (ptr) ); \
  152.             (ptr) = NULL;                 \
  153.           FT_END_STMNT
  154.  
  155. #define FT_MEM_NEW( ptr )                        \
  156.           FT_MEM_ALLOC( ptr, sizeof ( *(ptr) ) )
  157.  
  158. #define FT_MEM_REALLOC( ptr, cursz, newsz )                        \
  159.           FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory,           \
  160.                                                  1,                \
  161.                                                  (FT_Long)(cursz), \
  162.                                                  (FT_Long)(newsz), \
  163.                                                  (ptr),            \
  164.                                                  &error ) )
  165.  
  166. #define FT_MEM_QALLOC( ptr, size )                               \
  167.           FT_ASSIGNP_INNER( ptr, ft_mem_qalloc( memory,          \
  168.                                                 (FT_Long)(size), \
  169.                                                 &error ) )
  170.  
  171. #define FT_MEM_QNEW( ptr )                        \
  172.           FT_MEM_QALLOC( ptr, sizeof ( *(ptr) ) )
  173.  
  174. #define FT_MEM_QREALLOC( ptr, cursz, newsz )                        \
  175.           FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory,           \
  176.                                                   1,                \
  177.                                                   (FT_Long)(cursz), \
  178.                                                   (FT_Long)(newsz), \
  179.                                                   (ptr),            \
  180.                                                   &error ) )
  181.  
  182. #define FT_MEM_ALLOC_MULT( ptr, count, item_size )                     \
  183.           FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory,               \
  184.                                                  (FT_Long)(item_size), \
  185.                                                  0,                    \
  186.                                                  (FT_Long)(count),     \
  187.                                                  NULL,                 \
  188.                                                  &error ) )
  189.  
  190. #define FT_MEM_REALLOC_MULT( ptr, oldcnt, newcnt, itmsz )           \
  191.           FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory,            \
  192.                                                  (FT_Long)(itmsz),  \
  193.                                                  (FT_Long)(oldcnt), \
  194.                                                  (FT_Long)(newcnt), \
  195.                                                  (ptr),             \
  196.                                                  &error ) )
  197.  
  198. #define FT_MEM_QALLOC_MULT( ptr, count, item_size )                     \
  199.           FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory,               \
  200.                                                   (FT_Long)(item_size), \
  201.                                                   0,                    \
  202.                                                   (FT_Long)(count),     \
  203.                                                   NULL,                 \
  204.                                                   &error ) )
  205.  
  206. #define FT_MEM_QREALLOC_MULT( ptr, oldcnt, newcnt, itmsz)            \
  207.           FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory,            \
  208.                                                   (FT_Long)(itmsz),  \
  209.                                                   (FT_Long)(oldcnt), \
  210.                                                   (FT_Long)(newcnt), \
  211.                                                   (ptr),             \
  212.                                                   &error ) )
  213.  
  214.  
  215. #define FT_MEM_SET_ERROR( cond )  ( (cond), error != 0 )
  216.  
  217.  
  218. #define FT_MEM_SET( dest, byte, count )     ft_memset( dest, byte, count )
  219.  
  220. #define FT_MEM_COPY( dest, source, count )  ft_memcpy( dest, source, count )
  221.  
  222. #define FT_MEM_MOVE( dest, source, count )  ft_memmove( dest, source, count )
  223.  
  224.  
  225. #define FT_MEM_ZERO( dest, count )  FT_MEM_SET( dest, 0, count )
  226.  
  227. #define FT_ZERO( p )                FT_MEM_ZERO( p, sizeof ( *(p) ) )
  228.  
  229.  
  230. #define FT_ARRAY_ZERO( dest, count )                        \
  231.           FT_MEM_ZERO( dest, (count) * sizeof ( *(dest) ) )
  232.  
  233. #define FT_ARRAY_COPY( dest, source, count )                        \
  234.           FT_MEM_COPY( dest, source, (count) * sizeof ( *(dest) ) )
  235.  
  236. #define FT_ARRAY_MOVE( dest, source, count )                        \
  237.           FT_MEM_MOVE( dest, source, (count) * sizeof ( *(dest) ) )
  238.  
  239.  
  240.   /*
  241.    *  Return the maximum number of addressable elements in an array.
  242.    *  We limit ourselves to INT_MAX, rather than UINT_MAX, to avoid
  243.    *  any problems.
  244.    */
  245. #define FT_ARRAY_MAX( ptr )           ( FT_INT_MAX / sizeof ( *(ptr) ) )
  246.  
  247. #define FT_ARRAY_CHECK( ptr, count )  ( (count) <= FT_ARRAY_MAX( ptr ) )
  248.  
  249.  
  250.   /*************************************************************************/
  251.   /*                                                                       */
  252.   /* The following functions macros expect that their pointer argument is  */
  253.   /* _typed_ in order to automatically compute array element sizes.        */
  254.   /*                                                                       */
  255.  
  256. #define FT_MEM_NEW_ARRAY( ptr, count )                              \
  257.           FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory,            \
  258.                                                  sizeof ( *(ptr) ), \
  259.                                                  0,                 \
  260.                                                  (FT_Long)(count),  \
  261.                                                  NULL,              \
  262.                                                  &error ) )
  263.  
  264. #define FT_MEM_RENEW_ARRAY( ptr, cursz, newsz )                     \
  265.           FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory,            \
  266.                                                  sizeof ( *(ptr) ), \
  267.                                                  (FT_Long)(cursz),  \
  268.                                                  (FT_Long)(newsz),  \
  269.                                                  (ptr),             \
  270.                                                  &error ) )
  271.  
  272. #define FT_MEM_QNEW_ARRAY( ptr, count )                              \
  273.           FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory,            \
  274.                                                   sizeof ( *(ptr) ), \
  275.                                                   0,                 \
  276.                                                   (FT_Long)(count),  \
  277.                                                   NULL,              \
  278.                                                   &error ) )
  279.  
  280. #define FT_MEM_QRENEW_ARRAY( ptr, cursz, newsz )                     \
  281.           FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory,            \
  282.                                                   sizeof ( *(ptr) ), \
  283.                                                   (FT_Long)(cursz),  \
  284.                                                   (FT_Long)(newsz),  \
  285.                                                   (ptr),             \
  286.                                                   &error ) )
  287.  
  288. #define FT_ALLOC( ptr, size )                           \
  289.           FT_MEM_SET_ERROR( FT_MEM_ALLOC( ptr, size ) )
  290.  
  291. #define FT_REALLOC( ptr, cursz, newsz )                           \
  292.           FT_MEM_SET_ERROR( FT_MEM_REALLOC( ptr, cursz, newsz ) )
  293.  
  294. #define FT_ALLOC_MULT( ptr, count, item_size )                           \
  295.           FT_MEM_SET_ERROR( FT_MEM_ALLOC_MULT( ptr, count, item_size ) )
  296.  
  297. #define FT_REALLOC_MULT( ptr, oldcnt, newcnt, itmsz )              \
  298.           FT_MEM_SET_ERROR( FT_MEM_REALLOC_MULT( ptr, oldcnt,      \
  299.                                                  newcnt, itmsz ) )
  300.  
  301. #define FT_QALLOC( ptr, size )                           \
  302.           FT_MEM_SET_ERROR( FT_MEM_QALLOC( ptr, size ) )
  303.  
  304. #define FT_QREALLOC( ptr, cursz, newsz )                           \
  305.           FT_MEM_SET_ERROR( FT_MEM_QREALLOC( ptr, cursz, newsz ) )
  306.  
  307. #define FT_QALLOC_MULT( ptr, count, item_size )                           \
  308.           FT_MEM_SET_ERROR( FT_MEM_QALLOC_MULT( ptr, count, item_size ) )
  309.  
  310. #define FT_QREALLOC_MULT( ptr, oldcnt, newcnt, itmsz )              \
  311.           FT_MEM_SET_ERROR( FT_MEM_QREALLOC_MULT( ptr, oldcnt,      \
  312.                                                   newcnt, itmsz ) )
  313.  
  314. #define FT_FREE( ptr )  FT_MEM_FREE( ptr )
  315.  
  316. #define FT_NEW( ptr )  FT_MEM_SET_ERROR( FT_MEM_NEW( ptr ) )
  317.  
  318. #define FT_NEW_ARRAY( ptr, count )                           \
  319.           FT_MEM_SET_ERROR( FT_MEM_NEW_ARRAY( ptr, count ) )
  320.  
  321. #define FT_RENEW_ARRAY( ptr, curcnt, newcnt )                           \
  322.           FT_MEM_SET_ERROR( FT_MEM_RENEW_ARRAY( ptr, curcnt, newcnt ) )
  323.  
  324. #define FT_QNEW( ptr )                           \
  325.           FT_MEM_SET_ERROR( FT_MEM_QNEW( ptr ) )
  326.  
  327. #define FT_QNEW_ARRAY( ptr, count )                          \
  328.           FT_MEM_SET_ERROR( FT_MEM_NEW_ARRAY( ptr, count ) )
  329.  
  330. #define FT_QRENEW_ARRAY( ptr, curcnt, newcnt )                          \
  331.           FT_MEM_SET_ERROR( FT_MEM_RENEW_ARRAY( ptr, curcnt, newcnt ) )
  332.  
  333.  
  334.   FT_BASE( FT_Pointer )
  335.   ft_mem_strdup( FT_Memory    memory,
  336.                  const char*  str,
  337.                  FT_Error    *p_error );
  338.  
  339.   FT_BASE( FT_Pointer )
  340.   ft_mem_dup( FT_Memory    memory,
  341.               const void*  address,
  342.               FT_ULong     size,
  343.               FT_Error    *p_error );
  344.  
  345.  
  346. #define FT_MEM_STRDUP( dst, str )                                            \
  347.           (dst) = (char*)ft_mem_strdup( memory, (const char*)(str), &error )
  348.  
  349. #define FT_STRDUP( dst, str )                           \
  350.           FT_MEM_SET_ERROR( FT_MEM_STRDUP( dst, str ) )
  351.  
  352. #define FT_MEM_DUP( dst, address, size )                                    \
  353.           (dst) = ft_mem_dup( memory, (address), (FT_ULong)(size), &error )
  354.  
  355. #define FT_DUP( dst, address, size )                           \
  356.           FT_MEM_SET_ERROR( FT_MEM_DUP( dst, address, size ) )
  357.  
  358.  
  359.   /* Return >= 1 if a truncation occurs.            */
  360.   /* Return 0 if the source string fits the buffer. */
  361.   /* This is *not* the same as strlcpy().           */
  362.   FT_BASE( FT_Int )
  363.   ft_mem_strcpyn( char*        dst,
  364.                   const char*  src,
  365.                   FT_ULong     size );
  366.  
  367. #define FT_STRCPYN( dst, src, size )                                         \
  368.           ft_mem_strcpyn( (char*)dst, (const char*)(src), (FT_ULong)(size) )
  369.  
  370.  /* */
  371.  
  372.  
  373. FT_END_HEADER
  374.  
  375. #endif /* __FTMEMORY_H__ */
  376.  
  377.  
  378. /* END */
  379.