| OLD | NEW |
|---|
| (Empty) |
| 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.30 2009/03/23 04:33:33 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 = ROUND8(nByte); | |
| 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 = ROUND8(nByte); | |
| 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 (int)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 ROUND8(n); | |
| 107 } | |
| 108 | |
| 109 /* | |
| 110 ** Initialize this module. | |
| 111 */ | |
| 112 static int sqlite3MemInit(void *NotUsed){ | |
| 113 UNUSED_PARAMETER(NotUsed); | |
| 114 return SQLITE_OK; | |
| 115 } | |
| 116 | |
| 117 /* | |
| 118 ** Deinitialize this module. | |
| 119 */ | |
| 120 static void sqlite3MemShutdown(void *NotUsed){ | |
| 121 UNUSED_PARAMETER(NotUsed); | |
| 122 return; | |
| 123 } | |
| 124 | |
| 125 /* | |
| 126 ** This routine is the only routine in this file with external linkage. | |
| 127 ** | |
| 128 ** Populate the low-level memory allocation function pointers in | |
| 129 ** sqlite3GlobalConfig.m with pointers to the routines in this file. | |
| 130 */ | |
| 131 void sqlite3MemSetDefault(void){ | |
| 132 static const sqlite3_mem_methods defaultMethods = { | |
| 133 sqlite3MemMalloc, | |
| 134 sqlite3MemFree, | |
| 135 sqlite3MemRealloc, | |
| 136 sqlite3MemSize, | |
| 137 sqlite3MemRoundup, | |
| 138 sqlite3MemInit, | |
| 139 sqlite3MemShutdown, | |
| 140 0 | |
| 141 }; | |
| 142 sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods); | |
| 143 } | |
| 144 | |
| 145 #endif /* SQLITE_SYSTEM_MALLOC */ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 3108030:
Move bundled copy of sqlite one level deeper to better separate it... (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src/