contrib/sqlite3/sqlite3.c

1303   int (*xFileControl)(sqlite3_file*, int op, void *pArg);
1329 ** into an integer that the pArg argument points to. This capability
4968 ** ^The fourth argument, pArg, is an application data pointer that is passed
4979 ** ^The collating function callback is invoked with a copy of the pArg
5003 ** with the addition that the xDestroy callback is invoked on pArg when
5024   void *pArg,
5031   void *pArg,
5039   void *pArg,
5313 ** ^The pArg argument is passed through to the callback.
6936 ** method is passed a copy of the sqlite3_pcache_methods2.pArg value.)^
7069   void *pArg;
7091   void *pArg;
8349   void *pArg;                /* First arg to busy callback */
10289 **   LIKEFUNC(zName, nArg, pArg, flags)
10292 **     function likeFunc. Argument pArg is cast to a (void *) and made
10303 #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \
10305    pArg, 0, xFunc, 0, 0, #zName, 0, 0}
15203 SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){
15205   return id->pMethods->xFileControl(id, op, pArg);
15207 SQLITE_PRIVATE void sqlite3OsFileControlHint(sqlite3_file *id, int op, void *pArg){
15208   (void)id->pMethods->xFileControl(id, op, pArg);
18861   void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
18862   void *pArg,
18868   mem0.alarmArg = pArg;
18882   void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
18883   void *pArg,
18886   return sqlite3MemoryAlarm(xCallback, pArg, iThreshold);
19010   void *pArg;
19014   pArg = mem0.alarmArg;
19017   xCallback(pArg, nowUsed, nByte);
19020   mem0.alarmArg = pArg;
26806 ** If *pArg is inititially negative then this is a query.  Set *pArg to
26809 ** If *pArg is 0 or 1, then clear or set the mask bit of pFile->ctrlFlags.
26811 static void unixModeBit(unixFile *pFile, unsigned char mask, int *pArg){
26812   if( *pArg<0 ){
26813     *pArg = (pFile->ctrlFlags & mask)!=0;
26814   }else if( (*pArg)==0 ){
26827 static int unixFileControl(sqlite3_file *id, int op, void *pArg){
26831       *(int*)pArg = pFile->eFileLock;
26835       *(int*)pArg = pFile->lastErrno;
26839       pFile->szChunk = *(int *)pArg;
26845       rc = fcntlSizeHint(pFile, *(i64 *)pArg);
26850       unixModeBit(pFile, UNIXFILE_PERSIST_WAL, (int*)pArg);
26854       unixModeBit(pFile, UNIXFILE_PSOW, (int*)pArg);
26858       *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
26865         *(char**)pArg = zTFile;
26870       i64 newLimit = *(i64*)pArg;
26874       *(i64*)pArg = pFile->mmapSizeMax;
26895       return proxyFileControl(id,op,pArg);
30192 static int proxyFileControl(sqlite3_file *id, int op, void *pArg){
30200           *(const char **)pArg = pCtx->lockProxyPath;
30202           *(const char **)pArg = ":auto: (not held)";
30205         *(const char **)pArg = NULL;
30213       if( pArg==NULL || (const char *)pArg==0 ){
30222         const char *proxyPath = (const char *)pArg;
30226           if( !strcmp(pArg, ":auto:")
33519 ** If *pArg is inititially negative then this is a query.  Set *pArg to
33522 ** If *pArg is 0 or 1, then clear or set the mask bit of pFile->ctrlFlags.
33524 static void winModeBit(winFile *pFile, unsigned char mask, int *pArg){
33525   if( *pArg<0 ){
33526     *pArg = (pFile->ctrlFlags & mask)!=0;
33527   }else if( (*pArg)==0 ){
33540 static int winFileControl(sqlite3_file *id, int op, void *pArg){
33542   OSTRACE(("FCNTL file=%p, op=%d, pArg=%p\n", pFile->h, op, pArg));
33545       *(int*)pArg = pFile->locktype;
33550       *(int*)pArg = (int)pFile->lastErrno;
33555       pFile->szChunk = *(int *)pArg;
33564           sqlite3_int64 newSz = *(sqlite3_int64*)pArg;
33578       winModeBit(pFile, WINFILE_PERSIST_WAL, (int*)pArg);
33583       winModeBit(pFile, WINFILE_PSOW, (int*)pArg);
33588       *(char**)pArg = sqlite3_mprintf("win32");
33593       int *a = (int*)pArg;
33611         *(char**)pArg = zTFile;
33618       i64 newLimit = *(i64*)pArg;
33622       *(i64*)pArg = pFile->mmapSizeMax;
36189   return sqlite3GlobalConfig.pcache2.xInit(sqlite3GlobalConfig.pcache2.pArg);
36194     sqlite3GlobalConfig.pcache2.xShutdown(sqlite3GlobalConfig.pcache2.pArg);
37611     0,                       /* pArg */
51253 static int btreeInvokeBusyHandler(void *pArg){
51254   BtShared *pBt = (BtShared*)pArg;
65504       Mem *pArg;
66726   Mem *pArg;
66741   u.ai.pArg = &aMem[pOp->p2];
66742   for(u.ai.i=0; u.ai.i<u.ai.n; u.ai.i++, u.ai.pArg++){
66743     assert( memIsValid(u.ai.pArg) );
66744     u.ai.apVal[u.ai.i] = u.ai.pArg;
66745     Deephemeralize(u.ai.pArg);
66746     sqlite3VdbeMemStoreType(u.ai.pArg);
66747     REGISTER_TRACE(pOp->p2+u.ai.i, u.ai.pArg);
82003   void *pArg
82007   db->pAuthArg = pArg;
88598   Mem *pArg  = (Mem *)argv[0];
88620     cmp = sqlite3MemCompare(pBest, pArg, pColl);
88622       sqlite3VdbeMemCopy(pBest, pArg);
88627     sqlite3VdbeMemCopy(pBest, pArg);
92040 ** the xCallback() function is called.  pArg becomes the first
92048   void *pArg,                 /* First argument to xCallback() */
92112         if( xCallback(pArg, nCol, azVals, azCols) ){
100954 static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
100955   TabResult *p = (TabResult*)pArg;  /* Result accumulator */
103726   Token *pArg = &pParse->sArg;
103727   if( pArg->z==0 ){
103728     pArg->z = p->z;
103729     pArg->n = p->n;
103731     assert(pArg->z < p->z);
103732     pArg->n = (int)(&p->z[p->n] - pArg->z);
104244   void *pArg = 0;
104271     rc = pMod->xFindFunction(pVtab, nArg, zLowerName, &xFunc, &pArg);
104289   pNew->pUserData = pArg;
116039   rc = p->xFunc(p->pArg, p->nBusy);
116055   void *pArg
116059   db->busyHandler.pArg = pArg;
116076   void *pArg
116082     db->pProgressArg = pArg;
116241   FuncDestructor *pArg = 0;
116244     pArg = (FuncDestructor *)sqlite3DbMallocZero(db, sizeof(FuncDestructor));
116245     if( !pArg ){
116249     pArg->xDestroy = xDestroy;
116250     pArg->pUserData = p;
116252   rc = sqlite3CreateFunc(db, zFunc, nArg, enc, p, xFunc, xStep, xFinal, pArg);
116253   if( pArg && pArg->nRef==0 ){
116256     sqlite3DbFree(db, pArg);
116321 ** Register a trace function.  The pArg from the previously registered trace
116328 SQLITE_API void *sqlite3_trace(sqlite3 *db, void (*xTrace)(void*,const char*), void *pArg){
116333   db->pTraceArg = pArg;
116338 ** Register a profile function.  The pArg from the previously registered
116348   void *pArg
116354   db->pProfileArg = pArg;
116368   void *pArg                /* Argument to the function */
116374   db->pCommitArg = pArg;
116386   void *pArg                /* Argument to the function */
116392   db->pUpdateArg = pArg;
116404   void *pArg                /* Argument to the function */
116410   db->pRollbackArg = pArg;
116469   void *pArg                      /* First argument passed to xCallback() */
116476   db->pWalArg = pArg;
117395     void *pArg = sqlite3GlobalConfig.pSqllogArg;
117396     sqlite3GlobalConfig.xSqllog(pArg, db, zFilename, 0);
117770 SQLITE_API int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *pArg){
117785       *(sqlite3_file**)pArg = fd;
117788       rc = sqlite3OsFileControl(fd, op, pArg);
118269   void *pArg
118287     xNotify(&pArg, 1);
118297       db->pUnlockArg = pArg;