/*

 ** 2001 September 15

 **

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

 ** a legal notice, here is a blessing:

 **

 **    May you do good and not evil.

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

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

 **

 *************************************************************************

 ** Memory allocation functions used throughout sqlite.

 **

 **

 ** $Id$

 */

 #include "sqliteInt.h"

 #include <stdarg.h>

 #include <ctype.h>

 /*

 ** This routine runs when the memory allocator sees that the

 ** total memory allocation is about to exceed the soft heap

 ** limit.

 */

 static void softHeapLimitEnforcer(

   void *NotUsed, 

   sqlite3_int64 inUse,

   int allocSize

 ){

   sqlite3_release_memory(allocSize);

 }

 /*

 ** Set the soft heap-size limit for the current thread. Passing a

 ** zero or negative value indicates no limit.

 */

 void sqlite3_soft_heap_limit(int n){

   sqlite3_uint64 iLimit;

   int overage;

   if( n<0 ){

     iLimit = 0;

   }else{

     iLimit = n;

   }

   if( iLimit>0 ){

     sqlite3_memory_alarm(softHeapLimitEnforcer, 0, iLimit);

   }else{

     sqlite3_memory_alarm(0, 0, 0);

   }

   overage = sqlite3_memory_used() - n;

   if( overage>0 ){

     sqlite3_release_memory(overage);

   }

 }

 /*

 ** Release memory held by SQLite instances created by the current thread.

 */

 int sqlite3_release_memory(int n){

 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT

   return sqlite3PagerReleaseMemory(n);

 #else

   return SQLITE_OK;

 #endif

 }

 /*

 ** Allocate and zero memory.

 */ 

 void *sqlite3MallocZero(unsigned n){

   void *p = sqlite3_malloc(n);

   if( p ){

     memset(p, 0, n);

   }

   return p;

 }

 /*

 ** Allocate and zero memory.  If the allocation fails, make

 ** the mallocFailed flag in the connection pointer.

 */

 void *sqlite3DbMallocZero(sqlite3 *db, unsigned n){

   void *p = sqlite3DbMallocRaw(db, n);

   if( p ){

     memset(p, 0, n);

   }

   return p;

 }

 /*

 ** Allocate and zero memory.  If the allocation fails, make

 ** the mallocFailed flag in the connection pointer.

 */

 void *sqlite3DbMallocRaw(sqlite3 *db, unsigned n){

   void *p = 0;

   if( !db || db->mallocFailed==0 ){

     p = sqlite3_malloc(n);

     if( !p && db ){

       db->mallocFailed = 1;

     }

   }

   return p;

 }

 /*

 ** Resize the block of memory pointed to by p to n bytes. If the

 ** resize fails, set the mallocFailed flag inthe connection object.

 */

 void *sqlite3DbRealloc(sqlite3 *db, void *p, int n){

   void *pNew = 0;

   if( db->mallocFailed==0 ){

     pNew = sqlite3_realloc(p, n);

     if( !pNew ){

       db->mallocFailed = 1;

     }

   }

   return pNew;

 }

 /*

 ** Attempt to reallocate p.  If the reallocation fails, then free p

 ** and set the mallocFailed flag in the database connection.

 */

 void *sqlite3DbReallocOrFree(sqlite3 *db, void *p, int n){

   void *pNew;

   pNew = sqlite3DbRealloc(db, p, n);

   if( !pNew ){

     sqlite3_free(p);

   }

   return pNew;

 }

 /*

 ** Make a copy of a string in memory obtained from sqliteMalloc(). These 

 ** functions call sqlite3MallocRaw() directly instead of sqliteMalloc(). This

 ** is because when memory debugging is turned on, these two functions are 

 ** called via macros that record the current file and line number in the

 ** ThreadData structure.

 */

 char *sqlite3StrDup(const char *z){

   char *zNew;

   int n;

   if( z==0 ) return 0;

   n = strlen(z)+1;

   zNew = sqlite3_malloc(n);

   if( zNew ) memcpy(zNew, z, n);

   return zNew;

 }

 char *sqlite3StrNDup(const char *z, int n){

   char *zNew;

   if( z==0 ) return 0;

   zNew = sqlite3_malloc(n+1);

   if( zNew ){

     memcpy(zNew, z, n);

     zNew[n] = 0;

   }

   return zNew;

 }

 char *sqlite3DbStrDup(sqlite3 *db, const char *z){

   char *zNew = sqlite3StrDup(z);

   if( z && !zNew ){

     db->mallocFailed = 1;

   }

   return zNew;

 }

 char *sqlite3DbStrNDup(sqlite3 *db, const char *z, int n){

   char *zNew = sqlite3StrNDup(z, n);

   if( z && !zNew ){

     db->mallocFailed = 1;

   }

   return zNew;

 }

 /*

 ** Create a string from the 2nd and subsequent arguments (up to the

 ** first NULL argument), store the string in memory obtained from

 ** sqliteMalloc() and make the pointer indicated by the 1st argument

 ** point to that string.  The 1st argument must either be NULL or 

 ** point to memory obtained from sqliteMalloc().

 */

 void sqlite3SetString(char **pz, ...){

   va_list ap;

   int nByte;

   const char *z;

   char *zResult;

   assert( pz!=0 );

   nByte = 1;

   va_start(ap, pz);

   while( (z = va_arg(ap, const char*))!=0 ){

     nByte += strlen(z);

   }

   va_end(ap);

   sqlite3_free(*pz);

   *pz = zResult = sqlite3_malloc(nByte);

   if( zResult==0 ){

     return;

   }

   *zResult = 0;

   va_start(ap, pz);

   while( (z = va_arg(ap, const char*))!=0 ){

     int n = strlen(z);

     memcpy(zResult, z, n);

     zResult += n;

   }

   zResult[0] = 0;

   va_end(ap);

 }

 /*

 ** This function must be called before exiting any API function (i.e. 

 ** returning control to the user) that has called sqlite3_malloc or

 ** sqlite3_realloc.

 **

 ** The returned value is normally a copy of the second argument to this

 ** function. However, if a malloc() failure has occured since the previous

 ** invocation SQLITE_NOMEM is returned instead. 

 **

 ** If the first argument, db, is not NULL and a malloc() error has occured,

 ** then the connection error-code (the value returned by sqlite3_errcode())

 ** is set to SQLITE_NOMEM.

 */

 int sqlite3ApiExit(sqlite3* db, int rc){

   /* If the db handle is not NULL, then we must hold the connection handle

   ** mutex here. Otherwise the read (and possible write) of db->mallocFailed 

   ** is unsafe, as is the call to sqlite3Error().

   */

   assert( !db || sqlite3_mutex_held(db->mutex) );

   if( db && db->mallocFailed ){

     sqlite3Error(db, SQLITE_NOMEM, 0);

     db->mallocFailed = 0;

     rc = SQLITE_NOMEM;

   }

   return rc & (db ? db->errMask : 0xff);

 }