1 /*

     2 ** 2004 May 26

     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 code use to implement APIs that are part of the

    14 ** VDBE.

    15 **

    16 ** $Id: vdbeapi.c,v 1.147 2008/10/13 10:37:50 danielk1977 Exp $

    17 */

    18 #include "sqliteInt.h"

    19 #include "vdbeInt.h"

    20 

    21 #if 0 && defined(SQLITE_ENABLE_MEMORY_MANAGEMENT)

    22 /*

    23 ** The following structure contains pointers to the end points of a

    24 ** doubly-linked list of all compiled SQL statements that may be holding

    25 ** buffers eligible for release when the sqlite3_release_memory() interface is

    26 ** invoked. Access to this list is protected by the SQLITE_MUTEX_STATIC_LRU2

    27 ** mutex.

    28 **

    29 ** Statements are added to the end of this list when sqlite3_reset() is

    30 ** called. They are removed either when sqlite3_step() or sqlite3_finalize()

    31 ** is called. When statements are added to this list, the associated 

    32 ** register array (p->aMem[1..p->nMem]) may contain dynamic buffers that

    33 ** can be freed using sqlite3VdbeReleaseMemory().

    34 **

    35 ** When statements are added or removed from this list, the mutex

    36 ** associated with the Vdbe being added or removed (Vdbe.db->mutex) is

    37 ** already held. The LRU2 mutex is then obtained, blocking if necessary,

    38 ** the linked-list pointers manipulated and the LRU2 mutex relinquished.

    39 */

    40 struct StatementLruList {

    41   Vdbe *pFirst;

    42   Vdbe *pLast;

    43 };

    44 static struct StatementLruList sqlite3LruStatements;

    45 

    46 /*

    47 ** Check that the list looks to be internally consistent. This is used

    48 ** as part of an assert() statement as follows:

    49 **

    50 **   assert( stmtLruCheck() );

    51 */

    52 #ifndef NDEBUG

    53 static int stmtLruCheck(){

    54   Vdbe *p;

    55   for(p=sqlite3LruStatements.pFirst; p; p=p->pLruNext){

    56     assert(p->pLruNext || p==sqlite3LruStatements.pLast);

    57     assert(!p->pLruNext || p->pLruNext->pLruPrev==p);

    58     assert(p->pLruPrev || p==sqlite3LruStatements.pFirst);

    59     assert(!p->pLruPrev || p->pLruPrev->pLruNext==p);

    60   }

    61   return 1;

    62 }

    63 #endif

    64 

    65 /*

    66 ** Add vdbe p to the end of the statement lru list. It is assumed that

    67 ** p is not already part of the list when this is called. The lru list

    68 ** is protected by the SQLITE_MUTEX_STATIC_LRU mutex.

    69 */

    70 static void stmtLruAdd(Vdbe *p){

    71   sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));

    72 

    73   if( p->pLruPrev || p->pLruNext || sqlite3LruStatements.pFirst==p ){

    74     sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));

    75     return;

    76   }

    77 

    78   assert( stmtLruCheck() );

    79 

    80   if( !sqlite3LruStatements.pFirst ){

    81     assert( !sqlite3LruStatements.pLast );

    82     sqlite3LruStatements.pFirst = p;

    83     sqlite3LruStatements.pLast = p;

    84   }else{

    85     assert( !sqlite3LruStatements.pLast->pLruNext );

    86     p->pLruPrev = sqlite3LruStatements.pLast;

    87     sqlite3LruStatements.pLast->pLruNext = p;

    88     sqlite3LruStatements.pLast = p;

    89   }

    90 

    91   assert( stmtLruCheck() );

    92 

    93   sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));

    94 }

    95 

    96 /*

    97 ** Assuming the SQLITE_MUTEX_STATIC_LRU2 mutext is already held, remove

    98 ** statement p from the least-recently-used statement list. If the 

    99 ** statement is not currently part of the list, this call is a no-op.

   100 */

   101 static void stmtLruRemoveNomutex(Vdbe *p){

   102   if( p->pLruPrev || p->pLruNext || p==sqlite3LruStatements.pFirst ){

   103     assert( stmtLruCheck() );

   104     if( p->pLruNext ){

   105       p->pLruNext->pLruPrev = p->pLruPrev;

   106     }else{

   107       sqlite3LruStatements.pLast = p->pLruPrev;

   108     }

   109     if( p->pLruPrev ){

   110       p->pLruPrev->pLruNext = p->pLruNext;

   111     }else{

   112       sqlite3LruStatements.pFirst = p->pLruNext;

   113     }

   114     p->pLruNext = 0;

   115     p->pLruPrev = 0;

   116     assert( stmtLruCheck() );

   117   }

   118 }

   119 

   120 /*

   121 ** Assuming the SQLITE_MUTEX_STATIC_LRU2 mutext is not held, remove

   122 ** statement p from the least-recently-used statement list. If the 

   123 ** statement is not currently part of the list, this call is a no-op.

   124 */

   125 static void stmtLruRemove(Vdbe *p){

   126   sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));

   127   stmtLruRemoveNomutex(p);

   128   sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));

   129 }

   130 

   131 /*

   132 ** Try to release n bytes of memory by freeing buffers associated 

   133 ** with the memory registers of currently unused vdbes.

   134 */

   135 int sqlite3VdbeReleaseMemory(int n){

   136   Vdbe *p;

   137   Vdbe *pNext;

   138   int nFree = 0;

   139 

   140   sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));

   141   for(p=sqlite3LruStatements.pFirst; p && nFree<n; p=pNext){

   142     pNext = p->pLruNext;

   143 

   144     /* For each statement handle in the lru list, attempt to obtain the

   145     ** associated database mutex. If it cannot be obtained, continue

   146     ** to the next statement handle. It is not possible to block on

   147     ** the database mutex - that could cause deadlock.

   148     */

   149     if( SQLITE_OK==sqlite3_mutex_try(p->db->mutex) ){

   150       nFree += sqlite3VdbeReleaseBuffers(p);

   151       stmtLruRemoveNomutex(p);

   152       sqlite3_mutex_leave(p->db->mutex);

   153     }

   154   }

   155   sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));

   156 

   157   return nFree;

   158 }

   159 

   160 /*

   161 ** Call sqlite3Reprepare() on the statement. Remove it from the

   162 ** lru list before doing so, as Reprepare() will free all the

   163 ** memory register buffers anyway.

   164 */

   165 int vdbeReprepare(Vdbe *p){

   166   stmtLruRemove(p);

   167   return sqlite3Reprepare(p);

   168 }

   169 

   170 #else       /* !SQLITE_ENABLE_MEMORY_MANAGEMENT */

   171   #define stmtLruRemove(x)

   172   #define stmtLruAdd(x)

   173   #define vdbeReprepare(x) sqlite3Reprepare(x)

   174 #endif

   175 

   176 

   177 #ifndef SQLITE_OMIT_DEPRECATED

   178 /*

   179 ** Return TRUE (non-zero) of the statement supplied as an argument needs

   180 ** to be recompiled.  A statement needs to be recompiled whenever the

   181 ** execution environment changes in a way that would alter the program

   182 ** that sqlite3_prepare() generates.  For example, if new functions or

   183 ** collating sequences are registered or if an authorizer function is

   184 ** added or changed.

   185 */

   186 int sqlite3_expired(sqlite3_stmt *pStmt){

   187   Vdbe *p = (Vdbe*)pStmt;

   188   return p==0 || p->expired;

   189 }

   190 #endif

   191 

   192 /*

   193 ** The following routine destroys a virtual machine that is created by

   194 ** the sqlite3_compile() routine. The integer returned is an SQLITE_

   195 ** success/failure code that describes the result of executing the virtual

   196 ** machine.

   197 **

   198 ** This routine sets the error code and string returned by

   199 ** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().

   200 */

   201 int sqlite3_finalize(sqlite3_stmt *pStmt){

   202   int rc;

   203   if( pStmt==0 ){

   204     rc = SQLITE_OK;

   205   }else{

   206     Vdbe *v = (Vdbe*)pStmt;

   207 #if SQLITE_THREADSAFE

   208     sqlite3_mutex *mutex = v->db->mutex;

   209 #endif

   210     sqlite3_mutex_enter(mutex);

   211     stmtLruRemove(v);

   212     rc = sqlite3VdbeFinalize(v);

   213     sqlite3_mutex_leave(mutex);

   214   }

   215   return rc;

   216 }

   217 

   218 /*

   219 ** Terminate the current execution of an SQL statement and reset it

   220 ** back to its starting state so that it can be reused. A success code from

   221 ** the prior execution is returned.

   222 **

   223 ** This routine sets the error code and string returned by

   224 ** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().

   225 */

   226 int sqlite3_reset(sqlite3_stmt *pStmt){

   227   int rc;

   228   if( pStmt==0 ){

   229     rc = SQLITE_OK;

   230   }else{

   231     Vdbe *v = (Vdbe*)pStmt;

   232     sqlite3_mutex_enter(v->db->mutex);

   233     rc = sqlite3VdbeReset(v);

   234     stmtLruAdd(v);

   235     sqlite3VdbeMakeReady(v, -1, 0, 0, 0);

   236     assert( (rc & (v->db->errMask))==rc );

   237     sqlite3_mutex_leave(v->db->mutex);

   238   }

   239   return rc;

   240 }

   241 

   242 /*

   243 ** Set all the parameters in the compiled SQL statement to NULL.

   244 */

   245 int sqlite3_clear_bindings(sqlite3_stmt *pStmt){

   246   int i;

   247   int rc = SQLITE_OK;

   248   Vdbe *p = (Vdbe*)pStmt;

   249 #if SQLITE_THREADSAFE

   250   sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex;

   251 #endif

   252   sqlite3_mutex_enter(mutex);

   253   for(i=0; i<p->nVar; i++){

   254     sqlite3VdbeMemRelease(&p->aVar[i]);

   255     p->aVar[i].flags = MEM_Null;

   256   }

   257   sqlite3_mutex_leave(mutex);

   258   return rc;

   259 }

   260 

   261 

   262 /**************************** sqlite3_value_  *******************************

   263 ** The following routines extract information from a Mem or sqlite3_value

   264 ** structure.

   265 */

   266 const void *sqlite3_value_blob(sqlite3_value *pVal){

   267   Mem *p = (Mem*)pVal;

   268   if( p->flags & (MEM_Blob|MEM_Str) ){

   269     sqlite3VdbeMemExpandBlob(p);

   270     p->flags &= ~MEM_Str;

   271     p->flags |= MEM_Blob;

   272     return p->z;

   273   }else{

   274     return sqlite3_value_text(pVal);

   275   }

   276 }

   277 int sqlite3_value_bytes(sqlite3_value *pVal){

   278   return sqlite3ValueBytes(pVal, SQLITE_UTF8);

   279 }

   280 int sqlite3_value_bytes16(sqlite3_value *pVal){

   281   return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);

   282 }

   283 double sqlite3_value_double(sqlite3_value *pVal){

   284   return sqlite3VdbeRealValue((Mem*)pVal);

   285 }

   286 int sqlite3_value_int(sqlite3_value *pVal){

   287   return sqlite3VdbeIntValue((Mem*)pVal);

   288 }

   289 sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){

   290   return sqlite3VdbeIntValue((Mem*)pVal);

   291 }

   292 const unsigned char *sqlite3_value_text(sqlite3_value *pVal){

   293   return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8);

   294 }

   295 #ifndef SQLITE_OMIT_UTF16

   296 const void *sqlite3_value_text16(sqlite3_value* pVal){

   297   return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);

   298 }

   299 const void *sqlite3_value_text16be(sqlite3_value *pVal){

   300   return sqlite3ValueText(pVal, SQLITE_UTF16BE);

   301 }

   302 const void *sqlite3_value_text16le(sqlite3_value *pVal){

   303   return sqlite3ValueText(pVal, SQLITE_UTF16LE);

   304 }

   305 #endif /* SQLITE_OMIT_UTF16 */

   306 int sqlite3_value_type(sqlite3_value* pVal){

   307   return pVal->type;

   308 }

   309 

   310 /**************************** sqlite3_result_  *******************************

   311 ** The following routines are used by user-defined functions to specify

   312 ** the function result.

   313 */

   314 void sqlite3_result_blob(

   315   sqlite3_context *pCtx, 

   316   const void *z, 

   317   int n, 

   318   void (*xDel)(void *)

   319 ){

   320   assert( n>=0 );

   321   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   322   sqlite3VdbeMemSetStr(&pCtx->s, z, n, 0, xDel);

   323 }

   324 void sqlite3_result_double(sqlite3_context *pCtx, double rVal){

   325   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   326   sqlite3VdbeMemSetDouble(&pCtx->s, rVal);

   327 }

   328 void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){

   329   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   330   pCtx->isError = SQLITE_ERROR;

   331   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);

   332 }

   333 #ifndef SQLITE_OMIT_UTF16

   334 void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){

   335   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   336   pCtx->isError = SQLITE_ERROR;

   337   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);

   338 }

   339 #endif

   340 void sqlite3_result_int(sqlite3_context *pCtx, int iVal){

   341   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   342   sqlite3VdbeMemSetInt64(&pCtx->s, (i64)iVal);

   343 }

   344 void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){

   345   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   346   sqlite3VdbeMemSetInt64(&pCtx->s, iVal);

   347 }

   348 void sqlite3_result_null(sqlite3_context *pCtx){

   349   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   350   sqlite3VdbeMemSetNull(&pCtx->s);

   351 }

   352 void sqlite3_result_text(

   353   sqlite3_context *pCtx, 

   354   const char *z, 

   355   int n,

   356   void (*xDel)(void *)

   357 ){

   358   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   359   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, xDel);

   360 }

   361 #ifndef SQLITE_OMIT_UTF16

   362 void sqlite3_result_text16(

   363   sqlite3_context *pCtx, 

   364   const void *z, 

   365   int n, 

   366   void (*xDel)(void *)

   367 ){

   368   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   369   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, xDel);

   370 }

   371 void sqlite3_result_text16be(

   372   sqlite3_context *pCtx, 

   373   const void *z, 

   374   int n, 

   375   void (*xDel)(void *)

   376 ){

   377   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   378   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16BE, xDel);

   379 }

   380 void sqlite3_result_text16le(

   381   sqlite3_context *pCtx, 

   382   const void *z, 

   383   int n, 

   384   void (*xDel)(void *)

   385 ){

   386   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   387   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16LE, xDel);

   388 }

   389 #endif /* SQLITE_OMIT_UTF16 */

   390 void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){

   391   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   392   sqlite3VdbeMemCopy(&pCtx->s, pValue);

   393 }

   394 void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){

   395   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   396   sqlite3VdbeMemSetZeroBlob(&pCtx->s, n);

   397 }

   398 void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){

   399   pCtx->isError = errCode;

   400 }

   401 

   402 /* Force an SQLITE_TOOBIG error. */

   403 void sqlite3_result_error_toobig(sqlite3_context *pCtx){

   404   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   405   pCtx->isError = SQLITE_TOOBIG;

   406   sqlite3VdbeMemSetStr(&pCtx->s, "string or blob too big", -1, 

   407                        SQLITE_UTF8, SQLITE_STATIC);

   408 }

   409 

   410 /* An SQLITE_NOMEM error. */

   411 void sqlite3_result_error_nomem(sqlite3_context *pCtx){

   412   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   413   sqlite3VdbeMemSetNull(&pCtx->s);

   414   pCtx->isError = SQLITE_NOMEM;

   415   pCtx->s.db->mallocFailed = 1;

   416 }

   417 

   418 /*

   419 ** Execute the statement pStmt, either until a row of data is ready, the

   420 ** statement is completely executed or an error occurs.

   421 **

   422 ** This routine implements the bulk of the logic behind the sqlite_step()

   423 ** API.  The only thing omitted is the automatic recompile if a 

   424 ** schema change has occurred.  That detail is handled by the

   425 ** outer sqlite3_step() wrapper procedure.

   426 */

   427 static int sqlite3Step(Vdbe *p){

   428   sqlite3 *db;

   429   int rc;

   430 

   431   assert(p);

   432   if( p->magic!=VDBE_MAGIC_RUN ){

   433     return SQLITE_MISUSE;

   434   }

   435 

   436   /* Assert that malloc() has not failed */

   437   db = p->db;

   438   if( db->mallocFailed ){

   439     return SQLITE_NOMEM;

   440   }

   441 

   442   if( p->pc<=0 && p->expired ){

   443     if( p->rc==SQLITE_OK ){

   444       p->rc = SQLITE_SCHEMA;

   445     }

   446     rc = SQLITE_ERROR;

   447     goto end_of_step;

   448   }

   449   if( sqlite3SafetyOn(db) ){

   450     p->rc = SQLITE_MISUSE;

   451     return SQLITE_MISUSE;

   452   }

   453   if( p->pc<0 ){

   454     /* If there are no other statements currently running, then

   455     ** reset the interrupt flag.  This prevents a call to sqlite3_interrupt

   456     ** from interrupting a statement that has not yet started.

   457     */

   458     if( db->activeVdbeCnt==0 ){

   459       db->u1.isInterrupted = 0;

   460     }

   461 

   462 #ifndef SQLITE_OMIT_TRACE

   463     if( db->xProfile && !db->init.busy ){

   464       double rNow;

   465       sqlite3OsCurrentTime(db->pVfs, &rNow);

   466       p->startTime = (rNow - (int)rNow)*3600.0*24.0*1000000000.0;

   467     }

   468 #endif

   469 

   470     db->activeVdbeCnt++;

   471     p->pc = 0;

   472     stmtLruRemove(p);

   473   }

   474 #ifndef SQLITE_OMIT_EXPLAIN

   475   if( p->explain ){

   476     rc = sqlite3VdbeList(p);

   477   }else

   478 #endif /* SQLITE_OMIT_EXPLAIN */

   479   {

   480     rc = sqlite3VdbeExec(p);

   481   }

   482 

   483   if( sqlite3SafetyOff(db) ){

   484     rc = SQLITE_MISUSE;

   485   }

   486 

   487 #ifndef SQLITE_OMIT_TRACE

   488   /* Invoke the profile callback if there is one

   489   */

   490   if( rc!=SQLITE_ROW && db->xProfile && !db->init.busy && p->nOp>0

   491            && p->aOp[0].opcode==OP_Trace && p->aOp[0].p4.z!=0 ){

   492     double rNow;

   493     u64 elapseTime;

   494 

   495     sqlite3OsCurrentTime(db->pVfs, &rNow);

   496     elapseTime = (rNow - (int)rNow)*3600.0*24.0*1000000000.0 - p->startTime;

   497     db->xProfile(db->pProfileArg, p->aOp[0].p4.z, elapseTime);

   498   }

   499 #endif

   500 

   501   db->errCode = rc;

   502   /*sqlite3Error(p->db, rc, 0);*/

   503   p->rc = sqlite3ApiExit(p->db, p->rc);

   504 end_of_step:

   505   assert( (rc&0xff)==rc );

   506   if( p->zSql && (rc&0xff)<SQLITE_ROW ){

   507     /* This behavior occurs if sqlite3_prepare_v2() was used to build

   508     ** the prepared statement.  Return error codes directly */

   509     p->db->errCode = p->rc;

   510     /* sqlite3Error(p->db, p->rc, 0); */

   511     return p->rc;

   512   }else{

   513     /* This is for legacy sqlite3_prepare() builds and when the code

   514     ** is SQLITE_ROW or SQLITE_DONE */

   515     return rc;

   516   }

   517 }

   518 

   519 /*

   520 ** This is the top-level implementation of sqlite3_step().  Call

   521 ** sqlite3Step() to do most of the work.  If a schema error occurs,

   522 ** call sqlite3Reprepare() and try again.

   523 */

   524 #ifdef SQLITE_OMIT_PARSER

   525 int sqlite3_step(sqlite3_stmt *pStmt){

   526   int rc = SQLITE_MISUSE;

   527   if( pStmt ){

   528     Vdbe *v;

   529     v = (Vdbe*)pStmt;

   530     sqlite3_mutex_enter(v->db->mutex);

   531     rc = sqlite3Step(v);

   532     sqlite3_mutex_leave(v->db->mutex);

   533   }

   534   return rc;

   535 }

   536 #else

   537 int sqlite3_step(sqlite3_stmt *pStmt){

   538   int rc = SQLITE_MISUSE;

   539   if( pStmt ){

   540     int cnt = 0;

   541     Vdbe *v = (Vdbe*)pStmt;

   542     sqlite3 *db = v->db;

   543     sqlite3_mutex_enter(db->mutex);

   544     while( (rc = sqlite3Step(v))==SQLITE_SCHEMA

   545            && cnt++ < 5

   546            && vdbeReprepare(v) ){

   547       sqlite3_reset(pStmt);

   548       v->expired = 0;

   549     }

   550     if( rc==SQLITE_SCHEMA && v->zSql && db->pErr ){

   551       /* This case occurs after failing to recompile an sql statement. 

   552       ** The error message from the SQL compiler has already been loaded 

   553       ** into the database handle. This block copies the error message 

   554       ** from the database handle into the statement and sets the statement

   555       ** program counter to 0 to ensure that when the statement is 

   556       ** finalized or reset the parser error message is available via

   557       ** sqlite3_errmsg() and sqlite3_errcode().

   558       */

   559       const char *zErr = (const char *)sqlite3_value_text(db->pErr); 

   560       sqlite3DbFree(db, v->zErrMsg);

   561       if( !db->mallocFailed ){

   562         v->zErrMsg = sqlite3DbStrDup(db, zErr);

   563       } else {

   564         v->zErrMsg = 0;

   565         v->rc = SQLITE_NOMEM;

   566       }

   567     }

   568     rc = sqlite3ApiExit(db, rc);

   569     sqlite3_mutex_leave(db->mutex);

   570   }

   571   return rc;

   572 }

   573 #endif

   574 

   575 /*

   576 ** Extract the user data from a sqlite3_context structure and return a

   577 ** pointer to it.

   578 */

   579 void *sqlite3_user_data(sqlite3_context *p){

   580   assert( p && p->pFunc );

   581   return p->pFunc->pUserData;

   582 }

   583 

   584 /*

   585 ** Extract the user data from a sqlite3_context structure and return a

   586 ** pointer to it.

   587 */

   588 sqlite3 *sqlite3_context_db_handle(sqlite3_context *p){

   589   assert( p && p->pFunc );

   590   return p->s.db;

   591 }

   592 

   593 /*

   594 ** The following is the implementation of an SQL function that always

   595 ** fails with an error message stating that the function is used in the

   596 ** wrong context.  The sqlite3_overload_function() API might construct

   597 ** SQL function that use this routine so that the functions will exist

   598 ** for name resolution but are actually overloaded by the xFindFunction

   599 ** method of virtual tables.

   600 */

   601 void sqlite3InvalidFunction(

   602   sqlite3_context *context,  /* The function calling context */

   603   int argc,                  /* Number of arguments to the function */

   604   sqlite3_value **argv       /* Value of each argument */

   605 ){

   606   const char *zName = context->pFunc->zName;

   607   char *zErr;

   608   zErr = sqlite3MPrintf(0,

   609       "unable to use function %s in the requested context", zName);

   610   sqlite3_result_error(context, zErr, -1);

   611   sqlite3_free(zErr);

   612 }

   613 

   614 /*

   615 ** Allocate or return the aggregate context for a user function.  A new

   616 ** context is allocated on the first call.  Subsequent calls return the

   617 ** same context that was returned on prior calls.

   618 */

   619 void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){

   620   Mem *pMem;

   621   assert( p && p->pFunc && p->pFunc->xStep );

   622   assert( sqlite3_mutex_held(p->s.db->mutex) );

   623   pMem = p->pMem;

   624   if( (pMem->flags & MEM_Agg)==0 ){

   625     if( nByte==0 ){

   626       sqlite3VdbeMemReleaseExternal(pMem);

   627       pMem->flags = MEM_Null;

   628       pMem->z = 0;

   629     }else{

   630       sqlite3VdbeMemGrow(pMem, nByte, 0);

   631       pMem->flags = MEM_Agg;

   632       pMem->u.pDef = p->pFunc;

   633       if( pMem->z ){

   634         memset(pMem->z, 0, nByte);

   635       }

   636     }

   637   }

   638   return (void*)pMem->z;

   639 }

   640 

   641 /*

   642 ** Return the auxilary data pointer, if any, for the iArg'th argument to

   643 ** the user-function defined by pCtx.

   644 */

   645 void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){

   646   VdbeFunc *pVdbeFunc;

   647 

   648   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   649   pVdbeFunc = pCtx->pVdbeFunc;

   650   if( !pVdbeFunc || iArg>=pVdbeFunc->nAux || iArg<0 ){

   651     return 0;

   652   }

   653   return pVdbeFunc->apAux[iArg].pAux;

   654 }

   655 

   656 /*

   657 ** Set the auxilary data pointer and delete function, for the iArg'th

   658 ** argument to the user-function defined by pCtx. Any previous value is

   659 ** deleted by calling the delete function specified when it was set.

   660 */

   661 void sqlite3_set_auxdata(

   662   sqlite3_context *pCtx, 

   663   int iArg, 

   664   void *pAux, 

   665   void (*xDelete)(void*)

   666 ){

   667   struct AuxData *pAuxData;

   668   VdbeFunc *pVdbeFunc;

   669   if( iArg<0 ) goto failed;

   670 

   671   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   672   pVdbeFunc = pCtx->pVdbeFunc;

   673   if( !pVdbeFunc || pVdbeFunc->nAux<=iArg ){

   674     int nAux = (pVdbeFunc ? pVdbeFunc->nAux : 0);

   675     int nMalloc = sizeof(VdbeFunc) + sizeof(struct AuxData)*iArg;

   676     pVdbeFunc = sqlite3DbRealloc(pCtx->s.db, pVdbeFunc, nMalloc);

   677     if( !pVdbeFunc ){

   678       goto failed;

   679     }

   680     pCtx->pVdbeFunc = pVdbeFunc;

   681     memset(&pVdbeFunc->apAux[nAux], 0, sizeof(struct AuxData)*(iArg+1-nAux));

   682     pVdbeFunc->nAux = iArg+1;

   683     pVdbeFunc->pFunc = pCtx->pFunc;

   684   }

   685 

   686   pAuxData = &pVdbeFunc->apAux[iArg];

   687   if( pAuxData->pAux && pAuxData->xDelete ){

   688     pAuxData->xDelete(pAuxData->pAux);

   689   }

   690   pAuxData->pAux = pAux;

   691   pAuxData->xDelete = xDelete;

   692   return;

   693 

   694 failed:

   695   if( xDelete ){

   696     xDelete(pAux);

   697   }

   698 }

   699 

   700 #ifndef SQLITE_OMIT_DEPRECATED

   701 /*

   702 ** Return the number of times the Step function of a aggregate has been 

   703 ** called.

   704 **

   705 ** This function is deprecated.  Do not use it for new code.  It is

   706 ** provide only to avoid breaking legacy code.  New aggregate function

   707 ** implementations should keep their own counts within their aggregate

   708 ** context.

   709 */

   710 int sqlite3_aggregate_count(sqlite3_context *p){

   711   assert( p && p->pFunc && p->pFunc->xStep );

   712   return p->pMem->n;

   713 }

   714 #endif

   715 

   716 /*

   717 ** Return the number of columns in the result set for the statement pStmt.

   718 */

   719 int sqlite3_column_count(sqlite3_stmt *pStmt){

   720   Vdbe *pVm = (Vdbe *)pStmt;

   721   return pVm ? pVm->nResColumn : 0;

   722 }

   723 

   724 /*

   725 ** Return the number of values available from the current row of the

   726 ** currently executing statement pStmt.

   727 */

   728 int sqlite3_data_count(sqlite3_stmt *pStmt){

   729   Vdbe *pVm = (Vdbe *)pStmt;

   730   if( pVm==0 || pVm->pResultSet==0 ) return 0;

   731   return pVm->nResColumn;

   732 }

   733 

   734 

   735 /*

   736 ** Check to see if column iCol of the given statement is valid.  If

   737 ** it is, return a pointer to the Mem for the value of that column.

   738 ** If iCol is not valid, return a pointer to a Mem which has a value

   739 ** of NULL.

   740 */

   741 static Mem *columnMem(sqlite3_stmt *pStmt, int i){

   742   Vdbe *pVm;

   743   int vals;

   744   Mem *pOut;

   745 

   746   pVm = (Vdbe *)pStmt;

   747   if( pVm && pVm->pResultSet!=0 && i<pVm->nResColumn && i>=0 ){

   748     sqlite3_mutex_enter(pVm->db->mutex);

   749     vals = sqlite3_data_count(pStmt);

   750     pOut = &pVm->pResultSet[i];

   751   }else{

   752     static const Mem nullMem = {{0}, 0.0, 0, "", 0, MEM_Null, SQLITE_NULL, 0, 0, 0 };

   753     if( pVm->db ){

   754       sqlite3_mutex_enter(pVm->db->mutex);

   755       sqlite3Error(pVm->db, SQLITE_RANGE, 0);

   756     }

   757     pOut = (Mem*)&nullMem;

   758   }

   759   return pOut;

   760 }

   761 

   762 /*

   763 ** This function is called after invoking an sqlite3_value_XXX function on a 

   764 ** column value (i.e. a value returned by evaluating an SQL expression in the

   765 ** select list of a SELECT statement) that may cause a malloc() failure. If 

   766 ** malloc() has failed, the threads mallocFailed flag is cleared and the result

   767 ** code of statement pStmt set to SQLITE_NOMEM.

   768 **

   769 ** Specifically, this is called from within:

   770 **

   771 **     sqlite3_column_int()

   772 **     sqlite3_column_int64()

   773 **     sqlite3_column_text()

   774 **     sqlite3_column_text16()

   775 **     sqlite3_column_real()

   776 **     sqlite3_column_bytes()

   777 **     sqlite3_column_bytes16()

   778 **

   779 ** But not for sqlite3_column_blob(), which never calls malloc().

   780 */

   781 static void columnMallocFailure(sqlite3_stmt *pStmt)

   782 {

   783   /* If malloc() failed during an encoding conversion within an

   784   ** sqlite3_column_XXX API, then set the return code of the statement to

   785   ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR

   786   ** and _finalize() will return NOMEM.

   787   */

   788   Vdbe *p = (Vdbe *)pStmt;

   789   if( p ){

   790     p->rc = sqlite3ApiExit(p->db, p->rc);

   791     sqlite3_mutex_leave(p->db->mutex);

   792   }

   793 }

   794 

   795 /**************************** sqlite3_column_  *******************************

   796 ** The following routines are used to access elements of the current row

   797 ** in the result set.

   798 */

   799 const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){

   800   const void *val;

   801   val = sqlite3_value_blob( columnMem(pStmt,i) );

   802   /* Even though there is no encoding conversion, value_blob() might

   803   ** need to call malloc() to expand the result of a zeroblob() 

   804   ** expression. 

   805   */

   806   columnMallocFailure(pStmt);

   807   return val;

   808 }

   809 int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){

   810   int val = sqlite3_value_bytes( columnMem(pStmt,i) );

   811   columnMallocFailure(pStmt);

   812   return val;

   813 }

   814 int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){

   815   int val = sqlite3_value_bytes16( columnMem(pStmt,i) );

   816   columnMallocFailure(pStmt);

   817   return val;

   818 }

   819 double sqlite3_column_double(sqlite3_stmt *pStmt, int i){

   820   double val = sqlite3_value_double( columnMem(pStmt,i) );

   821   columnMallocFailure(pStmt);

   822   return val;

   823 }

   824 int sqlite3_column_int(sqlite3_stmt *pStmt, int i){

   825   int val = sqlite3_value_int( columnMem(pStmt,i) );

   826   columnMallocFailure(pStmt);

   827   return val;

   828 }

   829 sqlite_int64 sqlite3_column_int64(sqlite3_stmt *pStmt, int i){

   830   sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) );

   831   columnMallocFailure(pStmt);

   832   return val;

   833 }

   834 const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int i){

   835   const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) );

   836   columnMallocFailure(pStmt);

   837   return val;

   838 }

   839 sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){

   840   Mem *pOut = columnMem(pStmt, i);

   841   if( pOut->flags&MEM_Static ){

   842     pOut->flags &= ~MEM_Static;

   843     pOut->flags |= MEM_Ephem;

   844   }

   845   columnMallocFailure(pStmt);

   846   return (sqlite3_value *)pOut;

   847 }

   848 #ifndef SQLITE_OMIT_UTF16

   849 const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){

   850   const void *val = sqlite3_value_text16( columnMem(pStmt,i) );

   851   columnMallocFailure(pStmt);

   852   return val;

   853 }

   854 #endif /* SQLITE_OMIT_UTF16 */

   855 int sqlite3_column_type(sqlite3_stmt *pStmt, int i){

   856   int iType = sqlite3_value_type( columnMem(pStmt,i) );

   857   columnMallocFailure(pStmt);

   858   return iType;

   859 }

   860 

   861 /* The following function is experimental and subject to change or

   862 ** removal */

   863 /*int sqlite3_column_numeric_type(sqlite3_stmt *pStmt, int i){

   864 **  return sqlite3_value_numeric_type( columnMem(pStmt,i) );

   865 **}

   866 */

   867 

   868 /*

   869 ** Convert the N-th element of pStmt->pColName[] into a string using

   870 ** xFunc() then return that string.  If N is out of range, return 0.

   871 **

   872 ** There are up to 5 names for each column.  useType determines which

   873 ** name is returned.  Here are the names:

   874 **

   875 **    0      The column name as it should be displayed for output

   876 **    1      The datatype name for the column

   877 **    2      The name of the database that the column derives from

   878 **    3      The name of the table that the column derives from

   879 **    4      The name of the table column that the result column derives from

   880 **

   881 ** If the result is not a simple column reference (if it is an expression

   882 ** or a constant) then useTypes 2, 3, and 4 return NULL.

   883 */

   884 static const void *columnName(

   885   sqlite3_stmt *pStmt,

   886   int N,

   887   const void *(*xFunc)(Mem*),

   888   int useType

   889 ){

   890   const void *ret = 0;

   891   Vdbe *p = (Vdbe *)pStmt;

   892   int n;

   893   

   894 

   895   if( p!=0 ){

   896     n = sqlite3_column_count(pStmt);

   897     if( N<n && N>=0 ){

   898       N += useType*n;

   899       sqlite3_mutex_enter(p->db->mutex);

   900       ret = xFunc(&p->aColName[N]);

   901 

   902       /* A malloc may have failed inside of the xFunc() call. If this

   903       ** is the case, clear the mallocFailed flag and return NULL.

   904       */

   905       if( p->db && p->db->mallocFailed ){

   906         p->db->mallocFailed = 0;

   907         ret = 0;

   908       }

   909       sqlite3_mutex_leave(p->db->mutex);

   910     }

   911   }

   912   return ret;

   913 }

   914 

   915 /*

   916 ** Return the name of the Nth column of the result set returned by SQL

   917 ** statement pStmt.

   918 */

   919 const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){

   920   return columnName(

   921       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_NAME);

   922 }

   923 #ifndef SQLITE_OMIT_UTF16

   924 const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){

   925   return columnName(

   926       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_NAME);

   927 }

   928 #endif

   929 

   930 /*

   931 ** Constraint:  If you have ENABLE_COLUMN_METADATA then you must

   932 ** not define OMIT_DECLTYPE.

   933 */

   934 #if defined(SQLITE_OMIT_DECLTYPE) && defined(SQLITE_ENABLE_COLUMN_METADATA)

   935 # error "Must not define both SQLITE_OMIT_DECLTYPE \

   936          and SQLITE_ENABLE_COLUMN_METADATA"

   937 #endif

   938 

   939 #ifndef SQLITE_OMIT_DECLTYPE

   940 /*

   941 ** Return the column declaration type (if applicable) of the 'i'th column

   942 ** of the result set of SQL statement pStmt.

   943 */

   944 const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){

   945   return columnName(

   946       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DECLTYPE);

   947 }

   948 #ifndef SQLITE_OMIT_UTF16

   949 const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){

   950   return columnName(

   951       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DECLTYPE);

   952 }

   953 #endif /* SQLITE_OMIT_UTF16 */

   954 #endif /* SQLITE_OMIT_DECLTYPE */

   955 

   956 #ifdef SQLITE_ENABLE_COLUMN_METADATA

   957 /*

   958 ** Return the name of the database from which a result column derives.

   959 ** NULL is returned if the result column is an expression or constant or

   960 ** anything else which is not an unabiguous reference to a database column.

   961 */

   962 const char *sqlite3_column_database_name(sqlite3_stmt *pStmt, int N){

   963   return columnName(

   964       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DATABASE);

   965 }

   966 #ifndef SQLITE_OMIT_UTF16

   967 const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){

   968   return columnName(

   969       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DATABASE);

   970 }

   971 #endif /* SQLITE_OMIT_UTF16 */

   972 

   973 /*

   974 ** Return the name of the table from which a result column derives.

   975 ** NULL is returned if the result column is an expression or constant or

   976 ** anything else which is not an unabiguous reference to a database column.

   977 */

   978 const char *sqlite3_column_table_name(sqlite3_stmt *pStmt, int N){

   979   return columnName(

   980       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_TABLE);

   981 }

   982 #ifndef SQLITE_OMIT_UTF16

   983 const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){

   984   return columnName(

   985       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_TABLE);

   986 }

   987 #endif /* SQLITE_OMIT_UTF16 */

   988 

   989 /*

   990 ** Return the name of the table column from which a result column derives.

   991 ** NULL is returned if the result column is an expression or constant or

   992 ** anything else which is not an unabiguous reference to a database column.

   993 */

   994 const char *sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N){

   995   return columnName(

   996       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_COLUMN);

   997 }

   998 #ifndef SQLITE_OMIT_UTF16

   999 const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){

  1000   return columnName(

  1001       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_COLUMN);

  1002 }

  1003 #endif /* SQLITE_OMIT_UTF16 */

  1004 #endif /* SQLITE_ENABLE_COLUMN_METADATA */

  1005 

  1006 

  1007 /******************************* sqlite3_bind_  ***************************

  1008 ** 

  1009 ** Routines used to attach values to wildcards in a compiled SQL statement.

  1010 */

  1011 /*

  1012 ** Unbind the value bound to variable i in virtual machine p. This is the 

  1013 ** the same as binding a NULL value to the column. If the "i" parameter is

  1014 ** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK.

  1015 **

  1016 ** A successful evaluation of this routine acquires the mutex on p.

  1017 ** the mutex is released if any kind of error occurs.

  1018 **

  1019 ** The error code stored in database p->db is overwritten with the return

  1020 ** value in any case.

  1021 */

  1022 static int vdbeUnbind(Vdbe *p, int i){

  1023   Mem *pVar;

  1024   if( p==0 ) return SQLITE_MISUSE;

  1025   sqlite3_mutex_enter(p->db->mutex);

  1026   if( p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){

  1027     sqlite3Error(p->db, SQLITE_MISUSE, 0);

  1028     sqlite3_mutex_leave(p->db->mutex);

  1029     return SQLITE_MISUSE;

  1030   }

  1031   if( i<1 || i>p->nVar ){

  1032     sqlite3Error(p->db, SQLITE_RANGE, 0);

  1033     sqlite3_mutex_leave(p->db->mutex);

  1034     return SQLITE_RANGE;

  1035   }

  1036   i--;

  1037   pVar = &p->aVar[i];

  1038   sqlite3VdbeMemRelease(pVar);

  1039   pVar->flags = MEM_Null;

  1040   sqlite3Error(p->db, SQLITE_OK, 0);

  1041   return SQLITE_OK;

  1042 }

  1043 

  1044 /*

  1045 ** Bind a text or BLOB value.

  1046 */

  1047 static int bindText(

  1048   sqlite3_stmt *pStmt,   /* The statement to bind against */

  1049   int i,                 /* Index of the parameter to bind */

  1050   const void *zData,     /* Pointer to the data to be bound */

  1051   int nData,             /* Number of bytes of data to be bound */

  1052   void (*xDel)(void*),   /* Destructor for the data */

  1053   int encoding           /* Encoding for the data */

  1054 ){

  1055   Vdbe *p = (Vdbe *)pStmt;

  1056   Mem *pVar;

  1057   int rc;

  1058 

  1059   rc = vdbeUnbind(p, i);

  1060   if( rc==SQLITE_OK ){

  1061     if( zData!=0 ){

  1062       pVar = &p->aVar[i-1];

  1063       rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel);

  1064       if( rc==SQLITE_OK && encoding!=0 ){

  1065         rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db));

  1066       }

  1067       sqlite3Error(p->db, rc, 0);

  1068       rc = sqlite3ApiExit(p->db, rc);

  1069     }

  1070     sqlite3_mutex_leave(p->db->mutex);

  1071   }

  1072   return rc;

  1073 }

  1074 

  1075 

  1076 /*

  1077 ** Bind a blob value to an SQL statement variable.

  1078 */

  1079 int sqlite3_bind_blob(

  1080   sqlite3_stmt *pStmt, 

  1081   int i, 

  1082   const void *zData, 

  1083   int nData, 

  1084   void (*xDel)(void*)

  1085 ){

  1086   return bindText(pStmt, i, zData, nData, xDel, 0);

  1087 }

  1088 int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){

  1089   int rc;

  1090   Vdbe *p = (Vdbe *)pStmt;

  1091   rc = vdbeUnbind(p, i);

  1092   if( rc==SQLITE_OK ){

  1093     sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);

  1094     sqlite3_mutex_leave(p->db->mutex);

  1095   }

  1096   return rc;

  1097 }

  1098 int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){

  1099   return sqlite3_bind_int64(p, i, (i64)iValue);

  1100 }

  1101 int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){

  1102   int rc;

  1103   Vdbe *p = (Vdbe *)pStmt;

  1104   rc = vdbeUnbind(p, i);

  1105   if( rc==SQLITE_OK ){

  1106     sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);

  1107     sqlite3_mutex_leave(p->db->mutex);

  1108   }

  1109   return rc;

  1110 }

  1111 int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){

  1112   int rc;

  1113   Vdbe *p = (Vdbe*)pStmt;

  1114   rc = vdbeUnbind(p, i);

  1115   if( rc==SQLITE_OK ){

  1116     sqlite3_mutex_leave(p->db->mutex);

  1117   }

  1118   return rc;

  1119 }

  1120 int sqlite3_bind_text( 

  1121   sqlite3_stmt *pStmt, 

  1122   int i, 

  1123   const char *zData, 

  1124   int nData, 

  1125   void (*xDel)(void*)

  1126 ){

  1127   return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);

  1128 }

  1129 #ifndef SQLITE_OMIT_UTF16

  1130 int sqlite3_bind_text16(

  1131   sqlite3_stmt *pStmt, 

  1132   int i, 

  1133   const void *zData, 

  1134   int nData, 

  1135   void (*xDel)(void*)