|
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.26 2008/09/01 18:34:20 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 ** sqlite3GlobalConfig.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 */ |