1 /*

     2 ** 2007 August 14

     3 **

     4 ** The author disclaims copyright to this source code.  In place of

     5 ** a legal notice, here is a blessing:

     6 **

     7 **    May you do good and not evil.

     8 **    May you find forgiveness for yourself and forgive others.

     9 **    May you share freely, never taking more than you give.

    10 **

    11 *************************************************************************

    12 **

    13 ** This file contains low-level memory allocation drivers for when

    14 ** SQLite will use the standard C-library malloc/realloc/free interface

    15 ** to obtain the memory it needs.

    16 **

    17 ** This file contains implementations of the low-level memory allocation

    18 ** routines specified in the sqlite3_mem_methods object.

    19 **

    20 ** $Id: mem1.c,v 1.25 2008/07/25 08:49:00 danielk1977 Exp $

    21 */

    22 #include "sqliteInt.h"

    23 

    24 /*

    25 ** This version of the memory allocator is the default.  It is

    26 ** used when no other memory allocator is specified using compile-time

    27 ** macros.

    28 */

    29 #ifdef SQLITE_SYSTEM_MALLOC

    30 

    31 /*

    32 ** Like malloc(), but remember the size of the allocation

    33 ** so that we can find it later using sqlite3MemSize().

    34 **

    35 ** For this low-level routine, we are guaranteed that nByte>0 because

    36 ** cases of nByte<=0 will be intercepted and dealt with by higher level

    37 ** routines.

    38 */

    39 static void *sqlite3MemMalloc(int nByte){

    40   sqlite3_int64 *p;

    41   assert( nByte>0 );

    42   nByte = (nByte+7)&~7;

    43   p = malloc( nByte+8 );

    44   if( p ){

    45     p[0] = nByte;

    46     p++;

    47   }

    48   return (void *)p;

    49 }

    50 

    51 /*

    52 ** Like free() but works for allocations obtained from sqlite3MemMalloc()

    53 ** or sqlite3MemRealloc().

    54 **

    55 ** For this low-level routine, we already know that pPrior!=0 since

    56 ** cases where pPrior==0 will have been intecepted and dealt with

    57 ** by higher-level routines.

    58 */

    59 static void sqlite3MemFree(void *pPrior){

    60   sqlite3_int64 *p = (sqlite3_int64*)pPrior;

    61   assert( pPrior!=0 );

    62   p--;

    63   free(p);

    64 }

    65 

    66 /*

    67 ** Like realloc().  Resize an allocation previously obtained from

    68 ** sqlite3MemMalloc().

    69 **

    70 ** For this low-level interface, we know that pPrior!=0.  Cases where

    71 ** pPrior==0 while have been intercepted by higher-level routine and

    72 ** redirected to xMalloc.  Similarly, we know that nByte>0 becauses

    73 ** cases where nByte<=0 will have been intercepted by higher-level

    74 ** routines and redirected to xFree.

    75 */

    76 static void *sqlite3MemRealloc(void *pPrior, int nByte){

    77   sqlite3_int64 *p = (sqlite3_int64*)pPrior;

    78   assert( pPrior!=0 && nByte>0 );

    79   nByte = (nByte+7)&~7;

    80   p = (sqlite3_int64*)pPrior;

    81   p--;

    82   p = realloc(p, nByte+8 );

    83   if( p ){

    84     p[0] = nByte;

    85     p++;

    86   }

    87   return (void*)p;

    88 }

    89 

    90 /*

    91 ** Report the allocated size of a prior return from xMalloc()

    92 ** or xRealloc().

    93 */

    94 static int sqlite3MemSize(void *pPrior){

    95   sqlite3_int64 *p;

    96   if( pPrior==0 ) return 0;

    97   p = (sqlite3_int64*)pPrior;

    98   p--;

    99   return p[0];

   100 }

   101 

   102 /*

   103 ** Round up a request size to the next valid allocation size.

   104 */

   105 static int sqlite3MemRoundup(int n){

   106   return (n+7) & ~7;

   107 }

   108 

   109 /*

   110 ** Initialize this module.

   111 */

   112 static int sqlite3MemInit(void *NotUsed){

   113   return SQLITE_OK;

   114 }

   115 

   116 /*

   117 ** Deinitialize this module.

   118 */

   119 static void sqlite3MemShutdown(void *NotUsed){

   120   return;

   121 }

   122 

   123 const sqlite3_mem_methods *sqlite3MemGetDefault(void){

   124   static const sqlite3_mem_methods defaultMethods = {

   125      sqlite3MemMalloc,

   126      sqlite3MemFree,

   127      sqlite3MemRealloc,

   128      sqlite3MemSize,

   129      sqlite3MemRoundup,

   130      sqlite3MemInit,

   131      sqlite3MemShutdown,

   132      0

   133   };

   134   return &defaultMethods;

   135 }

   136 

   137 /*

   138 ** This routine is the only routine in this file with external linkage.

   139 **

   140 ** Populate the low-level memory allocation function pointers in

   141 ** sqlite3Config.m with pointers to the routines in this file.

   142 */

   143 void sqlite3MemSetDefault(void){

   144   sqlite3_config(SQLITE_CONFIG_MALLOC, sqlite3MemGetDefault());

   145 }

   146 

   147 #endif /* SQLITE_SYSTEM_MALLOC */