Lines Matching defs:void
330 ** the ((void*)&((char*)0)[X]) construct. But MSVC chokes on ((void*)(X)).
336 # define SQLITE_INT_TO_PTR(X) ((void*)(intptr_t)(X))
339 # define SQLITE_INT_TO_PTR(X) ((void*)(X))
343 # define SQLITE_INT_TO_PTR(X) ((void*)&((char*)0)[X])
455 SQLITE_PRIVATE void sqlite3Coverage(int);
672 SQLITE_API const char *sqlite3_libversion(void);
673 SQLITE_API const char *sqlite3_sourceid(void);
674 SQLITE_API int sqlite3_libversion_number(void);
712 SQLITE_API int sqlite3_threadsafe(void);
797 typedef int (*sqlite3_callback)(void*,int,char**, char**);
863 int (*callback)(void*,int,char**,char**), /* Callback function */
864 void *, /* 1st argument to callback */
1149 int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
1150 int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst);
1157 int (*xFileControl)(sqlite3_file*, int op, void *pArg);
1331 void *pAppData; /* Pointer to application-specific data */
1337 void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename);
1338 void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg);
1339 void (*(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol))(void);
1340 void (*xDlClose)(sqlite3_vfs*, void*);
1441 SQLITE_API int sqlite3_initialize(void);
1442 SQLITE_API int sqlite3_shutdown(void);
1443 SQLITE_API int sqlite3_os_init(void);
1444 SQLITE_API int sqlite3_os_end(void);
1574 void *(*xMalloc)(int); /* Memory allocation function */
1575 void (*xFree)(void*); /* Free a prior allocation */
1576 void *(*xRealloc)(void*,int); /* Resize an allocation */
1577 int (*xSize)(void*); /* Return the size of an allocation */
1579 int (*xInit)(void*); /* Initialize the memory allocator */
1580 void (*xShutdown)(void*); /* Deinitialize the memory allocator */
1581 void *pAppData; /* Argument to xInit() and xShutdown() */
1779 #define SQLITE_CONFIG_SCRATCH 6 /* void*, int sz, int N */
1780 #define SQLITE_CONFIG_PAGECACHE 7 /* void*, int sz, int N */
1781 #define SQLITE_CONFIG_HEAP 8 /* void*, int nByte, int min */
1823 #define SQLITE_DBCONFIG_LOOKASIDE 1001 /* void* int int */
1997 SQLITE_API void sqlite3_interrupt(sqlite3*);
2033 SQLITE_API int sqlite3_complete16(const void *sql);
2046 ** ^The first argument to the busy handler is a copy of the void* pointer which
2099 SQLITE_API int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*);
2198 SQLITE_API void sqlite3_free_table(char **result);
2364 SQLITE_API void *sqlite3_malloc(int);
2365 SQLITE_API void *sqlite3_realloc(void*, int);
2366 SQLITE_API void sqlite3_free(void*);
2391 SQLITE_API sqlite3_int64 sqlite3_memory_used(void);
2412 SQLITE_API void sqlite3_randomness(int N, void *P);
2496 int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
2497 void *pUserData
2586 SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*);
2587 SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_profile(sqlite3*,
2588 void(*xProfile)(void*,const char*,sqlite3_uint64), void*);
2609 SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
2705 const void *filename, /* Database filename (UTF-16) */
2751 SQLITE_API const void *sqlite3_errmsg16(sqlite3*);
2972 const void *zSql, /* SQL statement, UTF-16 encoded */
2975 const void **pzTail /* OUT: Pointer to unused portion of zSql */
2979 const void *zSql, /* SQL statement, UTF-16 encoded */
2982 const void **pzTail /* OUT: Pointer to unused portion of zSql */
3126 SQLITE_API int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*));
3131 SQLITE_API int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*));
3132 SQLITE_API int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*));
3242 SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt*, int N);
3288 SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt*,int);
3290 SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt*,int);
3292 SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt*,int);
3324 SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt*,int);
3587 SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
3594 SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
3727 void *pApp,
3728 void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
3729 void (*xStep)(sqlite3_context*,int,sqlite3_value**),
3730 void (*xFinal)(sqlite3_context*)
3734 const void *zFunctionName,
3737 void *pApp,
3738 void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
3739 void (*xStep)(sqlite3_context*,int,sqlite3_value**),
3740 void (*xFinal)(sqlite3_context*)
3770 SQLITE_API SQLITE_DEPRECATED int sqlite3_global_recover(void);
3771 SQLITE_API SQLITE_DEPRECATED void sqlite3_thread_cleanup(void);
3772 SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int),void*,sqlite3_int64);
3820 SQLITE_API const void *sqlite3_value_blob(sqlite3_value*);
3827 SQLITE_API const void *sqlite3_value_text16(sqlite3_value*);
3828 SQLITE_API const void *sqlite3_value_text16le(sqlite3_value*);
3829 SQLITE_API const void *sqlite3_value_text16be(sqlite3_value*);
3872 SQLITE_API void *sqlite3_aggregate_context(sqlite3_context*, int nBytes);
3886 SQLITE_API void *sqlite3_user_data(sqlite3_context*);
3941 SQLITE_API void *sqlite3_get_auxdata(sqlite3_context*, int N);
3942 SQLITE_API void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*));
3959 typedef void (*sqlite3_destructor_type)(void*);
4068 SQLITE_API void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*));
4069 SQLITE_API void sqlite3_result_double(sqlite3_context*, double);
4070 SQLITE_API void sqlite3_result_error(sqlite3_context*, const char*, int);
4071 SQLITE_API void sqlite3_result_error16(sqlite3_context*, const void*, int);
4072 SQLITE_API void sqlite3_result_error_toobig(sqlite3_context*);
4073 SQLITE_API void sqlite3_result_error_nomem(sqlite3_context*);
4074 SQLITE_API void sqlite3_result_error_code(sqlite3_context*, int);
4075 SQLITE_API void sqlite3_result_int(sqlite3_context*, int);
4076 SQLITE_API void sqlite3_result_int64(sqlite3_context*, sqlite3_int64);
4077 SQLITE_API void sqlite3_result_null(sqlite3_context*);
4078 SQLITE_API void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*));
4079 SQLITE_API void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*));
4080 SQLITE_API void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*));
4081 SQLITE_API void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*));
4082 SQLITE_API void sqlite3_result_value(sqlite3_context*, sqlite3_value*);
4083 SQLITE_API void sqlite3_result_zeroblob(sqlite3_context*, int n);
4110 ** as its first parameter a copy of the void* passed as the fourth argument
4123 ** destroyed and is passed a copy of the fourth parameter void* pointer
4135 void*,
4136 int(*xCompare)(void*,int,const void*,int,const void*)
4142 void*,
4143 int(*xCompare)(void*,int,const void*,int,const void*),
4144 void(*xDestroy)(void*)
4148 const void *zName,
4150 void*,
4151 int(*xCompare)(void*,int,const void*,int,const void*)
4182 void*,
4183 void(*)(void*,sqlite3*,int eTextRep,const char*)
4187 void*,
4188 void(*)(void*,sqlite3*,int eTextRep,const void*)
4200 const void *pKey, int nKey /* The key */
4213 const void *pKey, int nKey /* The new key */
4359 SQLITE_API void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*);
4360 SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);
4408 SQLITE_API void *sqlite3_update_hook(
4410 void(*)(void *,int ,char const *,char const *,sqlite3_int64),
4411 void*
4485 SQLITE_API void sqlite3_soft_heap_limit(int);
4627 SQLITE_API int sqlite3_auto_extension(void (*xEntryPoint)(void));
4638 SQLITE_API void sqlite3_reset_auto_extension(void);
4678 int (*xCreate)(sqlite3*, void *pAux,
4681 int (*xConnect)(sqlite3*, void *pAux,
4701 void (**pxFunc)(sqlite3_context*,int,sqlite3_value**),
4702 void **ppArg);
4817 void *pClientData /* Client data for xCreate/xConnect */
4823 void *pClientData, /* Client data for xCreate/xConnect */
4824 void(*xDestroy)(void*) /* Module destructor function */
5063 SQLITE_API int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset);
5101 SQLITE_API int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset);
5251 SQLITE_API void sqlite3_mutex_free(sqlite3_mutex*);
5252 SQLITE_API void sqlite3_mutex_enter(sqlite3_mutex*);
5254 SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex*);
5324 int (*xMutexInit)(void);
5325 int (*xMutexEnd)(void);
5327 void (*xMutexFree)(sqlite3_mutex *);
5328 void (*xMutexEnter)(sqlite3_mutex *);
5330 void (*xMutexLeave)(sqlite3_mutex *);
5426 SQLITE_API int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*);
5830 void *pArg;
5831 int (*xInit)(void*);
5832 void (*xShutdown)(void*);
5834 void (*xCachesize)(sqlite3_pcache*, int nCachesize);
5836 void *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag);
5837 void (*xUnpin)(sqlite3_pcache*, void*, int discard);
5838 void (*xRekey)(sqlite3_pcache*, void*, unsigned oldKey, unsigned newKey);
5839 void (*xTruncate)(sqlite3_pcache*, unsigned iLimit);
5840 void (*xDestroy)(sqlite3_pcache*);
6103 ** single void* pointer that is passed to the callback when it is invoked.
6105 ** it an array of void* context pointers. The first argument passed to
6106 ** an unlock-notify callback is a pointer to an array of void* pointers,
6113 ** multiple times, it is invoked once with the set of void* context pointers
6161 void (*xNotify)(void **apArg, int nArg), /* Callback function to invoke */
6162 void *pNotifyArg /* Argument to pass to xNotify */
6255 void *data; /* Data associated with this element */
6262 SQLITE_PRIVATE void sqlite3HashInit(Hash*);
6263 SQLITE_PRIVATE void *sqlite3HashInsert(Hash*, const char *pKey, int nKey, void *pData);
6264 SQLITE_PRIVATE void *sqlite3HashFind(const Hash*, const char *pKey, int nKey);
6265 SQLITE_PRIVATE void sqlite3HashClear(Hash*);
6674 int (*xFunc)(void *,int); /* The busy callback */
6675 void *pArg; /* First arg to busy callback */
6725 #define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v)))
6728 SQLITE_API void *sqlite3_wsd_find(void *K, int L);
6751 #define UNUSED_PARAMETER(x) (void)(x)
6902 SQLITE_PRIVATE void *sqlite3BtreeSchema(Btree *, int, void(*)(void *));
6922 SQLITE_PRIVATE void sqlite3BtreeTripAllCursors(Btree*, int);
6924 SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *pBtree, int idx, u32 *pValue);
6955 SQLITE_PRIVATE int sqlite3BtreeCursorSize(void);
6956 SQLITE_PRIVATE void sqlite3BtreeCursorZero(BtCursor*);
6968 SQLITE_PRIVATE int sqlite3BtreeInsert(BtCursor*, const void *pKey, i64 nKey,
6969 const void *pData, int nData,
6977 SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor*, u32 offset, u32 amt, void*);
6978 SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor*, int *pAmt);
6979 SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor*, int *pAmt);
6981 SQLITE_PRIVATE int sqlite3BtreeData(BtCursor*, u32 offset, u32 amt, void*);
6982 SQLITE_PRIVATE void sqlite3BtreeSetCachedRowid(BtCursor*, sqlite3_int64);
6988 SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor*, u32 offset, u32 amt, void*);
6989 SQLITE_PRIVATE void sqlite3BtreeCacheOverflow(BtCursor *);
6990 SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *);
7002 SQLITE_PRIVATE void sqlite3BtreeCursorList(Btree*);
7011 SQLITE_PRIVATE void sqlite3BtreeEnter(Btree*);
7012 SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3*);
7019 SQLITE_PRIVATE void sqlite3BtreeLeave(Btree*);
7020 SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor*);
7021 SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor*);
7022 SQLITE_PRIVATE void sqlite3BtreeLeaveAll(sqlite3*);
7023 SQLITE_PRIVATE void sqlite3BtreeMutexArrayEnter(BtreeMutexArray*);
7024 SQLITE_PRIVATE void sqlite3BtreeMutexArrayLeave(BtreeMutexArray*);
7025 SQLITE_PRIVATE void sqlite3BtreeMutexArrayInsert(BtreeMutexArray*, Btree*);
7102 void *p; /* Generic pointer */
7135 void *token; /* id that may be used to recursive triggers */
7411 SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe*, int addr, int P1);
7412 SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe*, int addr, int P2);
7413 SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe*, int addr, int P3);
7414 SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe*, u8 P5);
7415 SQLITE_PRIVATE void sqlite3VdbeJumpHere(Vdbe*, int addr);
7416 SQLITE_PRIVATE void sqlite3VdbeChangeToNoop(Vdbe*, int addr, int N);
7417 SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe*, int addr, const char *zP4, int N);
7418 SQLITE_PRIVATE void sqlite3VdbeUsesBtree(Vdbe*, int);
7421 SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe*);
7422 SQLITE_PRIVATE void sqlite3VdbeMakeReady(Vdbe*,int,int,int,int,int,int);
7424 SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe*, int);
7428 SQLITE_PRIVATE void sqlite3VdbeTrace(Vdbe*,FILE*);
7430 SQLITE_PRIVATE void sqlite3VdbeResetStepResult(Vdbe*);
7432 SQLITE_PRIVATE void sqlite3VdbeSetNumCols(Vdbe*,int);
7433 SQLITE_PRIVATE int sqlite3VdbeSetColName(Vdbe*, int, int, const char *, void(*)(void*));
7434 SQLITE_PRIVATE void sqlite3VdbeCountChanges(Vdbe*);
7436 SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe*, const char *z, int n, int);
7437 SQLITE_PRIVATE void sqlite3VdbeSwap(Vdbe*,Vdbe*);
7439 SQLITE_PRIVATE void sqlite3VdbeProgramDelete(sqlite3 *, SubProgram *, int);
7441 SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe*, int);
7446 SQLITE_PRIVATE UnpackedRecord *sqlite3VdbeRecordUnpack(KeyInfo*,int,const void*,char*,int);
7447 SQLITE_PRIVATE void sqlite3VdbeDeleteUnpackedRecord(UnpackedRecord*);
7448 SQLITE_PRIVATE int sqlite3VdbeRecordCompare(int,const void*,UnpackedRecord*);
7452 SQLITE_PRIVATE void sqlite3VdbeComment(Vdbe*, const char*, ...);
7454 SQLITE_PRIVATE void sqlite3VdbeNoopComment(Vdbe*, const char*, ...);
7560 void(*)(DbPage*)
7566 SQLITE_PRIVATE void sqlite3PagerSetBusyhandler(Pager*, int(*)(void *), void *);
7569 SQLITE_PRIVATE void sqlite3PagerSetCachesize(Pager*, int);
7570 SQLITE_PRIVATE void sqlite3PagerSetSafetyLevel(Pager*,int,int);
7580 SQLITE_PRIVATE void sqlite3PagerRef(DbPage*);
7581 SQLITE_PRIVATE void sqlite3PagerUnref(DbPage*);
7585 SQLITE_PRIVATE void sqlite3PagerDontWrite(DbPage*);
7588 SQLITE_PRIVATE void *sqlite3PagerGetData(DbPage *);
7589 SQLITE_PRIVATE void *sqlite3PagerGetExtra(DbPage *);
7610 SQLITE_PRIVATE void *sqlite3PagerTempSpace(Pager*);
7614 SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager*,Pgno);
7623 SQLITE_PRIVATE void sqlite3PagerRefdump(Pager*);
7624 void disable_simulated_io_errors(void);
7625 void enable_simulated_io_errors(void);
7662 void *pData; /* Content of this page */
7663 void *pExtra; /* Extra content */
7692 SQLITE_PRIVATE int sqlite3PcacheInitialize(void);
7693 SQLITE_PRIVATE void sqlite3PcacheShutdown(void);
7698 SQLITE_PRIVATE void sqlite3PCacheBufferSetup(void *, int sz, int n);
7704 SQLITE_PRIVATE void sqlite3PcacheOpen(
7708 int (*xStress)(void*, PgHdr*), /* Call to try to make pages clean */
7709 void *pStress, /* Argument to xStress */
7714 SQLITE_PRIVATE void sqlite3PcacheSetPageSize(PCache *, int);
7719 SQLITE_PRIVATE int sqlite3PcacheSize(void);
7725 SQLITE_PRIVATE void sqlite3PcacheRelease(PgHdr*);
7727 SQLITE_PRIVATE void sqlite3PcacheDrop(PgHdr*); /* Remove page from cache */
7728 SQLITE_PRIVATE void sqlite3PcacheMakeDirty(PgHdr*); /* Make sure page is marked dirty */
7729 SQLITE_PRIVATE void sqlite3PcacheMakeClean(PgHdr*); /* Mark a single page as clean */
7730 SQLITE_PRIVATE void sqlite3PcacheCleanAll(PCache*); /* Mark all dirty list pages as clean */
7733 SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr*, Pgno);
7736 SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache*, Pgno x);
7742 SQLITE_PRIVATE void sqlite3PcacheClose(PCache*);
7745 SQLITE_PRIVATE void sqlite3PcacheClearSyncFlags(PCache *);
7748 SQLITE_PRIVATE void sqlite3PcacheClear(PCache*);
7754 SQLITE_PRIVATE void sqlite3PcacheRef(PgHdr*);
7766 SQLITE_PRIVATE void sqlite3PcacheIterateDirty(PCache *pCache, void (*xIter)(PgHdr *));
7775 SQLITE_PRIVATE void sqlite3PcacheSetCachesize(PCache *, int);
7786 SQLITE_PRIVATE void sqlite3PcacheStats(int*,int*,int*,int*);
7789 SQLITE_PRIVATE void sqlite3PCacheSetDefault(void);
8025 SQLITE_PRIVATE int sqlite3OsInit(void);
8031 SQLITE_PRIVATE int sqlite3OsRead(sqlite3_file*, void*, int amt, i64 offset);
8032 SQLITE_PRIVATE int sqlite3OsWrite(sqlite3_file*, const void*, int amt, i64 offset);
8039 SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file*,int,void*);
8052 SQLITE_PRIVATE void *sqlite3OsDlOpen(sqlite3_vfs *, const char *);
8053 SQLITE_PRIVATE void sqlite3OsDlError(sqlite3_vfs *, int, char *);
8054 SQLITE_PRIVATE void (*sqlite3OsDlSym(sqlite3_vfs *, void *, const char *))(void);
8055 SQLITE_PRIVATE void sqlite3OsDlClose(sqlite3_vfs *, void *);
8248 void *pStart; /* First byte of available memory space */
8249 void *pEnd; /* First byte past end of available space */
8321 void **aExtension; /* Array of shared library handles */
8325 void (*xTrace)(void*,const char*); /* Trace function */
8326 void *pTraceArg; /* Argument to the trace function */
8327 void (*xProfile)(void*,const char*,u64); /* Profiling function */
8328 void *pProfileArg; /* Argument to profile function */
8329 void *pCommitArg; /* Argument to xCommitCallback() */
8330 int (*xCommitCallback)(void*); /* Invoked at every commit. */
8331 void *pRollbackArg; /* Argument to xRollbackCallback() */
8332 void (*xRollbackCallback)(void*); /* Invoked at every commit. */
8333 void *pUpdateArg;
8334 void (*xUpdateCallback)(void*,int, const char*,const char*,sqlite_int64);
8335 void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*);
8336 void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*);
8337 void *pCollNeededArg;
8347 int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
8349 void *pAuthArg; /* 1st argument to the access auth function */
8352 int (*xProgress)(void *); /* The progress callback */
8353 void *pProgressArg; /* Argument to the progress callback */
8387 void *pUnlockArg; /* Argument to xUnlockNotify */
8388 void (*xUnlockNotify)(void **, int); /* Unlock notify callback */
8458 void *pUserData; /* User data parameter */
8460 void (*xFunc)(sqlite3_context*,int,sqlite3_value**); /* Regular function */
8461 void (*xStep)(sqlite3_context*,int,sqlite3_value**); /* Aggregate step */
8462 void (*xFinalize)(sqlite3_context*); /* Aggregate finalizer */
8485 ** value passed as iArg is cast to a (void*) and made available
8498 ** function likeFunc. Argument pArg is cast to a (void *) and made
8510 {nArg, SQLITE_UTF8, flags, (void *)arg, 0, likeFunc, 0, 0, #zName, 0}
8544 void *pAux; /* pAux passed to create_module() */
8545 void (*xDestroy)(void *); /* Module destructor function */
8591 void *pUser; /* First argument to xCmp() */
8592 int (*xCmp)(void*,int, const void*, int, const void*);
8593 void (*xDel)(void*); /* Destructor for pUser */
9861 void *pHeap; /* Heap storage space */
9864 void *pScratch; /* Scratch memory */
9867 void *pPage; /* Page cache memory */
9928 SQLITE_PRIVATE int sqlite3Corrupt(void);
9974 SQLITE_PRIVATE int sqlite3MallocInit(void);
9975 SQLITE_PRIVATE void sqlite3MallocEnd(void);
9976 SQLITE_PRIVATE void *sqlite3Malloc(int);
9977 SQLITE_PRIVATE void *sqlite3MallocZero(int);
9978 SQLITE_PRIVATE void *sqlite3DbMallocZero(sqlite3*, int);
9979 SQLITE_PRIVATE void *sqlite3DbMallocRaw(sqlite3*, int);
9982 SQLITE_PRIVATE void *sqlite3Realloc(void*, int);
9983 SQLITE_PRIVATE void *sqlite3DbReallocOrFree(sqlite3 *, void *, int);
9984 SQLITE_PRIVATE void *sqlite3DbRealloc(sqlite3 *, void *, int);
9985 SQLITE_PRIVATE void sqlite3DbFree(sqlite3*, void*);
9986 SQLITE_PRIVATE int sqlite3MallocSize(void*);
9987 SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3*, void*);
9988 SQLITE_PRIVATE void *sqlite3ScratchMalloc(int);
9989 SQLITE_PRIVATE void sqlite3ScratchFree(void*);
9990 SQLITE_PRIVATE void *sqlite3PageMalloc(int);
9991 SQLITE_PRIVATE void sqlite3PageFree(void*);
9992 SQLITE_PRIVATE void sqlite3MemSetDefault(void);
9993 SQLITE_PRIVATE void sqlite3BenignMallocHooks(void (*)(void), void (*)(void));
9994 SQLITE_PRIVATE int sqlite3MemoryAlarm(void (*)(void*, sqlite3_int64, int), void*, sqlite3_int64);
10015 SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys3(void);
10018 SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys5(void);
10023 SQLITE_PRIVATE sqlite3_mutex_methods *sqlite3DefaultMutex(void);
10025 SQLITE_PRIVATE int sqlite3MutexInit(void);
10026 SQLITE_PRIVATE int sqlite3MutexEnd(void);
10030 SQLITE_PRIVATE void sqlite3StatusAdd(int, int);
10031 SQLITE_PRIVATE void sqlite3StatusSet(int, int);
10035 SQLITE_PRIVATE void sqlite3VXPrintf(StrAccum*, int, const char*, va_list);
10037 SQLITE_PRIVATE void sqlite3XPrintf(StrAccum*, const char*, ...);
10043 SQLITE_PRIVATE void sqlite3DebugPrintf(const char*, ...);
10046 SQLITE_PRIVATE void *sqlite3TestTextToPtr(const char*);
10048 SQLITE_PRIVATE void sqlite3SetString(char **, sqlite3*, const char*, ...);
10049 SQLITE_PRIVATE void sqlite3ErrorMsg(Parse*, const char*, ...);
10050 SQLITE_PRIVATE void sqlite3ErrorClear(Parse*);
10054 SQLITE_PRIVATE void sqlite3FinishCoding(Parse*);
10056 SQLITE_PRIVATE void sqlite3ReleaseTempReg(Parse*,int);
10058 SQLITE_PRIVATE void sqlite3ReleaseTempRange(Parse*,int,int);
10061 SQLITE_PRIVATE void sqlite3ExprAttachSubtrees(sqlite3*,Expr*,Expr*,Expr*);
10065 SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse*, Expr*);
10066 SQLITE_PRIVATE void sqlite3ExprDelete(sqlite3*, Expr*);
10068 SQLITE_PRIVATE void sqlite3ExprListSetName(Parse*,ExprList*,Token*,int);
10069 SQLITE_PRIVATE void sqlite3ExprListSetSpan(Parse*,ExprList*,ExprSpan*);
10070 SQLITE_PRIVATE void sqlite3ExprListDelete(sqlite3*, ExprList*);
10072 SQLITE_PRIVATE int sqlite3InitCallback(void*, int, char**, char**);
10073 SQLITE_PRIVATE void sqlite3Pragma(Parse*,Token*,Token*,Token*,int);
10074 SQLITE_PRIVATE void sqlite3ResetInternalSchema(sqlite3*, int);
10075 SQLITE_PRIVATE void sqlite3BeginParse(Parse*,int);
10076 SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3*);
10078 SQLITE_PRIVATE void sqlite3OpenMasterTable(Parse *, int);
10079 SQLITE_PRIVATE void sqlite3StartTable(Parse*,Token*,Token*,int,int,int,int);
10080 SQLITE_PRIVATE void sqlite3AddColumn(Parse*,Token*);
10081 SQLITE_PRIVATE void sqlite3AddNotNull(Parse*, int);
10082 SQLITE_PRIVATE void sqlite3AddPrimaryKey(Parse*, ExprList*, int, int, int);
10083 SQLITE_PRIVATE void sqlite3AddCheckConstraint(Parse*, Expr*);
10084 SQLITE_PRIVATE void sqlite3AddColumnType(Parse*,Token*);
10085 SQLITE_PRIVATE void sqlite3AddDefaultValue(Parse*,ExprSpan*);
10086 SQLITE_PRIVATE void sqlite3AddCollateType(Parse*, Token*);
10087 SQLITE_PRIVATE void sqlite3EndTable(Parse*,Token*,Token*,Select*);
10092 SQLITE_PRIVATE void sqlite3BitvecClear(Bitvec*, u32, void*);
10093 SQLITE_PRIVATE void sqlite3BitvecDestroy(Bitvec*);
10097 SQLITE_PRIVATE RowSet *sqlite3RowSetInit(sqlite3*, void*, unsigned int);
10098 SQLITE_PRIVATE void sqlite3RowSetClear(RowSet*);
10099 SQLITE_PRIVATE void sqlite3RowSetInsert(RowSet*, i64);
10103 SQLITE_PRIVATE void sqlite3CreateView(Parse*,Token*,Token*,Token*,Select*,int,int);
10111 SQLITE_PRIVATE void sqlite3DropTable(Parse*, SrcList*, int, int);
10112 SQLITE_PRIVATE void sqlite3DeleteTable(Table*);
10114 SQLITE_PRIVATE void sqlite3AutoincrementBegin(Parse *pParse);
10115 SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse);
10120 SQLITE_PRIVATE void sqlite3Insert(Parse*, SrcList*, ExprList*, Select*, IdList*, int);
10121 SQLITE_PRIVATE void *sqlite3ArrayAllocate(sqlite3*,void*,int,int,int*,int*,int*);
10128 SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *, SrcList *, Token *);
10130 SQLITE_PRIVATE void sqlite3SrcListShiftJoinType(SrcList*);
10131 SQLITE_PRIVATE void sqlite3SrcListAssignCursors(Parse*, SrcList*);
10132 SQLITE_PRIVATE void sqlite3IdListDelete(sqlite3*, IdList*);
10133 SQLITE_PRIVATE void sqlite3SrcListDelete(sqlite3*, SrcList*);
10136 SQLITE_PRIVATE void sqlite3DropIndex(Parse*, SrcList*, int);
10140 SQLITE_PRIVATE void sqlite3SelectDelete(sqlite3*, Select*);
10143 SQLITE_PRIVATE void sqlite3OpenTable(Parse*, int iCur, int iDb, Table*, int);
10147 SQLITE_PRIVATE void sqlite3DeleteFrom(Parse*, SrcList*, Expr*);
10148 SQLITE_PRIVATE void sqlite3Update(Parse*, SrcList*, ExprList*, Expr*, int);
10150 SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo*);
10152 SQLITE_PRIVATE void sqlite3ExprCodeMove(Parse*, int, int, int);
10153 SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse*, int, int, int);
10154 SQLITE_PRIVATE void sqlite3ExprCacheStore(Parse*, int, int, int);
10155 SQLITE_PRIVATE void sqlite3ExprCachePush(Parse*);
10156 SQLITE_PRIVATE void sqlite3ExprCachePop(Parse*, int);
10157 SQLITE_PRIVATE void sqlite3ExprCacheRemove(Parse*, int, int);
10158 SQLITE_PRIVATE void sqlite3ExprCacheClear(Parse*);
10159 SQLITE_PRIVATE void sqlite3ExprCacheAffinityChange(Parse*, int, int);
10160 SQLITE_PRIVATE void sqlite3ExprHardCopy(Parse*,int,int);
10165 SQLITE_PRIVATE void sqlite3ExprCodeConstants(Parse*, Expr*);
10167 SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse*, Expr*, int, int);
10168 SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse*, Expr*, int, int);
10172 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable(sqlite3*,int,const char*);
10173 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3*,int,const char*);
10174 SQLITE_PRIVATE void sqlite3Vacuum(Parse*);
10178 SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext*, Expr*);
10179 SQLITE_PRIVATE void sqlite3ExprAnalyzeAggList(NameContext*,ExprList*);
10181 SQLITE_PRIVATE void sqlite3PrngSaveState(void);
10182 SQLITE_PRIVATE void sqlite3PrngRestoreState(void);
10183 SQLITE_PRIVATE void sqlite3PrngResetState(void);
10184 SQLITE_PRIVATE void sqlite3RollbackAll(sqlite3*);
10185 SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse*, int);
10186 SQLITE_PRIVATE void sqlite3BeginTransaction(Parse*, int);
10187 SQLITE_PRIVATE void sqlite3CommitTransaction(Parse*);
10188 SQLITE_PRIVATE void sqlite3RollbackTransaction(Parse*);
10189 SQLITE_PRIVATE void sqlite3Savepoint(Parse*, int, Token*);
10190 SQLITE_PRIVATE void sqlite3CloseSavepoints(sqlite3 *);
10196 SQLITE_PRIVATE void sqlite3ExprCodeIsNullJump(Vdbe*, const Expr*, int, int);
10199 SQLITE_PRIVATE void sqlite3GenerateRowDelete(Parse*, Table*, int, int, int, Trigger *, int);
10200 SQLITE_PRIVATE void sqlite3GenerateRowIndexDelete(Parse*, Table*, int, int*);
10202 SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(Parse*,Table*,int,int,
10204 SQLITE_PRIVATE void sqlite3CompleteInsertion(Parse*, Table*, int, int, int*, int, int, int);
10206 SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse*, int, int);
10207 SQLITE_PRIVATE void sqlite3MultiWrite(Parse*);
10208 SQLITE_PRIVATE void sqlite3MayAbort(Parse*);
10209 SQLITE_PRIVATE void sqlite3HaltConstraint(Parse*, int, char*, int);
10215 SQLITE_PRIVATE void sqlite3FuncDefInsert(FuncDefHash*, FuncDef*);
10217 SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(sqlite3*);
10218 SQLITE_PRIVATE void sqlite3RegisterDateTimeFunctions(void);
10219 SQLITE_PRIVATE void sqlite3RegisterGlobalFunctions(void);
10229 SQLITE_PRIVATE void sqlite3ChangeCookie(Parse*, int);
10232 SQLITE_PRIVATE void sqlite3MaterializeView(Parse*, Table*, Expr*, int);
10236 SQLITE_PRIVATE void sqlite3BeginTrigger(Parse*, Token*,Token*,int,int,IdList*,SrcList*,
10238 SQLITE_PRIVATE void sqlite3FinishTrigger(Parse*, TriggerStep*, Token*);
10239 SQLITE_PRIVATE void sqlite3DropTrigger(Parse*, SrcList*, int);
10240 SQLITE_PRIVATE void sqlite3DropTriggerPtr(Parse*, Trigger*);
10243 SQLITE_PRIVATE void sqlite3CodeRowTrigger(Parse*, Trigger *, int, ExprList*, int, Table *,
10245 SQLITE_PRIVATE void sqlite3CodeRowTriggerDirect(Parse *, Trigger *, Table *, int, int, int);
10246 void sqliteViewTriggers(Parse*, Table*, Expr*, int, ExprList*);
10247 SQLITE_PRIVATE void sqlite3DeleteTriggerStep(sqlite3*, TriggerStep*);
10253 SQLITE_PRIVATE void sqlite3DeleteTrigger(sqlite3*, Trigger*);
10254 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3*,int,const char*);
10270 SQLITE_PRIVATE void sqlite3CreateForeignKey(Parse*, ExprList*, Token*, ExprList*, int);
10271 SQLITE_PRIVATE void sqlite3DeferForeignKey(Parse*, int);
10273 SQLITE_PRIVATE void sqlite3AuthRead(Parse*,Expr*,Schema*,SrcList*);
10275 SQLITE_PRIVATE void sqlite3AuthContextPush(Parse*, AuthContext*, const char*);
10276 SQLITE_PRIVATE void sqlite3AuthContextPop(AuthContext*);
10282 # define sqlite3AuthContextPop(a) ((void)(a))
10284 SQLITE_PRIVATE void sqlite3Attach(Parse*, Expr*, Expr*, Expr*);
10285 SQLITE_PRIVATE void sqlite3Detach(Parse*, Expr*);
10297 SQLITE_PRIVATE int sqlite3Utf16ByteLen(const void *pData, int nChar);
10338 SQLITE_PRIVATE void sqlite3TableAffinityStr(Vdbe *, Table *);
10343 SQLITE_PRIVATE void sqlite3Error(sqlite3*, int, const char*,...);
10344 SQLITE_PRIVATE void *sqlite3HexToBlob(sqlite3*, const char *z, int n);
10354 SQLITE_PRIVATE void sqlite3VdbeSetChanges(sqlite3 *, int);
10356 SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value*, u8);
10358 SQLITE_PRIVATE void sqlite3ValueSetStr(sqlite3_value*, int, const void *,u8,
10359 void(*)(void*));
10360 SQLITE_PRIVATE void sqlite3ValueFree(sqlite3_value*);
10362 SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *, const void*, int);
10367 SQLITE_PRIVATE void sqlite3ValueApplyAffinity(sqlite3_value *, u8, u8);
10376 SQLITE_PRIVATE void sqlite3RootPageMoved(Db*, int, int);
10377 SQLITE_PRIVATE void sqlite3Reindex(Parse*, Token*, Token*);
10378 SQLITE_PRIVATE void sqlite3AlterFunctions(sqlite3*);
10379 SQLITE_PRIVATE void sqlite3AlterRenameTable(Parse*, SrcList*, Token*);
10381 SQLITE_PRIVATE void sqlite3NestedParse(Parse*, const char*, ...);
10382 SQLITE_PRIVATE void sqlite3ExpirePreparedStatements(sqlite3*);
10384 SQLITE_PRIVATE void sqlite3SelectPrep(Parse*, Select*, NameContext*);
10386 SQLITE_PRIVATE void sqlite3ResolveSelectNames(Parse*, Select*, NameContext*);
10388 SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *, Table *, int, int);
10389 SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *, Token *);
10390 SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *, SrcList *);
10393 SQLITE_PRIVATE void sqlite3Analyze(Parse*, Token*, Token*);
10398 SQLITE_PRIVATE void sqlite3DeleteIndexSamples(Index*);
10399 SQLITE_PRIVATE void sqlite3DefaultRowEst(Index*);
10400 SQLITE_PRIVATE void sqlite3RegisterLikeFunctions(sqlite3*, int);
10402 SQLITE_PRIVATE void sqlite3MinimumFileFormat(Parse*, int, int);
10403 SQLITE_PRIVATE void sqlite3SchemaFree(void *);
10407 SQLITE_PRIVATE int sqlite3CreateFunc(sqlite3 *, const char *, int, int, void *,
10408 void (*)(sqlite3_context*,int,sqlite3_value **),
10409 void (*)(sqlite3_context*,int,sqlite3_value **), void (*)(sqlite3_context*));
10413 SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum*, char*, int, int);
10414 SQLITE_PRIVATE void sqlite3StrAccumAppend(StrAccum*,const char*,int);
10416 SQLITE_PRIVATE void sqlite3StrAccumReset(StrAccum*);
10417 SQLITE_PRIVATE void sqlite3SelectDestInit(SelectDest*,int,int);
10420 SQLITE_PRIVATE void sqlite3BackupRestart(sqlite3_backup *);
10421 SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *, Pgno, const u8 *);
10426 SQLITE_PRIVATE void *sqlite3ParserAlloc(void*(*)(size_t));
10427 SQLITE_PRIVATE void sqlite3ParserFree(void*, void(*)(void*));
10428 SQLITE_PRIVATE void sqlite3Parser(void*, int, Token, Parse*);
10430 SQLITE_PRIVATE int sqlite3ParserStackPeak(void*);
10433 SQLITE_PRIVATE void sqlite3AutoLoadExtensions(sqlite3*);
10435 SQLITE_PRIVATE void sqlite3CloseExtensions(sqlite3*);
10441 SQLITE_PRIVATE void sqlite3TableLock(Parse *, int, int, u8, const char *);
10460 SQLITE_PRIVATE void sqlite3VtabClear(Table*);
10464 SQLITE_PRIVATE void sqlite3VtabLock(VTable *);
10465 SQLITE_PRIVATE void sqlite3VtabUnlock(VTable *);
10466 SQLITE_PRIVATE void sqlite3VtabUnlockList(sqlite3*);
10469 SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse*,Table*);
10470 SQLITE_PRIVATE void sqlite3VtabBeginParse(Parse*, Token*, Token*, Token*);
10471 SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse*, Token*);
10472 SQLITE_PRIVATE void sqlite3VtabArgInit(Parse*);
10473 SQLITE_PRIVATE void sqlite3VtabArgExtend(Parse*, Token*);
10479 SQLITE_PRIVATE void sqlite3InvalidFunction(sqlite3_context*,int,sqlite3_value**);
10483 SQLITE_PRIVATE void sqlite3ExprListCheckLength(Parse*, ExprList*, const char*);
10496 SQLITE_PRIVATE void sqlite3FkCheck(Parse*, Table*, int, int);
10497 SQLITE_PRIVATE void sqlite3FkDropTable(Parse*, SrcList *, Table*);
10498 SQLITE_PRIVATE void sqlite3FkActions(Parse*, Table*, ExprList*, int);
10510 SQLITE_PRIVATE void sqlite3FkDelete(Table*);
10528 SQLITE_PRIVATE void sqlite3BeginBenignMalloc(void);
10529 SQLITE_PRIVATE void sqlite3EndBenignMalloc(void);
10548 SQLITE_PRIVATE void sqlite3MemJournalOpen(sqlite3_file *);
10549 SQLITE_PRIVATE int sqlite3MemJournalSize(void);
10553 SQLITE_PRIVATE void sqlite3ExprSetHeight(Parse *pParse, Expr *p);
10563 SQLITE_PRIVATE void sqlite3Put4byte(u8*, u32);
10566 SQLITE_PRIVATE void sqlite3ConnectionBlocked(sqlite3 *, sqlite3 *);
10567 SQLITE_PRIVATE void sqlite3ConnectionUnlocked(sqlite3 *db);
10568 SQLITE_PRIVATE void sqlite3ConnectionClosed(sqlite3 *db);
10576 SQLITE_PRIVATE void sqlite3ParserTrace(FILE*, char *);
10586 SQLITE_PRIVATE void sqlite3VdbeIOTraceSql(Vdbe*);
10587 SQLITE_PRIVATE void (*sqlite3IoTrace)(const char*,...);
10743 (void*)0, /* pHeap */
10746 (void*)0, /* pScratch */
10749 (void*)0, /* pPage */
10855 SQLITE_PRIVATE void sqlite3StatusAdd(int op, int N){
10867 SQLITE_PRIVATE void sqlite3StatusSet(int op, int X){
11155 static void computeJD(DateTime *p){
11236 static void setDateTimeToCurrent(sqlite3_context *context, DateTime *p){
11286 static void computeYMD(DateTime *p){
11312 static void computeHMS(DateTime *p){
11330 static void computeYMD_HMS(DateTime *p){
11338 static void clearYMD_HMS_TZ(DateTime *p){
11678 static void juliandayFunc(
11695 static void datetimeFunc(
11715 static void timeFunc(
11734 static void dateFunc(
11767 static void strftimeFunc(
11903 static void ctimeFunc(
11917 static void cdateFunc(
11931 static void ctimestampFunc(
11953 static void currentTimeFunc(
12002 SQLITE_PRIVATE void sqlite3RegisterDateTimeFunctions(void){
12067 void *pTstAlloc = sqlite3Malloc(10); \
12089 SQLITE_PRIVATE int sqlite3OsRead(sqlite3_file *id, void *pBuf, int amt, i64 offset){
12093 SQLITE_PRIVATE int sqlite3OsWrite(sqlite3_file *id, const void *pBuf, int amt, i64 offset){
12119 SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){
12173 SQLITE_PRIVATE void *sqlite3OsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
12176 SQLITE_PRIVATE void sqlite3OsDlError(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
12179 SQLITE_PRIVATE void (*sqlite3OsDlSym(sqlite3_vfs *pVfs, void *pHdle, const char *zSym))(void){
12182 SQLITE_PRIVATE void sqlite3OsDlClose(sqlite3_vfs *pVfs, void *pHandle){
12230 SQLITE_PRIVATE int sqlite3OsInit(void){
12231 void *p = sqlite3_malloc(10);
12271 static void vfsUnlink(sqlite3_vfs *pVfs){
12363 void (*xBenignBegin)(void);
12364 void (*xBenignEnd)(void);
12387 SQLITE_PRIVATE void sqlite3BenignMallocHooks(
12388 void (*xBenignBegin)(void),
12389 void (*xBenignEnd)(void)
12401 SQLITE_PRIVATE void sqlite3BeginBenignMalloc(void){
12407 SQLITE_PRIVATE void sqlite3EndBenignMalloc(void){
12447 static void *sqlite3MemMalloc(int nByte){ return 0; }
12448 static void sqlite3MemFree(void *pPrior){ return; }
12449 static void *sqlite3MemRealloc(void *pPrior, int nByte){ return 0; }
12450 static int sqlite3MemSize(void *pPrior){ return 0; }
12452 static int sqlite3MemInit(void *NotUsed){ return SQLITE_OK; }
12453 static void sqlite3MemShutdown(void *NotUsed){ return; }
12461 SQLITE_PRIVATE void sqlite3MemSetDefault(void){
12514 static void *sqlite3MemMalloc(int nByte){
12523 return (void *)p;
12534 static void sqlite3MemFree(void *pPrior){
12551 static void *sqlite3MemRealloc(void *pPrior, int nByte){
12562 return (void*)p;
12569 static int sqlite3MemSize(void *pPrior){
12587 static int sqlite3MemInit(void *NotUsed){
12595 static void sqlite3MemShutdown(void *NotUsed){
12606 SQLITE_PRIVATE void sqlite3MemSetDefault(void){
12656 extern int backtrace(void**,int);
12657 extern void backtrace_symbols_fd(void*const*,int,int);
12719 void (*xBacktrace)(int, int, void **);
12749 static void adjustStats(int iSize, int increment){
12772 static struct MemBlockHdr *sqlite3MemsysGetHeader(void *pAllocation){
12796 static int sqlite3MemSize(void *p){
12808 static int sqlite3MemInit(void *NotUsed){
12822 static void sqlite3MemShutdown(void *NotUsed){
12839 static void randomFill(char *pBuf, int nByte){
12862 static void *sqlite3MemMalloc(int nByte){
12864 void **pBt;
12867 void *p = 0;
12874 mem.nBacktrace*sizeof(void*) + mem.nTitle;
12878 pBt = (void**)&z[mem.nTitle];
12892 void *aAddr[40];
12894 memcpy(pBt, &aAddr[1], pHdr->nBacktrace*sizeof(void*));
12911 p = (void*)pInt;
12920 static void sqlite3MemFree(void *pPrior){
12922 void **pBt;
12926 pBt = (void**)pHdr;
12946 randomFill(z, sizeof(void*)*pHdr->nBacktraceSlots + sizeof(*pHdr) +
12961 static void *sqlite3MemRealloc(void *pPrior, int nByte){
12963 void *pNew;
12981 SQLITE_PRIVATE void sqlite3MemSetDefault(void){
13000 SQLITE_PRIVATE void sqlite3MemdebugBacktrace(int depth){
13007 SQLITE_PRIVATE void sqlite3MemdebugBacktraceCallback(void (*xBacktrace)(int, int, void **)){
13014 SQLITE_PRIVATE void sqlite3MemdebugSettitle(const char *zTitle){
13024 SQLITE_PRIVATE void sqlite3MemdebugSync(){
13027 void **pBt = (void**)pHdr;
13037 SQLITE_PRIVATE void sqlite3MemdebugDump(const char *zFilename){
13040 void **pBt;
13050 z -= pHdr->nBacktraceSlots*sizeof(void*) + pHdr->nTitle;
13055 pBt = (void**)pHdr;
13238 static void memsys3UnlinkFromList(u32 i, u32 *pRoot){
13258 static void memsys3Unlink(u32 i){
13278 static void memsys3LinkIntoList(u32 i, u32 *pRoot){
13292 static void memsys3Link(u32 i){
13313 static void memsys3Enter(void){
13319 static void memsys3Leave(void){
13326 static void memsys3OutOfMemory(int nByte){
13343 static void *memsys3Checkout(u32 i, u32 nBlock){
13361 static void *memsys3FromMaster(u32 nBlock){
13366 void *p = memsys3Checkout(mem3.iMaster, mem3.szMaster);
13386 return (void*)&mem3.aPool[newi];
13406 static void memsys3Merge(u32 *pRoot){
13445 static void *memsys3MallocUnsafe(int nByte){
13527 void memsys3FreeUnsafe(void *pOld){
13568 static int memsys3Size(void *p){
13590 static void *memsys3Malloc(int nBytes){
13596 return (void*)p;
13602 void memsys3Free(void *pPrior){
13612 void *memsys3Realloc(void *pPrior, int nBytes){
13614 void *p;
13643 static int memsys3Init(void *NotUsed){
13668 static void memsys3Shutdown(void *NotUsed){
13680 SQLITE_PRIVATE void sqlite3Memsys3Dump(const char *zFilename){
13764 SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys3(void){
13927 static void memsys5Unlink(int i, int iLogsize){
13949 static void memsys5Link(int i, int iLogsize){
13970 static void memsys5Enter(void){
13973 static void memsys5Leave(void){
13982 static int memsys5Size(void *p){
14021 static void *memsys5MallocUnsafe(int nByte){
14073 return (void*)&mem5.zPool[i*mem5.szAtom];
14079 static void memsys5FreeUnsafe(void *pOld){
14135 static void *memsys5Malloc(int nBytes){
14142 return (void*)p;
14151 static void memsys5Free(void *pPrior){
14170 static void *memsys5Realloc(void *pPrior, int nBytes){
14172 void *p;
14231 static int memsys5Init(void *NotUsed){
14288 static void memsys5Shutdown(void *NotUsed){
14299 SQLITE_PRIVATE void sqlite3Memsys5Dump(const char *zFilename){
14342 SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys5(void){
14390 SQLITE_PRIVATE int sqlite3MutexInit(void){
14421 SQLITE_PRIVATE int sqlite3MutexEnd(void){
14455 SQLITE_API void sqlite3_mutex_free(sqlite3_mutex *p){
14465 SQLITE_API void sqlite3_mutex_enter(sqlite3_mutex *p){
14489 SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex *p){
14549 static int noopMutexInit(void){ return SQLITE_OK; }
14550 static int noopMutexEnd(void){ return SQLITE_OK; }
14552 static void noopMutexFree(sqlite3_mutex *p){ return; }
14553 static void noopMutexEnter(sqlite3_mutex *p){ return; }
14555 static void noopMutexLeave(sqlite3_mutex *p){ return; }
14557 SQLITE_PRIVATE sqlite3_mutex_methods *sqlite3DefaultMutex(void){
14604 static int debugMutexInit(void){ return SQLITE_OK; }
14605 static int debugMutexEnd(void){ return SQLITE_OK; }
14639 static void debugMutexFree(sqlite3_mutex *p){
14656 static void debugMutexEnter(sqlite3_mutex *p){
14672 static void debugMutexLeave(sqlite3_mutex *p){
14678 SQLITE_PRIVATE sqlite3_mutex_methods *sqlite3DefaultMutex(void){
14739 static int os2MutexInit(void){ return SQLITE_OK; }
14740 static int os2MutexEnd(void){ return SQLITE_OK; }
14849 static void os2MutexFree(sqlite3_mutex *p){
14901 static void os2MutexEnter(sqlite3_mutex *p){
14937 static void os2MutexLeave(sqlite3_mutex *p){
14950 SQLITE_PRIVATE sqlite3_mutex_methods *sqlite3DefaultMutex(void){
15043 static int pthreadMutexInit(void){ return SQLITE_OK; }
15044 static int pthreadMutexEnd(void){ return SQLITE_OK; }
15143 static void pthreadMutexFree(sqlite3_mutex *p){
15161 static void pthreadMutexEnter(sqlite3_mutex *p){
15255 static void pthreadMutexLeave(sqlite3_mutex *p){
15275 SQLITE_PRIVATE sqlite3_mutex_methods *sqlite3DefaultMutex(void){
15351 static int mutexIsNT(void){
15390 static int winMutexInit(void){
15407 static int winMutexEnd(void){
15495 static void winMutexFree(sqlite3_mutex *p){
15514 static void winMutexEnter(sqlite3_mutex *p){
15552 static void winMutexLeave(sqlite3_mutex *p){
15560 SQLITE_PRIVATE sqlite3_mutex_methods *sqlite3DefaultMutex(void){
15604 static void softHeapLimitEnforcer(
15605 void *NotUsed,
15617 SQLITE_API void sqlite3_soft_heap_limit(int n){
15672 void (*alarmCallback)(void*, sqlite3_int64,int);
15673 void *alarmArg;
15689 SQLITE_PRIVATE int sqlite3MallocInit(void){
15731 SQLITE_PRIVATE void sqlite3MallocEnd(void){
15741 SQLITE_API sqlite3_int64 sqlite3_memory_used(void){
15766 void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
15767 void *pArg,
15784 void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
15785 void *pArg,
15795 static void sqlite3MallocAlarm(int nByte){
15796 void (*xCallback)(void*,sqlite3_int64,int);
15798 void *pArg;
15815 static int mallocWithAlarm(int n, void **pp){
15817 void *p;
15844 SQLITE_PRIVATE void *sqlite3Malloc(int n){
15845 void *p;
15868 SQLITE_API void *sqlite3_malloc(int n){
15894 SQLITE_PRIVATE void *sqlite3ScratchMalloc(int n){
15895 void *p;
15920 p = (void*)&((char*)sqlite3GlobalConfig.pScratch)[i];
15945 SQLITE_PRIVATE void sqlite3ScratchFree(void *p){
15959 || p>=(void*)mem0.aScratchFree ){
15988 static int isLookaside(sqlite3 *db, void *p){
15999 SQLITE_PRIVATE int sqlite3MallocSize(void *p){
16002 SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3 *db, void *p){
16014 SQLITE_API void sqlite3_free(void *p){
16030 SQLITE_PRIVATE void sqlite3DbFree(sqlite3 *db, void *p){
16045 SQLITE_PRIVATE void *sqlite3Realloc(void *pOld, int nBytes){
16047 void *pNew;
16090 SQLITE_API void *sqlite3_realloc(void *pOld, int n){
16101 SQLITE_PRIVATE void *sqlite3MallocZero(int n){
16102 void *p = sqlite3Malloc(n);
16113 SQLITE_PRIVATE void *sqlite3DbMallocZero(sqlite3 *db, int n){
16114 void *p = sqlite3DbMallocRaw(db, n);
16139 SQLITE_PRIVATE void *sqlite3DbMallocRaw(sqlite3 *db, int n){
16140 void *p;
16155 return (void*)pBuf;
16174 SQLITE_PRIVATE void *sqlite3DbRealloc(sqlite3 *db, void *p, int n){
16175 void *pNew = 0;
16205 SQLITE_PRIVATE void *sqlite3DbReallocOrFree(sqlite3 *db, void *p, int n){
16206 void *pNew;
16254 SQLITE_PRIVATE void sqlite3SetString(char **pz, sqlite3 *db, const char *zFormat, ...){
16470 static void appendSpace(StrAccum *pAccum, int N){
16521 SQLITE_PRIVATE void sqlite3VXPrintf(
17035 SQLITE_PRIVATE void sqlite3StrAccumAppend(StrAccum *p, const char *z, int N){
17105 SQLITE_PRIVATE void sqlite3StrAccumReset(StrAccum *p){
17115 SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum *p, char *zBase, int n, int mx){
17239 SQLITE_PRIVATE void sqlite3DebugPrintf(const char *zFormat, ...){
17258 SQLITE_PRIVATE void sqlite3XPrintf(StrAccum *p, const char *zFormat, ...){
17312 static u8 randomByte(void){
17371 SQLITE_API void sqlite3_randomness(int N, void *pBuf){
17394 SQLITE_PRIVATE void sqlite3PrngSaveState(void){
17401 SQLITE_PRIVATE void sqlite3PrngRestoreState(void){
17408 SQLITE_PRIVATE void sqlite3PrngResetState(void){
17564 void *token; /* Copy of SubProgram.token */
17605 void (*xDel)(void *); /* If not null, call this function to delete Mem.z */
17671 void *pAux; /* Aux data for the i-th argument */
17672 void (*xDelete)(void *); /* Destructor for the aux data */
17766 void *pFree; /* Free this when deleting the vdbe */
17789 SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *, VdbeCursor*);
17790 void sqliteVdbePopStack(Vdbe*,int);
17793 SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE*, int, Op*);
17799 SQLITE_PRIVATE void sqlite3VdbeDeleteAuxData(VdbeFunc*, int);
17801 int sqlite2BtreeKeyCompare(BtCursor *, const void *, int, int, int *);
17811 SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem*, const Mem*, int);
17812 SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem*, Mem*);
17814 SQLITE_PRIVATE int sqlite3VdbeMemSetStr(Mem*, const char*, int, u8, void(*)(void*));
17815 SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem*, i64);
17816 SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem*, double);
17817 SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem*);
17818 SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem*,int);
17819 SQLITE_PRIVATE void sqlite3VdbeMemSetRowSet(Mem*);
17825 SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem*);
17829 SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p);
17830 SQLITE_PRIVATE void sqlite3VdbeMemReleaseExternal(Mem *p);
17835 SQLITE_PRIVATE void sqlite3VdbeFrameDelete(VdbeFrame*);
17837 SQLITE_PRIVATE void sqlite3VdbeMemStoreType(Mem *pMem);
17846 SQLITE_PRIVATE void sqlite3VdbeMutexArrayEnter(Vdbe *p);
17853 SQLITE_PRIVATE void sqlite3VdbePrintSql(Vdbe*);
17854 SQLITE_PRIVATE void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf);
18269 SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *db, const void *z, int nByte){
18315 SQLITE_PRIVATE int sqlite3Utf16ByteLen(const void *zIn, int nChar){
18340 SQLITE_PRIVATE void sqlite3UtfSelfTest(void){
18416 SQLITE_PRIVATE void sqlite3Coverage(int x){
18503 SQLITE_PRIVATE void sqlite3Error(sqlite3 *db, int err_code, const char *zFormat, ...){
18536 SQLITE_PRIVATE void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){
18550 SQLITE_PRIVATE void sqlite3ErrorClear(Parse *pParse){
19338 SQLITE_PRIVATE void sqlite3Put4byte(unsigned char *p, u32 v){
19372 SQLITE_PRIVATE void *sqlite3HexToBlob(sqlite3 *db, const char *z, int n){
19506 SQLITE_PRIVATE void sqlite3HashInit(Hash *pNew){
19518 SQLITE_PRIVATE void sqlite3HashClear(Hash *pH){
19552 static void insertElement(
19651 static void removeElementGivenHash(
19686 SQLITE_PRIVATE void *sqlite3HashFind(const Hash *pH, const char *pKey, int nKey){
19716 SQLITE_PRIVATE void *sqlite3HashInsert(Hash *pH, const char *pKey, int nKey, void *data){
19731 void *old_data = elem->data;
20070 __inline__ sqlite_uint64 sqlite3Hwtime(void){
20078 __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){
20089 __inline__ sqlite_uint64 sqlite3Hwtime(void){
20097 __inline__ sqlite_uint64 sqlite3Hwtime(void){
20121 SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }
20159 static void local_ioerr(){
20244 void *pBuf, /* Write content into this buffer */
20275 const void *pBuf, /* The bytes to be written */
20663 static int os2FileControl(sqlite3_file *id, int op, void *pArg){
20705 static void initUconvObjects( void ){
20715 static void freeUconvObjects( void ){
21061 static void *os2DlOpen(sqlite3_vfs *pVfs, const char *zFilename){
21068 return rc != NO_ERROR ? 0 : (void*)hmod;
21074 static void os2DlError(sqlite3_vfs *pVfs, int nBuf, char *zBufOut){
21077 static void *os2DlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol){
21089 return rc != NO_ERROR ? 0 : (void*)pfn;
21091 static void os2DlClose(sqlite3_vfs *pVfs, void *pHandle){
21232 SQLITE_API int sqlite3_os_init(void){
21258 SQLITE_API int sqlite3_os_end(void){
21459 void *lockingContext; /* Locking style specific state */
21595 __inline__ sqlite_uint64 sqlite3Hwtime(void){
21603 __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){
21614 __inline__ sqlite_uint64 sqlite3Hwtime(void){
21622 __inline__ sqlite_uint64 sqlite3Hwtime(void){
21646 SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }
21684 static void local_ioerr(){
21773 static void unixEnterMutex(void){
21776 static void unixLeaveMutex(void){
21780 static int unixMutexHeld(void) {
22052 static void vxworksReleaseFileId(struct vxworksFileId *pId){
22318 static void *threadLockingTest(void *pArg){
22332 static void testThreadLockingBehavior(int fd_orig){
22367 static void releaseLockInfo(struct unixLockInfo *pLock){
22394 static void releaseOpenCnt(struct unixOpenCnt *pOpen){
22995 static void setPendingFd(unixFile *pFile){
24230 static int seekAndRead(unixFile *id, sqlite3_int64 offset, void *pBuf, int cnt){
24268 void *pBuf,
24304 static int seekAndWrite(unixFile *id, i64 offset, const void *pBuf, int cnt){
24340 const void *pBuf,
24647 static int proxyFileControl(sqlite3_file*,int,void*);
24654 static int unixFileControl(sqlite3_file *id, int op, void *pArg){
24736 ** directly at the finder-function since C90 rules prevent a void*
25040 pNew->lockingContext = (void*)zFilename;
25654 static void *unixDlOpen(sqlite3_vfs *NotUsed, const char *zFilename){
25666 static void unixDlError(sqlite3_vfs *NotUsed, int nBuf, char *zBufOut){
25676 static void (*unixDlSym(sqlite3_vfs *NotUsed, void *p, const char*zSym))(void){
25678 ** GCC with -pedantic-errors says that C90 does not allow a void* to be
25680 ** returns a void* which is really a pointer to a function. So how do we
25684 ** parameters void* and const char* and returning a pointer to a function.
25690 ** you really cannot cast a function pointer into void*. But then, on the
25694 void (*(*x)(void*,const char*))(void);
25696 x = (void(*(*)(void*,const char*))(void))dlsym;
25699 static void unixDlClose(sqlite3_vfs *NotUsed, void *pHandle){
26021 void *oldLockingContext; /* Original lockingcontext to restore on close */
26076 static void proxyGetHostIDPath(char *path, size_t len){
26225 dummyVfs.pAppData = (void*)&autolockIoFinder;
26592 static int proxyFileControl(sqlite3_file *id, int op, void *pArg){
26794 SQLITE_API int sqlite3_os_init(void){
26799 ** silly C90 rules prohibit a void* from being cast to a function pointer
26821 (void*)&FINDER, /* pAppData */ \
26882 SQLITE_API int sqlite3_os_end(void){
27044 __inline__ sqlite_uint64 sqlite3Hwtime(void){
27052 __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){
27063 __inline__ sqlite_uint64 sqlite3Hwtime(void){
27071 __inline__ sqlite_uint64 sqlite3Hwtime(void){
27095 SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }
27133 static void local_ioerr(){
27260 static int isNT(void){
27442 static void winceMutexAcquire(HANDLE h){
27532 static void winceDestroyLock(winFile *pFile){
27775 void *pBuf, /* Write content into this buffer */
27813 const void *pBuf, /* The bytes to be written */
28211 static int winFileControl(sqlite3_file *id, int op, void *pArg){
28280 static void *convertUtf8Filename(const char *zFilename){
28281 void *zConverted = 0;
28432 void *zConverted; /* Filename in OS encoding */
28582 void *zConverted = convertUtf8Filename(zFilename);
28627 void *zConverted = convertUtf8Filename(zFilename);
28687 void *zConverted;
28759 void *zConverted = convertUtf8Filename(zFullpath);
28809 static void *winDlOpen(sqlite3_vfs *pVfs, const char *zFilename){
28811 void *zConverted = convertUtf8Filename(zFilename);
28828 return (void*)h;
28830 static void winDlError(sqlite3_vfs *pVfs, int nBuf, char *zBufOut){
28834 void (*winDlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol))(void){
28838 return (void(*)(void))GetProcAddressA((HANDLE)pHandle, zSymbol);
28842 return (void(*)(void))GetProcAddress((HANDLE)pHandle, zSymbol);
28845 void winDlClose(sqlite3_vfs *pVfs, void *pHandle){
29001 SQLITE_API int sqlite3_os_init(void){
29027 SQLITE_API int sqlite3_os_end(void){
29073 #define BITVEC_SZ (sizeof(void*)*128) /* 512 on 32bit. 1024 on 64bit */
29269 SQLITE_PRIVATE void sqlite3BitvecClear(Bitvec *p, u32 i, void *pBuf){
29306 SQLITE_PRIVATE void sqlite3BitvecDestroy(Bitvec *p){
29371 void *pTmpSpace;
29470 int (*xStress)(void*,PgHdr*); /* Call to try make a page clean */
29471 void *pStress; /* Argument to xStress */
29510 static void pcacheRemoveFromDirtyList(PgHdr *pPage){
29547 static void pcacheAddToDirtyList(PgHdr *pPage){
29571 static void pcacheUnpin(PgHdr *p){
29586 SQLITE_PRIVATE int sqlite3PcacheInitialize(void){
29592 SQLITE_PRIVATE void sqlite3PcacheShutdown(void){
29601 SQLITE_PRIVATE int sqlite3PcacheSize(void){ return sizeof(PCache); }
29609 SQLITE_PRIVATE void sqlite3PcacheOpen(
29613 int (*xStress)(void*,PgHdr*),/* Call to try to make pages clean */
29614 void *pStress, /* Argument to xStress */
29630 SQLITE_PRIVATE void sqlite3PcacheSetPageSize(PCache *pCache, int szPage){
29705 pPage->pExtra = (void*)&pPage[1];
29706 pPage->pData = (void *)&((char *)pPage)[sizeof(PgHdr) + pCache->szExtra];
29712 assert( pPage->pExtra==(void *)&pPage[1] );
29730 SQLITE_PRIVATE void sqlite3PcacheRelease(PgHdr *p){
29749 SQLITE_PRIVATE void sqlite3PcacheRef(PgHdr *p){
29759 SQLITE_PRIVATE void sqlite3PcacheDrop(PgHdr *p){
29777 SQLITE_PRIVATE void sqlite3PcacheMakeDirty(PgHdr *p){
29790 SQLITE_PRIVATE void sqlite3PcacheMakeClean(PgHdr *p){
29803 SQLITE_PRIVATE void sqlite3PcacheCleanAll(PCache *pCache){
29813 SQLITE_PRIVATE void sqlite3PcacheClearSyncFlags(PCache *pCache){
29824 SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr *p, Pgno newPgno){
29845 SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache *pCache, Pgno pgno){
29867 SQLITE_PRIVATE void sqlite3PcacheClose(PCache *pCache){
29876 SQLITE_PRIVATE void sqlite3PcacheClear(PCache *pCache){
29998 SQLITE_PRIVATE void sqlite3PcacheSetCachesize(PCache *pCache, int mxPage){
30011 SQLITE_PRIVATE void sqlite3PcacheIterateDirty(PCache *pCache, void (*xIter)(PgHdr *)){
30106 void *pStart, *pEnd; /* Bounds of pagecache malloc range */
30130 #define PGHDR1_TO_PAGE(p) (void*)(((char*)p) - p->pCache->szPage)
30148 SQLITE_PRIVATE void sqlite3PCacheBufferSetup(void *pBuf, int sz, int n){
30159 pBuf = (void*)&((char*)pBuf)[sz];
30171 static void *pcache1Alloc(int nByte){
30172 void *p;
30202 static void pcache1Free(void *p){
30223 void *pPg = pcache1Alloc(nByte);
30243 static void pcache1FreePage(PgHdr1 *p){
30257 SQLITE_PRIVATE void *sqlite3PageMalloc(int sz){
30258 void *p;
30268 SQLITE_PRIVATE void sqlite3PageFree(void *p){
30327 static void pcache1PinPage(PgHdr1 *pPage){
30355 static void pcache1RemoveFromHash(PgHdr1 *pPage){
30371 static void pcache1EnforceMaxPage(void){
30388 static void pcache1TruncateUnsafe(
30419 static int pcache1Init(void *NotUsed){
30435 static void pcache1Shutdown(void *NotUsed){
30469 static void pcache1Cachesize(sqlite3_pcache *p, int nMax){
30540 static void *pcache1Fetch(sqlite3_pcache *p, unsigned int iKey, int createFlag){
30603 *(void **)(PGHDR1_TO_PAGE(pPage)) = 0;
30622 static void pcache1Unpin(sqlite3_pcache *p, void *pPg, int reuseUnlikely){
30661 static void pcache1Rekey(
30663 void *pPg,
30701 static void pcache1Truncate(sqlite3_pcache *p, unsigned int iLimit){
30716 static void pcache1Destroy(sqlite3_pcache *p){
30733 SQLITE_PRIVATE void sqlite3PCacheSetDefault(void){
30782 SQLITE_PRIVATE void sqlite3PcacheStats(
30926 SQLITE_PRIVATE RowSet *sqlite3RowSetInit(sqlite3 *db, void *pSpace, unsigned int N){
30947 SQLITE_PRIVATE void sqlite3RowSetClear(RowSet *p){
30967 SQLITE_PRIVATE void sqlite3RowSetInsert(RowSet *p, i64 rowid){
31041 static void rowSetSort(RowSet *p){
31073 static void rowSetTreeToList(
31162 static void rowSetToList(RowSet *p){
31522 int (*xBusyHandler)(void*); /* Function to call when busy */
31523 void *pBusyHandlerArg; /* Context argument for xBusyHandler */
31528 void (*xReiniter)(DbPage*); /* Call this routine when reloading pages */
31530 void *(*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */
31531 void (*xCodecSizeChng)(void*,int,int); /* Notify of page size changes */
31532 void (*xCodecFree)(void*); /* Destructor for the codec */
31533 void *pCodec; /* First argument to xCodec... methods */
31776 static void pager_set_pagehash(PgHdr *pPage){
31786 static void checkPage(PgHdr *pPg){
32268 (void)sqlite3PcacheFetch(pPager->pPCache, pgno, 0, &p);
32278 static void pager_reset(Pager *pPager){
32291 static void releaseAllSavepoints(Pager *pPager){
32335 static void pager_unlock(Pager *pPager){
32428 static void pagerUnlockAndRollback(Pager *pPager){
32780 void *pData;
33011 static void setSectorSize(Pager *pPager){
33401 SQLITE_PRIVATE void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){
33432 SQLITE_PRIVATE void sqlite3PagerSetSafetyLevel(Pager *pPager, int level, int bFullFsync){
33503 SQLITE_PRIVATE void sqlite3PagerSetBusyhandler(
33505 int (*xBusyHandler)(void *), /* Pointer to busy-handler function */
33506 void *pBusyHandlerArg /* Argument to pass to xBusyHandler */
33517 static void pagerReportSize(Pager *pPager){
33595 SQLITE_PRIVATE void *sqlite3PagerTempSpace(Pager *pPager){
33626 void disable_simulated_io_errors(void){
33630 void enable_simulated_io_errors(void){
33804 static void assertTruncateConstraintCb(PgHdr *pPg){
33808 static void assertTruncateConstraint(Pager *pPager){
33821 SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){
33892 SQLITE_PRIVATE void sqlite3PagerRef(DbPage *pPg){
34164 void *pData = pPg->pData;
34189 ** (cast as a void*). The pager is always 'purgeable' (not an in-memory
34205 static int pagerStress(void *p, PgHdr *pPg){
34329 void (*xReinit)(DbPage*) /* Function to reinitialize pages */
34521 !memDb?pagerStress:0, (void *)pPager, pPager->pPCache);
34659 rc = sqlite3OsRead(pPager->jfd, (void *)&first, 1, 0);
34949 static void pagerUnlockIfUnused(Pager *pPager){
35148 SQLITE_PRIVATE void sqlite3PagerUnref(DbPage *pPg){
35359 void *pData = pPg->pData;
35627 SQLITE_PRIVATE void sqlite3PagerDontWrite(PgHdr *pPg){
35705 const void *zBuf = pPgHdr->pData;
36278 static void sqlite3PagerSetCodec(
36280 void *(*xCodec)(void*,void*,Pgno,int),
36281 void (*xCodecSizeChng)(void*,int,int),
36282 void (*xCodecFree)(void*),
36283 void *pCodec
36292 static void *sqlite3PagerGetCodec(Pager *pPager){
36459 SQLITE_PRIVATE void *sqlite3PagerGetData(DbPage *pPg){
36468 SQLITE_PRIVATE void *sqlite3PagerGetExtra(DbPage *pPg){
37003 void *pSchema; /* Pointer to space allocated by sqlite3BtreeSchema() */
37004 void (*xFreeSchema)(void*); /* Destructor for BtShared.pSchema */
37072 void *pKey; /* Saved key that was cursor's last known position */
37231 static void lockBtreeMutex(Btree *p){
37245 static void unlockBtreeMutex(Btree *p){
37271 SQLITE_PRIVATE void sqlite3BtreeEnter(Btree *p){
37333 SQLITE_PRIVATE void sqlite3BtreeLeave(Btree *p){
37367 SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor *pCur){
37370 SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor *pCur){
37390 SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3 *db){
37418 SQLITE_PRIVATE void sqlite3BtreeLeaveAll(sqlite3 *db){
37471 SQLITE_PRIVATE void sqlite3BtreeMutexArrayInsert(BtreeMutexArray *pArray, Btree *pBtree){
37504 SQLITE_PRIVATE void sqlite3BtreeMutexArrayEnter(BtreeMutexArray *pArray){
37529 SQLITE_PRIVATE void sqlite3BtreeMutexArrayLeave(BtreeMutexArray *pArray){
37549 SQLITE_PRIVATE void sqlite3BtreeEnter(Btree *p){
37552 SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3 *db){
37913 static void clearAllSharedCacheTableLocks(Btree *p){
37958 static void downgradeAllSharedCacheTableLocks(Btree *p){
37974 static void releasePage(MemPage *pPage); /* Forward reference */
37992 static void invalidateOverflowCache(BtCursor *pCur){
38002 static void invalidateAllOverflowCache(BtShared *pBt){
38023 static void invalidateIncrblobCursors(
38114 static void btreeClearHasContent(BtShared *pBt){
38143 void *pKey = sqlite3Malloc( (int)pCur->nKey );
38195 SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *pCur){
38209 const void *pKey, /* Packed key if the btree is an index */
38315 static void ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent, int *pRC){
38439 static void btreeParseCellPtr(
38512 static void btreeParseCell(
38593 static void ptrmapPutOvflPtr(MemPage *pPage, u8 *pCell, int *pRC){
39039 static void zeroPage(MemPage *pPage, int flags){
39046 assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
39179 static void releasePage(MemPage *pPage){
39183 assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
39198 static void pageReinit(DbPage *pData){
39220 static int btreeInvokeBusyHandler(void *pArg){
39518 static void allocateTempSpace(BtShared *pBt){
39527 static void freeTempSpace(BtShared *pBt){
39896 static void unlockBtreeIfUnused(BtShared *pBt){
40557 static void btreeEndTransaction(Btree *p){
40683 SQLITE_PRIVATE void sqlite3BtreeTripAllCursors(Btree *pBtree, int errCode){
40924 SQLITE_PRIVATE int sqlite3BtreeCursorSize(void){
40936 SQLITE_PRIVATE void sqlite3BtreeCursorZero(BtCursor *p){
40952 SQLITE_PRIVATE void sqlite3BtreeSetCachedRowid(BtCursor *pCur, sqlite3_int64 iRowid){
41016 static void assertCellInfo(BtCursor *pCur){
41028 static void getCellInfo(BtCursor *pCur){
41093 ** It might just as well be a procedure (returning void) but we continue
41192 void *pPayload, /* Pointer to page data */
41193 void *pBuf, /* Pointer to buffer */
41384 SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
41401 SQLITE_PRIVATE int sqlite3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
41492 SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor *pCur, int *pAmt){
41493 const void *p = 0;
41497 p = (const void*)fetchPayload(pCur, pAmt, 0);
41501 SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor *pCur, int *pAmt){
41502 const void *p = 0;
41506 p = (const void*)fetchPayload(pCur, pAmt, 1);
41555 static void assertParentIndex(MemPage *pParent, int iIdx, Pgno iChild){
41575 static void moveToParent(BtCursor *pCur){
41925 c = sqlite3VdbeRecordCompare(nCell, (void*)&pCell[1], pIdxKey);
41931 c = sqlite3VdbeRecordCompare(nCell, (void*)&pCell[2], pIdxKey);
41937 void *pCellKey;
42570 static void freePage(MemPage *pPage, int *pRC){
42635 const void *pKey, i64 nKey, /* The key */
42636 const void *pData,int nData, /* The data */
42790 static void dropCell(MemPage *pPage, int idx, int sz, int *pRC){
42845 static void insertCell(
42932 static void assemblePage(
43147 static void copyNodeContent(MemPage *pFrom, MemPage *pTo, int *pRC){
43402 pOld->aData = (void*)&pOld[1];
44039 const void *pKey, i64 nKey, /* The key of the new record */
44040 const void *pData, int nData, /* The data of the new record */
44658 SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *p, int idx, u32 *pMeta){
44788 static void checkAppendMsg(
44841 static void checkPtrmap(
44871 static void checkList(
45302 SQLITE_PRIVATE void *sqlite3BtreeSchema(Btree *p, int nBytes, void(*xFree)(void *)){
45365 SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor *pCsr, u32 offset, u32 amt, void *z){
45408 SQLITE_PRIVATE void sqlite3BtreeCacheOverflow(BtCursor *pCur){
45692 static void attachBackupObject(sqlite3_backup *p){
45963 SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *pBackup, Pgno iPage, const u8 *aData){
45992 SQLITE_PRIVATE void sqlite3BackupRestart(sqlite3_backup *pBackup){
46146 pMem->xDel((void *)(pMem->z));
46314 SQLITE_PRIVATE void sqlite3VdbeMemReleaseExternal(Mem *p){
46327 p->xDel((void *)p->z);
46342 SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p){
46456 SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem *pMem){
46533 SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem *pMem){
46548 SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){
46570 SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){
46581 SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem *pMem, double val){
46596 SQLITE_PRIVATE void sqlite3VdbeMemSetRowSet(Mem *pMem){
46640 SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
46680 SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){
46712 void (*xDel)(void*) /* Destructor function */
46876 const void *v1, *v2;
46976 SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value* pVal, u8 enc){
47113 SQLITE_PRIVATE void sqlite3ValueSetStr(
47116 const void *z, /* Text of the new string */
47118 void (*xDel)(void*) /* Destructor for the string */
47126 SQLITE_PRIVATE void sqlite3ValueFree(sqlite3_value *v){
47200 SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe *p, const char *z, int n, int isPrepareV2){
47222 SQLITE_PRIVATE void sqlite3VdbeSwap(Vdbe *pA, Vdbe *pB){
47244 SQLITE_PRIVATE void sqlite3VdbeTrace(Vdbe *p, FILE *trace){
47396 SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe *p, int x){
47539 static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs){
47654 SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe *p, int addr, int val){
47666 SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe *p, int addr, int val){
47677 SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe *p, int addr, int val){
47689 SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe *p, u8 val){
47701 SQLITE_PRIVATE void sqlite3VdbeJumpHere(Vdbe *p, int addr){
47710 static void freeEphemeralFunction(sqlite3 *db, FuncDef *pDef){
47719 static void freeP4(sqlite3 *db, int p4type, void *p4){
47764 static void vdbeFreeOpArray(sqlite3 *db, Op *aOp, int nOp){
47790 SQLITE_PRIVATE void sqlite3VdbeProgramDelete(sqlite3 *db, SubProgram *p, int freeop){
47810 SQLITE_PRIVATE void sqlite3VdbeChangeToNoop(Vdbe *p, int addr, int N){
47848 SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe *p, int addr, const char *zP4, int n){
47856 freeP4(db, n, (void*)*(char**)&zP4);
47898 pOp->p4.p = (void*)zP4;
47901 pOp->p4.p = (void*)zP4;
47906 pOp->p4.p = (void*)zP4;
47922 SQLITE_PRIVATE void sqlite3VdbeComment(Vdbe *p, const char *zFormat, ...){
47935 SQLITE_PRIVATE void sqlite3VdbeNoopComment(Vdbe *p, const char *zFormat, ...){
48094 SQLITE_PRIVATE void sqlite3VdbeUsesBtree(Vdbe *p, int i){
48110 SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE *pOut, int pc, Op *pOp){
48131 static void releaseMemArray(Mem *p, int N){
48168 SQLITE_PRIVATE void sqlite3VdbeFrameDelete(VdbeFrame *p){
48384 SQLITE_PRIVATE void sqlite3VdbePrintSql(Vdbe *p){
48401 SQLITE_PRIVATE void sqlite3VdbeIOTraceSql(Vdbe *p){
48448 static void *allocSpace(
48449 void *pBuf, /* Where return pointer will be stored */
48459 pBuf = (void*)*ppFrom;
48484 SQLITE_PRIVATE void sqlite3VdbeMakeReady(
48608 SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *p, VdbeCursor *pCx){
48624 (void)sqlite3SafetyOff(p->db);
48626 (void)sqlite3SafetyOn(p->db);
48658 static void closeAllCursors(Vdbe *p){
48689 static void Cleanup(Vdbe *p){
48711 SQLITE_PRIVATE void sqlite3VdbeSetNumCols(Vdbe *p, int nResColumn){
48744 void (*xDel)(void*) /* Memory management strategy for zName */
48807 (void)sqlite3SafetyOff(db);
48809 (void)sqlite3SafetyOn(db);
48995 static void checkActiveVdbeCnt(sqlite3 *db){
49030 static void invalidateCursorsOnModifiedBtrees(sqlite3 *db){
49113 SQLITE_PRIVATE void sqlite3VdbeMutexArrayEnter(Vdbe *p){
49340 SQLITE_PRIVATE void sqlite3VdbeResetStepResult(Vdbe *p){
49363 (void)sqlite3SafetyOn(db);
49365 (void)sqlite3SafetyOff(db);
49448 SQLITE_PRIVATE void sqlite3VdbeDeleteAuxData(VdbeFunc *pVdbeFunc, int mask){
49464 SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe *p){
49857 const void *pKey, /* The binary record */
49909 return (void*)p;
49915 SQLITE_PRIVATE void sqlite3VdbeDeleteUnpackedRecord(UnpackedRecord *p){
49961 int nKey1, const void *pKey1, /* Left key */
50097 (void)getVarint32((u8*)m.z, szHdr);
50106 (void)getVarint32((u8*)&m.z[szHdr-1], typeRowid);
50183 SQLITE_PRIVATE void sqlite3VdbeSetChanges(sqlite3 *db, int nChange){
50193 SQLITE_PRIVATE void sqlite3VdbeCountChanges(Vdbe *v){
50207 SQLITE_PRIVATE void sqlite3ExpirePreparedStatements(sqlite3 *db){
50251 SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe *v, int iVar){
50371 SQLITE_API const void *sqlite3_value_blob(sqlite3_value *pVal){
50401 SQLITE_API const void *sqlite3_value_text16(sqlite3_value* pVal){
50404 SQLITE_API const void *sqlite3_value_text16be(sqlite3_value *pVal){
50407 SQLITE_API const void *sqlite3_value_text16le(sqlite3_value *pVal){
50423 static void setResultStrOrError(
50428 void (*xDel)(void*) /* Destructor function */
50434 SQLITE_API void sqlite3_result_blob(
50436 const void *z,
50438 void (*xDel)(void *)
50444 SQLITE_API void sqlite3_result_double(sqlite3_context *pCtx, double rVal){
50448 SQLITE_API void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){
50454 SQLITE_API void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){
50460 SQLITE_API void sqlite3_result_int(sqlite3_context *pCtx, int iVal){
50464 SQLITE_API void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){
50468 SQLITE_API void sqlite3_result_null(sqlite3_context *pCtx){
50472 SQLITE_API void sqlite3_result_text(
50476 void (*xDel)(void *)
50482 SQLITE_API void sqlite3_result_text16(
50484 const void *z,
50486 void (*xDel)(void *)
50491 SQLITE_API void sqlite3_result_text16be(
50493 const void *z,
50495 void (*xDel)(void *)
50500 SQLITE_API void sqlite3_result_text16le(
50502 const void *z,
50504 void (*xDel)(void *)
50510 SQLITE_API void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){
50514 SQLITE_API void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){
50518 SQLITE_API void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
50527 SQLITE_API void sqlite3_result_error_toobig(sqlite3_context *pCtx){
50535 SQLITE_API void sqlite3_result_error_nomem(sqlite3_context *pCtx){
50699 SQLITE_API void *sqlite3_user_data(sqlite3_context *p){
50721 SQLITE_PRIVATE void sqlite3InvalidFunction(
50740 SQLITE_API void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){
50760 return (void*)pMem->z;
50767 SQLITE_API void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){
50783 SQLITE_API void sqlite3_set_auxdata(
50786 void *pAux,
50787 void (*xDelete)(void*)
50919 static void columnMallocFailure(sqlite3_stmt *pStmt)
50937 SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){
50938 const void *val;
50987 SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){
50988 const void *val = sqlite3_value_text16( columnMem(pStmt,i) );
51022 static const void *columnName(
51025 const void *(*xFunc)(Mem*),
51028 const void *ret = 0;
51058 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_NAME);
51061 SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){
51063 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_NAME);
51083 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DECLTYPE);
51086 SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){
51088 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DECLTYPE);
51101 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DATABASE);
51104 SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){
51106 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DATABASE);
51117 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_TABLE);
51120 SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){
51122 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_TABLE);
51133 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_COLUMN);
51136 SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){
51138 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_COLUMN);
51196 const void *zData, /* Pointer to the data to be bound */
51198 void (*xDel)(void*), /* Destructor for the data */
51228 const void *zData,
51230 void (*xDel)(void*)
51271 void (*xDel)(void*)
51279 const void *zData,
51281 void (*xDel)(void*)
51342 static void createVarMap(Vdbe *p){
51721 static void updateMaxBlobsize(Mem *p){
51784 SQLITE_PRIVATE void sqlite3VdbeMemStoreType(Mem *pMem){
51868 static void applyNumericAffinity(Mem *pRec){
51904 static void applyAffinity(
51947 SQLITE_PRIVATE void sqlite3ValueApplyAffinity(
51960 SQLITE_PRIVATE void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf){
52042 static void memTracePrint(FILE *out, Mem *p){
52062 static void registerTrace(FILE *out, int iReg, Mem *p){
52113 __inline__ sqlite_uint64 sqlite3Hwtime(void){
52121 __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){
52132 __inline__ sqlite_uint64 sqlite3Hwtime(void){
52140 __inline__ sqlite_uint64 sqlite3Hwtime(void){
52164 SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }
52598 void *t; /* Token identifying trigger */
56790 (void)sqlite3SafetyOff(db);
56799 (void)sqlite3SafetyOn(db);
57052 void *t; /* Token identifying trigger */
58143 (void)sqlite3SafetyOff(db);
58158 (void)sqlite3SafetyOff(db);
58199 (void)sqlite3SafetyOff(db);
58341 void *z,
58344 int (*xCall)(BtCursor*, u32, u32, void*)
58389 SQLITE_API int sqlite3_blob_read(sqlite3_blob *pBlob, void *z, int n, int iOffset){
58396 SQLITE_API int sqlite3_blob_write(sqlite3_blob *pBlob, const void *z, int n, int iOffset){
58397 return blobReadWrite(pBlob, (void *)z, n, iOffset, sqlite3BtreePutData);
58497 void *zBuf, /* Put the results here */
58518 const void *zBuf, /* Take data to be written from here */
58723 void *zBuf, /* Put the results here */
58768 const void *zBuf, /* Take data to be written from here */
58885 SQLITE_PRIVATE void sqlite3MemJournalOpen(sqlite3_file *pJfd){
58904 SQLITE_PRIVATE int sqlite3MemJournalSize(void){
59090 static void resolveAlias(
59743 static void resolveOutOfRangeError(
60225 SQLITE_PRIVATE void sqlite3ResolveSelectNames(
60489 (void*)p4, P4_COLLSEQ);
60525 static void heightOfExpr(Expr *p, int *pnHeight){
60532 static void heightOfExprList(ExprList *p, int *pnHeight){
60540 static void heightOfSelect(Select *p, int *pnHeight){
60560 static void exprSetHeight(Expr *p){
60577 SQLITE_PRIVATE void sqlite3ExprSetHeight(Parse *pParse, Expr *p){
60679 SQLITE_PRIVATE void sqlite3ExprAttachSubtrees(
60778 SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr){
60848 SQLITE_PRIVATE void sqlite3ExprDelete(sqlite3 *db, Expr *p){
61255 SQLITE_PRIVATE void sqlite3ExprListSetName(
61280 SQLITE_PRIVATE void sqlite3ExprListSetSpan(
61301 SQLITE_PRIVATE void sqlite3ExprListCheckLength(
61317 SQLITE_PRIVATE void sqlite3ExprListDelete(sqlite3 *db, ExprList *pList){
61505 SQLITE_PRIVATE void sqlite3ExprCodeIsNullJump(
61938 sqlite3VdbeChangeP4(v, addr, (void *)&keyInfo, P4_KEYINFO);
62010 static void sqlite3ExprCodeIN(
62133 static void codeReal(Vdbe *v, const char *z, int negateFlag, int iMem){
62154 static void codeInteger(Vdbe *v, Expr *pExpr, int negFlag, int iMem){
62178 static void cacheEntryClear(Parse *pParse, struct yColCache *p){
62192 SQLITE_PRIVATE void sqlite3ExprCacheStore(Parse *pParse, int iTab, int iCol, int iReg){
62265 SQLITE_PRIVATE void sqlite3ExprCacheRemove(Parse *pParse, int iReg, int nReg){
62283 SQLITE_PRIVATE void sqlite3ExprCachePush(Parse *pParse){
62292 SQLITE_PRIVATE void sqlite3ExprCachePop(Parse *pParse, int N){
62312 static void sqlite3ExprCachePinRegister(Parse *pParse, int iReg){
62364 SQLITE_PRIVATE void sqlite3ExprCacheClear(Parse *pParse){
62380 SQLITE_PRIVATE void sqlite3ExprCacheAffinityChange(Parse *pParse, int iStart, int iCount){
62388 SQLITE_PRIVATE void sqlite3ExprCodeMove(Parse *pParse, int iFrom, int iTo, int nReg){
62405 SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse *pParse, int iFrom, int iTo, int nReg){
62437 SQLITE_PRIVATE void sqlite3ExprHardCopy(Parse *pParse, int iReg, int nReg){
63292 SQLITE_PRIVATE void sqlite3ExprCodeConstants(Parse *pParse, Expr *pExpr){
63347 static void exprCodeBetween(
63405 SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
63523 SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
63896 SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
63911 SQLITE_PRIVATE void sqlite3ExprAnalyzeAggList(NameContext *pNC, ExprList *pList){
63939 SQLITE_PRIVATE void sqlite3ReleaseTempReg(Parse *pParse, int iReg){
63970 SQLITE_PRIVATE void sqlite3ReleaseTempRange(Parse *pParse, int iReg, int nReg){
64015 static void renameTableFunc(
64080 static void renameParentFunc(
64135 static void renameTriggerFunc(
64207 SQLITE_PRIVATE void sqlite3AlterFunctions(sqlite3 *db){
64299 static void reloadTableSchema(Parse *pParse, Table *pTab, const char *zName){
64344 SQLITE_PRIVATE void sqlite3AlterRenameTable(
64544 SQLITE_PRIVATE void sqlite3MinimumFileFormat(Parse *pParse, int iDb, int minFormat){
64573 SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){
64694 SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){
64806 static void openStatTable(
64876 static void analyzeOneTable(
65101 static void loadAnalysis(Parse *pParse, int iDb){
65111 static void analyzeDatabase(Parse *pParse, int iDb){
65134 static void analyzeTable(Parse *pParse, Table *pTab){
65161 SQLITE_PRIVATE void sqlite3Analyze(Parse *pParse, Token *pName1, Token *pName2){
65232 static int analysisLoader(void *pData, int argc, char **argv, char **NotUsed){
65266 SQLITE_PRIVATE void sqlite3DeleteIndexSamples(Index *pIdx){
65335 (void)sqlite3SafetyOff(db);
65337 (void)sqlite3SafetyOn(db);
65355 (void)sqlite3SafetyOff(db);
65357 (void)sqlite3SafetyOn(db);
65362 (void)sqlite3SafetyOff(db);
65412 (void)sqlite3SafetyOn(db);
65489 static void attachFunc(
65579 extern int sqlite3CodecAttach(sqlite3*, int, const void*, int);
65580 extern void sqlite3CodecGetKey(sqlite3*, int, void**, int*);
65600 sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);
65613 (void)sqlite3SafetyOn(db);
65617 (void)sqlite3SafetyOff(db);
65658 static void detachFunc(
65710 static void codeAttach(
65782 SQLITE_PRIVATE void sqlite3Detach(Parse *pParse, Expr *pDbname){
65803 SQLITE_PRIVATE void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){
66035 int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
66036 void *pArg
66050 static void sqliteAuthBadReturnCode(Parse *pParse){
66097 SQLITE_PRIVATE void sqlite3AuthRead(
66190 SQLITE_PRIVATE void sqlite3AuthContextPush(
66205 SQLITE_PRIVATE void sqlite3AuthContextPop(AuthContext *pContext){
66245 SQLITE_PRIVATE void sqlite3BeginParse(Parse *pParse, int explainFlag){
66272 SQLITE_PRIVATE void sqlite3TableLock(
66312 static void codeTableLocks(Parse *pParse){
66340 SQLITE_PRIVATE void sqlite3FinishCoding(Parse *pParse){
66442 SQLITE_PRIVATE void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){
66562 static void freeIndex(Index *p){
66579 static void sqlite3DeleteIndex(Index *p){
66595 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){
66631 SQLITE_PRIVATE void sqlite3ResetInternalSchema(sqlite3 *db, int iDb){
66681 SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3 *db){
66688 static void sqliteResetColumnNames(Table *pTable){
66717 SQLITE_PRIVATE void sqlite3DeleteTable(Table *pTable){
66760 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){
66803 SQLITE_PRIVATE void sqlite3OpenMasterTable(Parse *p, int iDb){
66928 SQLITE_PRIVATE void sqlite3StartTable(
67145 SQLITE_PRIVATE void sqlite3AddColumn(Parse *pParse, Token *pName){
67194 SQLITE_PRIVATE void sqlite3AddNotNull(Parse *pParse, int onError){
67271 SQLITE_PRIVATE void sqlite3AddColumnType(Parse *pParse, Token *pType){
67293 SQLITE_PRIVATE void sqlite3AddDefaultValue(Parse *pParse, ExprSpan *pSpan){
67336 SQLITE_PRIVATE void sqlite3AddPrimaryKey(
67400 SQLITE_PRIVATE void sqlite3AddCheckConstraint(
67420 SQLITE_PRIVATE void sqlite3AddCollateType(Parse *pParse, Token *pToken){
67505 SQLITE_PRIVATE void sqlite3ChangeCookie(Parse *pParse, int iDb){
67543 static void identPut(char *z, int *pIdx, char *zSignedIdent){
67655 SQLITE_PRIVATE void sqlite3EndTable(
67861 SQLITE_PRIVATE void sqlite3CreateView(
67947 int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
68035 static void sqliteViewResetAll(sqlite3 *db, int idx){
68068 SQLITE_PRIVATE void sqlite3RootPageMoved(Db *pDb, int iFrom, int iTo){
68095 static void destroyRootPage(Parse *pParse, int iTable, int iDb){
68123 static void destroyTable(Parse *pParse, Table *pTab){
68180 SQLITE_PRIVATE void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, int noErr){
68358 SQLITE_PRIVATE void sqlite3CreateForeignKey(
68447 pFKey->zTo, sqlite3Strlen30(pFKey->zTo), (void *)pFKey
68478 SQLITE_PRIVATE void sqlite3DeferForeignKey(Parse *pParse, int isDeferred){
68499 static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){
68543 void * const pRegKey = SQLITE_INT_TO_PTR(regIdxKey);
69065 SQLITE_PRIVATE void sqlite3DefaultRowEst(Index *pIdx){
69086 SQLITE_PRIVATE void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists){
69169 SQLITE_PRIVATE void *sqlite3ArrayAllocate(
69171 void *pArray, /* Array of objects. Might be reallocated */
69180 void *pNew;
69231 SQLITE_PRIVATE void sqlite3IdListDelete(sqlite3 *db, IdList *pList){
69390 SQLITE_PRIVATE void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){
69408 SQLITE_PRIVATE void sqlite3SrcListDelete(sqlite3 *db, SrcList *pList){
69485 SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy){
69515 SQLITE_PRIVATE void sqlite3SrcListShiftJoinType(SrcList *p){
69528 SQLITE_PRIVATE void sqlite3BeginTransaction(Parse *pParse, int type){
69554 SQLITE_PRIVATE void sqlite3CommitTransaction(Parse *pParse){
69574 SQLITE_PRIVATE void sqlite3RollbackTransaction(Parse *pParse){
69595 SQLITE_PRIVATE void sqlite3Savepoint(Parse *pParse, int op, Token *pName){
69663 SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse *pParse, int iDb){
69702 SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){
69716 SQLITE_PRIVATE void sqlite3MultiWrite(Parse *pParse){
69737 SQLITE_PRIVATE void sqlite3MayAbort(Parse *pParse){
69747 SQLITE_PRIVATE void sqlite3HaltConstraint(Parse *pParse, int onError, char *p4, int p4type){
69779 static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){
69798 static void reindexDatabases(Parse *pParse, char const *zColl){
69829 SQLITE_PRIVATE void sqlite3Reindex(Parse *pParse, Token *pName1, Token *pName2){
69943 static void callCollNeeded(sqlite3 *db, int enc, const char *zName){
70203 SQLITE_PRIVATE void sqlite3FuncDefInsert(
70316 ** Free all resources held by the schema structure. The void* argument points
70323 SQLITE_PRIVATE void sqlite3SchemaFree(void *p){
70452 SQLITE_PRIVATE void sqlite3MaterializeView(
70586 SQLITE_PRIVATE void sqlite3DeleteFrom(
70841 SQLITE_PRIVATE void sqlite3GenerateRowDelete(
70949 SQLITE_PRIVATE void sqlite3GenerateRowIndexDelete(
71041 static void minmaxFunc(
71071 static void typeofFunc(
71092 static void lengthFunc(
71132 static void absFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
71182 static void substrFunc(
71268 static void roundFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
71299 static void *contextMalloc(sqlite3_context *context, i64 nByte){
71320 static void upperFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
71340 static void lowerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
71374 static void ifnullFunc(
71393 static void randomFunc(
71419 static void randomBlob(
71443 static void last_insert_rowid(
71457 static void changes(
71471 static void total_changes(
71670 static void likeFunc(
71723 static void nullifFunc(
71739 static void versionFunc(
71753 static void sourceidFunc(
71780 static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
71845 static void hexFunc(
71873 static void zeroblobFunc(
71898 static void replaceFunc(
71982 static void trimFunc(
72074 static void soundexFunc(
72127 static void loadExt(sqlite3_context *context, int argc, sqlite3_value **argv){
72169 static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){
72195 static void sumFinalize(sqlite3_context *context){
72208 static void avgFinalize(sqlite3_context *context){
72215 static void totalFinalize(sqlite3_context *context){
72234 static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){
72250 static void countFinalize(sqlite3_context *context){
72259 static void minmaxStep(
72279 ** sqlite3_user_data() function returns (void *)-1. For min() it
72280 ** returns (void *)db, where db is the sqlite3* database pointer.
72293 static void minMaxFinalize(sqlite3_context *context){
72307 static void groupConcatStep(
72340 static void groupConcatFinalize(sqlite3_context *context){
72360 SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(sqlite3 *db){
72376 static void setLikeOptFlag(sqlite3 *db, const char *zName, u8 flagVal){
72390 SQLITE_PRIVATE void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){
72448 SQLITE_PRIVATE void sqlite3RegisterGlobalFunctions(void){
72849 static void fkLookupParent(
72992 static void fkScanChildren(
73128 static void fkTriggerDelete(sqlite3 *dbMem, Trigger *p){
73156 SQLITE_PRIVATE void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTab){
73217 SQLITE_PRIVATE void sqlite3FkCheck(
73665 SQLITE_PRIVATE void sqlite3FkActions(
73693 SQLITE_PRIVATE void sqlite3FkDelete(Table *pTab){
73703 void *data = (void *)pFKey->pNextTo;
73748 SQLITE_PRIVATE void sqlite3OpenTable(
73827 SQLITE_PRIVATE void sqlite3TableAffinityStr(Vdbe *v, Table *pTab){
73951 SQLITE_PRIVATE void sqlite3AutoincrementBegin(Parse *pParse){
73992 static void autoIncStep(Parse *pParse, int memId, int regRowid){
74005 SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse){
74159 SQLITE_PRIVATE void sqlite3Insert(
74865 SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
75136 SQLITE_PRIVATE void sqlite3CompleteInsertion(
75579 void *pArg, /* First argument to xCallback() */
75746 void * (*aggregate_context)(sqlite3_context*,int nBytes);
75748 int (*bind_blob)(sqlite3_stmt*,int,const void*,int n,void(*)(void*));
75756 int (*bind_text)(sqlite3_stmt*,int,const char*,int n,void(*)(void*));
75757 int (*bind_text16)(sqlite3_stmt*,int,const void*,int,void(*)(void*));
75759 int (*busy_handler)(sqlite3*,int(*)(void*,int),void*);
75763 int (*collation_needed)(sqlite3*,void*,void(*)(void*,sqlite3*,int eTextRep,const char*));
75764 int (*collation_needed16)(sqlite3*,void*,void(*)(void*,sqlite3*,int eTextRep,const void*));
75765 const void * (*column_blob)(sqlite3_stmt*,int iCol);
75770 const void * (*column_database_name16)(sqlite3_stmt*,int);
75772 const void * (*column_decltype16)(sqlite3_stmt*,int);
75777 const void * (*column_name16)(sqlite3_stmt*,int);
75779 const void * (*column_origin_name16)(sqlite3_stmt*,int);
75781 const void * (*column_table_name16)(sqlite3_stmt*,int);
75783 const void * (*column_text16)(sqlite3_stmt*,int iCol);
75786 void * (*commit_hook)(sqlite3*,int(*)(void*),void*);
75788 int (*complete16)(const void*sql);
75789 int (*create_collation)(sqlite3*,const char*,int,void*,int(*)(void*,int,const void*,int,const void*));
75790 int (*create_collation16)(sqlite3*,const void*,int,void*,int(*)(void*,int,const void*,int,const void*));
75791 int (*create_function)(sqlite3*,const char*,int,int,void*,void (*xFunc)(sqlite3_context*,int,sqlite3_value**),void (*xStep)(sqlite3_context*,int,sqlite3_value**),void (*xFinal)(sqlite3_context*));
75792 int (*create_function16)(sqlite3*,const void*,int,int,void*,void (*xFunc)(sqlite3_context*,int,sqlite3_value**),void (*xStep)(sqlite3_context*,int,sqlite3_value**),void (*xFinal)(sqlite3_context*));
75793 int (*create_module)(sqlite3*,const char*,const sqlite3_module*,void*);
75800 const void * (*errmsg16)(sqlite3*);
75801 int (*exec)(sqlite3*,const char*,sqlite3_callback,void*,char**);
75804 void (*free)(void*);
75805 void (*free_table)(char**result);
75807 void * (*get_auxdata)(sqlite3_context*,int);
75809 int (*global_recover)(void);
75810 void (*interruptx)(sqlite3*);
75812 const char * (*libversion)(void);
75813 int (*libversion_number)(void);
75814 void *(*malloc)(int);
75817 int (*open16)(const void*,sqlite3**);
75819 int (*prepare16)(sqlite3*,const void*,int,sqlite3_stmt**,const void**);
75820 void * (*profile)(sqlite3*,void(*)(void*,const char*,sqlite_uint64),void*);
75821 void (*progress_handler)(sqlite3*,int,int(*)(void*),void*);
75822 void *(*realloc)(void*,int);
75824 void (*result_blob)(sqlite3_context*,const void*,int,void(*)(void*));
75825 void (*result_double)(sqlite3_context*,double);
75826 void (*result_error)(sqlite3_context*,const char*,int);
75827 void (*result_error16)(sqlite3_context*,const void*,int);
75828 void (*result_int)(sqlite3_context*,int);
75829 void (*result_int64)(sqlite3_context*,sqlite_int64);
75830 void (*result_null)(sqlite3_context*);
75831 void (*result_text)(sqlite3_context*,const char*,int,void(*)(void*));
75832 void (*result_text16)(sqlite3_context*,const void*,int,void(*)(void*));
75833 void (*result_text16be)(sqlite3_context*,const void*,int,void(*)(void*));
75834 void (*result_text16le)(sqlite3_context*,const void*,int,void(*)(void*));
75835 void (*result_value)(sqlite3_context*,sqlite3_value*);
75836 void * (*rollback_hook)(sqlite3*,void(*)(void*),void*);
75837 int (*set_authorizer)(sqlite3*,int(*)(void*,int,const char*,const char*,const char*,const char*),void*);
75838 void (*set_auxdata)(sqlite3_context*,int,void*,void (*)(void*));
75842 void (*thread_cleanup)(void);
75844 void * (*trace)(sqlite3*,void(*xTrace)(void*,const char*),void*);
75846 void * (*update_hook)(sqlite3*,void(*)(void*,int ,char const*,char const*,sqlite_int64),void*);
75847 void * (*user_data)(sqlite3_context*);
75848 const void * (*value_blob)(sqlite3_value*);
75856 const void * (*value_text16)(sqlite3_value*);
75857 const void * (*value_text16be)(sqlite3_value*);
75858 const void * (*value_text16le)(sqlite3_value*);
75865 int (*prepare16_v2)(sqlite3*,const void*,int,sqlite3_stmt**,const void**);
75868 int (*create_module_v2)(sqlite3*,const char*,const sqlite3_module*,void*,void (*xDestroy)(void *));
75874 int (*blob_read)(sqlite3_blob*,void*,int,int);
75875 int (*blob_write)(sqlite3_blob*,const void*,int,int);
75876 int (*create_collation_v2)(sqlite3*,const char*,int,void*,int(*)(void*,int,const void*,int,const void*),void(*)(void*));
75877 int (*file_control)(sqlite3*,const char*,int,void*);
75879 sqlite3_int64 (*memory_used)(void);
75881 void (*mutex_enter)(sqlite3_mutex*);
75882 void (*mutex_free)(sqlite3_mutex*);
75883 void (*mutex_leave)(sqlite3_mutex*);
75887 void (*result_error_nomem)(sqlite3_context*);
75888 void (*result_error_toobig)(sqlite3_context*);
75890 void (*soft_heap_limit)(int);
75894 int (*xthreadsafe)(void);
75895 void (*result_zeroblob)(sqlite3_context*,int);
75896 void (*result_error_code)(sqlite3_context*,int);
75898 void (*randomness)(int,void*);
76422 void *handle;
76425 void **aHandle;
76517 SQLITE_PRIVATE void sqlite3CloseExtensions(sqlite3 *db){
76564 void (**aExt)(void); /* Pointers to the extension init functions */
76587 SQLITE_API int sqlite3_auto_extension(void (*xInit)(void)){
76607 void (**aNew)(void);
76626 SQLITE_API void sqlite3_reset_auto_extension(void){
76648 SQLITE_PRIVATE void sqlite3AutoLoadExtensions(sqlite3 *db){
76827 static void returnSingleInt(Parse *pParse, const char *zLabel, i64 value){
76954 SQLITE_PRIVATE void sqlite3Pragma(
78080 extern void sqlite3_activate_see(const char*);
78086 extern void sqlite3_activate_cerod(const char*);
78141 static void corruptSchema(
78171 SQLITE_PRIVATE int sqlite3InitCallback(void *pInit, int argc, char **argv, char **NotUsed){
78314 (void)sqlite3SafetyOff(db);
78316 (void)sqlite3SafetyOn(db);
78439 (void)sqlite3SafetyOff(db);
78442 int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
78452 (void)sqlite3SafetyOn(db);
78565 static void schemaIsValid(Parse *pParse){
78701 (void)sqlite3SafetyOff(db);
78718 (void)sqlite3SafetyOff(db);
78917 const void *zSql, /* UTF-8 encoded SQL statement. */
78921 const void **pzTail /* OUT: End of parsed string */
78967 const void *zSql, /* UTF-8 encoded SQL statement. */
78970 const void **pzTail /* OUT: End of parsed string */
78979 const void *zSql, /* UTF-8 encoded SQL statement. */
78982 const void **pzTail /* OUT: End of parsed string */
79014 static void clearSelect(sqlite3 *db, Select *p){
79029 SQLITE_PRIVATE void sqlite3SelectDestInit(SelectDest *pDest, int eDest, int iParm){
79091 SQLITE_PRIVATE void sqlite3SelectDelete(sqlite3 *db, Select *p){
79228 static void addWhereTerm(
79287 static void setJoinExpr(Expr *p, int iTable){
79404 static void pushOntoSorter(
79444 static void codeOffset(
79468 static void codeDistinct(
79516 static void selectInnerLoop(
79775 static void generateSortTail(
80016 static void generateColumnTypes(
80056 static void generateColumnNames(
80239 static void selectAddColumnTypeAndCollation(
80344 static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){
81370 static void substExprList(sqlite3*, ExprList*, int, ExprList*);
81371 static void substSelect(sqlite3*, Select *, int, ExprList *);
81418 static void substExprList(
81430 static void substSelect(
82092 pTab->zName = sqlite3MPrintf(db, "sqlite_subquery_%p_", (void*)pTab);
82292 static void sqlite3SelectExpand(Parse *pParse, Select *pSelect){
82348 static void sqlite3SelectAddTypeInfo(Parse *pParse, Select *pSelect){
82371 SQLITE_PRIVATE void sqlite3SelectPrep(
82394 static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){
82426 static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){
82434 (void*)pF->pFunc, P4_FUNCDEF);
82442 static void updateAccumulator(Parse *pParse, AggInfo *pAggInfo){
82483 (void*)pF->pFunc, P4_FUNCDEF);
83198 SQLITE_PRIVATE void sqlite3PrintExpr(Expr *p){
83214 SQLITE_PRIVATE void sqlite3PrintExprList(ExprList *pList){
83223 SQLITE_PRIVATE void sqlite3PrintSelect(Select *p, int indent){
83321 static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
83461 SQLITE_API void sqlite3_free_table(
83495 SQLITE_PRIVATE void sqlite3DeleteTriggerStep(sqlite3 *db, TriggerStep *pTriggerStep){
83555 SQLITE_PRIVATE void sqlite3BeginTrigger(
83728 SQLITE_PRIVATE void sqlite3FinishTrigger(
83929 SQLITE_PRIVATE void sqlite3DeleteTrigger(sqlite3 *db, Trigger *pTrigger){
83947 SQLITE_PRIVATE void sqlite3DropTrigger(Parse *pParse, SrcList *pName, int noErr){
83995 SQLITE_PRIVATE void sqlite3DropTriggerPtr(Parse *pParse, Trigger *pTrigger){
84053 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){
84245 static void transferParseError(Parse *pTo, Parse *pFrom){
84351 pProgram->token = (void *)pTrigger;
84404 SQLITE_PRIVATE void sqlite3CodeRowTriggerDirect(
84475 SQLITE_PRIVATE void sqlite3CodeRowTrigger(
84587 static void updateVirtualTable(
84628 SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i, int iReg){
84656 SQLITE_PRIVATE void sqlite3Update(
85163 static void updateVirtualTable(
85305 SQLITE_PRIVATE void sqlite3Vacuum(Parse *pParse){
85324 void (*saved_xTrace)(void*,const char*); /* Saved db->xTrace */
85380 extern void sqlite3CodecGetKey(sqlite3*, int, void**, int*);
85383 sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);
85573 void *pAux, /* Context pointer for xCreate/xConnect */
85574 void (*xDestroy)(void *) /* Module destructor function */
85590 pDel = (Module *)sqlite3HashInsert(&db->aModule, zCopy, nName, (void*)pMod);
85615 void *pAux /* Context pointer for xCreate/xConnect */
85627 void *pAux, /* Context pointer for xCreate/xConnect */
85628 void (*xDestroy)(void *) /* Module destructor function */
85641 SQLITE_PRIVATE void sqlite3VtabLock(VTable *pVTab){
85662 SQLITE_PRIVATE void sqlite3VtabUnlock(VTable *pVTab){
85675 (void)sqlite3SafetyOff(db);
85677 (void)sqlite3SafetyOn(db);
85749 SQLITE_PRIVATE void sqlite3VtabUnlockList(sqlite3 *db){
85780 SQLITE_PRIVATE void sqlite3VtabClear(Table *p){
85797 static void addModuleArgument(sqlite3 *db, Table *pTable, char *zArg){
85822 SQLITE_PRIVATE void sqlite3VtabBeginParse(
85866 static void addArgumentToVtab(Parse *pParse){
85879 SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){
85961 SQLITE_PRIVATE void sqlite3VtabArgInit(Parse *pParse){
85971 SQLITE_PRIVATE void sqlite3VtabArgExtend(Parse *pParse, Token *p){
85991 int (*xConstruct)(sqlite3*,void*,int,const char*const*,sqlite3_vtab**,char**),
86018 (void)sqlite3SafetyOff(db);
86020 (void)sqlite3SafetyOn(db);
86136 aVTrans = sqlite3DbRealloc(db, (void *)db->aVTrans, nBytes);
86270 (void)sqlite3SafetyOn(db);
86292 static void callFinaliser(sqlite3 *db, int offset){
86431 void (*xFunc)(sqlite3_context*,int,sqlite3_value**) = 0;
86432 void *pArg = 0;
86488 SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){
86760 static void whereClauseInit(
86774 static void whereClauseClear(WhereClause*);
86779 static void whereOrInfoDelete(sqlite3 *db, WhereOrInfo *p){
86787 static void whereAndInfoDelete(sqlite3 *db, WhereAndInfo *p){
86796 static void whereClauseClear(WhereClause *pWC){
86879 static void whereSplit(WhereClause *pWC, Expr *pExpr, int op){
86918 static void createMask(WhereMaskSet *pMaskSet, int iCursor){
87008 static void exprCommute(Parse *pParse, Expr *pExpr){
87106 static void exprAnalyze(SrcList*, WhereClause*, int);
87113 static void exprAnalyzeAll(
87266 static void transferJoinMarkings(Expr *pDerived, Expr *pBase){
87348 static void exprAnalyzeOrTerm(
87598 static void exprAnalyze(
88020 static void TRACE_IDX_INPUTS(sqlite3_index_info *p){
88038 static void TRACE_IDX_OUTPUTS(sqlite3_index_info *p){
88060 static void bestIndex(
88070 static void bestOrClauseIndex(
88270 (void)sqlite3SafetyOff(pParse->db);
88275 (void)sqlite3SafetyOn(pParse->db);
88316 static void bestVirtualIndex(
88717 static void bestBtreeIndex(
89041 static void bestIndex(
89087 static void disableTerm(WhereLevel *pLevel, WhereTerm *pTerm){
89113 static void codeApplyAffinity(Parse *pParse, int base, int n, char *zAff){
89958 static void whereInfoFree(sqlite3 *db, WhereInfo *pWInfo){
90504 SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){
90688 static void spanSet(ExprSpan *pOut, Token *pStart, Token *pEnd){
90697 static void spanExpr(ExprSpan *pOut, Parse *pParse, int op, Token *pValue){
90706 static void spanBinaryExpr(
90720 static void spanUnaryPostfix(
90734 static void binaryToUnaryIfNull(Parse *pParse, Expr *pY, Expr *pA, int op){
90745 static void spanUnaryPrefix(
91517 SQLITE_PRIVATE void sqlite3ParserTrace(FILE *TraceFILE, char *zTracePrompt){
91938 static void yyGrowStack(yyParser *p){
91969 SQLITE_PRIVATE void *sqlite3ParserAlloc(void *(*mallocProc)(size_t)){
91991 static void yy_destructor(
92119 SQLITE_PRIVATE void sqlite3ParserFree(
92120 void *p, /* The parser to be deleted */
92121 void (*freeProc)(void*) /* Function used to reclaim memory */
92131 (*freeProc)((void*)pParser);
92138 SQLITE_PRIVATE int sqlite3ParserStackPeak(void *p){
92247 static void yyStackOverflow(yyParser *yypParser, YYMINORTYPE *yypMinor){
92268 static void yy_shift(
92650 static void yy_accept(yyParser*); /* Forward Declaration */
92656 static void yy_reduce(
93814 static void yy_parse_failed(
93833 static void yy_syntax_error(
93851 static void yy_accept(
93885 SQLITE_PRIVATE void sqlite3Parser(
93886 void *yyp, /* The parser */
94700 void *pEngine; /* The LEMON-generated LALR(1) parser */
94716 pEngine = sqlite3ParserAlloc((void*(*)(size_t))sqlite3Malloc);
95099 SQLITE_API int sqlite3_complete16(const void *zSql){
95245 SQLITE_API const char *sqlite3_libversion(void){ return sqlite3_version; }
95246 SQLITE_API const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; }
95247 SQLITE_API int sqlite3_libversion_number(void){ return SQLITE_VERSION_NUMBER; }
95248 SQLITE_API int sqlite3_threadsafe(void){ return SQLITE_THREADSAFE; }
95257 SQLITE_PRIVATE void (*sqlite3IoTrace)(const char*, ...) = 0;
95300 SQLITE_API int sqlite3_initialize(void){
95433 SQLITE_API int sqlite3_shutdown(void){
95529 sqlite3GlobalConfig.pScratch = va_arg(ap, void*);
95536 sqlite3GlobalConfig.pPage = va_arg(ap, void*);
95559 sqlite3GlobalConfig.pHeap = va_arg(ap, void*);
95612 static int setupLookaside(sqlite3 *db, void *pBuf, int sz, int cnt){
95613 void *pStart;
95681 void *pBuf = va_arg(ap, void*);
95713 void *padFlag,
95714 int nKey1, const void *pKey1,
95715 int nKey2, const void *pKey2
95743 void *NotUsed,
95744 int nKey1, const void *pKey1,
95745 int nKey2, const void *pKey2
95782 SQLITE_PRIVATE void sqlite3CloseSavepoints(sqlite3 *db){
95922 SQLITE_PRIVATE void sqlite3RollbackAll(sqlite3 *db){
96002 void *ptr, /* Database connection */
96065 int (*xBusy)(void*,int),
96066 void *pArg
96082 SQLITE_API void sqlite3_progress_handler(
96085 int (*xProgress)(void*),
96086 void *pArg
96110 sqlite3_busy_handler(db, sqliteDefaultBusyCallback, (void*)db);
96120 SQLITE_API void sqlite3_interrupt(sqlite3 *db){
96136 void *pUserData,
96137 void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
96138 void (*xStep)(sqlite3_context*,int,sqlite3_value **),
96139 void (*xFinal)(sqlite3_context*)
96220 void *p,
96221 void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
96222 void (*xStep)(sqlite3_context*,int,sqlite3_value **),
96223 void (*xFinal)(sqlite3_context*)
96236 const void *zFunctionName,
96239 void *p,
96240 void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
96241 void (*xStep)(sqlite3_context*,int,sqlite3_value**),
96242 void (*xFinal)(sqlite3_context*)
96296 SQLITE_API void *sqlite3_trace(sqlite3 *db, void (*xTrace)(void*,const char*), void *pArg){
96297 void *pOld;
96313 SQLITE_API void *sqlite3_profile(
96315 void (*xProfile)(void*,const char*,sqlite_uint64),
96316 void *pArg
96318 void *pOld;
96334 SQLITE_API void *sqlite3_commit_hook(
96336 int (*xCallback)(void*), /* Function to invoke on each commit */
96337 void *pArg /* Argument to the function */
96339 void *pOld;
96352 SQLITE_API void *sqlite3_update_hook(
96354 void (*xCallback)(void*,int,char const *,char const *,sqlite_int64),
96355 void *pArg /* Argument to the function */
96357 void *pRet;
96370 SQLITE_API void *sqlite3_rollback_hook(
96372 void (*xCallback)(void*), /* Callback function */
96373 void *pArg /* Argument to the function */
96375 void *pRet;
96503 SQLITE_API const void *sqlite3_errmsg16(sqlite3 *db){
96516 const void *z;
96518 return (void *)outOfMem;
96521 return (void *)misuse;
96525 z = (void *)outOfMem;
96577 void* pCtx,
96578 int(*xCompare)(void*,int,const void*,int,const void*),
96579 void(*xDel)(void*)
96839 createCollation(db, "RTRIM", SQLITE_UTF8, SQLITE_COLL_USER, (void*)1,
96984 const void *zFilename,
97024 void* pCtx,
97025 int(*xCompare)(void*,int,const void*,int,const void*)
97043 void* pCtx,
97044 int(*xCompare)(void*,int,const void*,int,const void*),
97045 void(*xDel)(void*)
97062 const void *zName,
97064 void* pCtx,
97065 int(*xCompare)(void*,int,const void*,int,const void*)
97088 void *pCollNeededArg,
97089 void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*)
97106 void *pCollNeededArg,
97107 void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*)
97124 SQLITE_API int sqlite3_global_recover(void){
97148 SQLITE_PRIVATE int sqlite3Corrupt(void){
97161 SQLITE_API void sqlite3_thread_cleanup(void){
97195 (void)sqlite3SafetyOn(db);
97254 (void)sqlite3SafetyOff(db);
97309 SQLITE_API int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *pArg){
97400 typedef void (*void_function)(void);
97590 static void checkListProperties(sqlite3 *db){
97616 static void removeFromBlockedList(sqlite3 *db){
97631 static void addToBlockedList(sqlite3 *db){
97646 static void enterMutex(void){
97654 static void leaveMutex(void){
97683 void (*xNotify)(void **, int),
97684 void *pArg
97730 SQLITE_PRIVATE void sqlite3ConnectionBlocked(sqlite3 *db, sqlite3 *pBlocker){
97758 SQLITE_PRIVATE void sqlite3ConnectionUnlocked(sqlite3 *db){
97759 void (*xUnlockNotify)(void **, int) = 0; /* Unlock-notify cb to invoke */
97762 void **aArg; /* Arguments to the unlock callback */
97763 void **aDyn = 0; /* Dynamically allocated space for aArg[] */
97764 void *aStatic[16]; /* Starter space for aArg[]. No malloc required */
97790 || (aDyn && nArg==(int)(sqlite3DbMallocSize(db, aDyn)/sizeof(void*)))
97793 void **pNew = (void **)sqlite3Malloc(nArg*sizeof(void *)*2);
97795 memcpy(pNew, aArg, nArg*sizeof(void *));
97857 SQLITE_PRIVATE void sqlite3ConnectionClosed(sqlite3 *db){
98380 void *data; /* Data associated with this element */
98381 void *pKey; int nKey; /* Key associated with this element */
98402 SQLITE_PRIVATE void sqlite3Fts3HashInit(Fts3Hash *pNew, char keyClass, char copyKey);
98403 SQLITE_PRIVATE void *sqlite3Fts3HashInsert(Fts3Hash*, const void *pKey, int nKey, void *pData);
98404 SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash*, const void *pKey, int nKey);
98405 SQLITE_PRIVATE void sqlite3Fts3HashClear(Fts3Hash*);
98406 SQLITE_PRIVATE Fts3HashElem *sqlite3Fts3HashFindElem(const Fts3Hash *, const void *, int);
98497 #define UNUSED_PARAMETER(x) (void)(x)
98659 SQLITE_PRIVATE int sqlite3Fts3InitVtab(int, sqlite3*, void*, int, const char*const*,
98665 SQLITE_PRIVATE void sqlite3Fts3PendingTermsClear(Fts3Table *);
98670 SQLITE_PRIVATE void sqlite3Fts3SegReaderFree(Fts3Table *, Fts3SegReader *);
98673 int (*)(Fts3Table *, void *, char *, int, char *, int), void *
98697 SQLITE_PRIVATE void sqlite3Fts3Dequote(char *);
98710 SQLITE_PRIVATE void sqlite3Fts3Offsets(sqlite3_context*, Fts3Cursor*);
98711 SQLITE_PRIVATE void sqlite3Fts3Snippet(sqlite3_context*, Fts3Cursor*,
98714 SQLITE_PRIVATE void sqlite3Fts3Snippet2(sqlite3_context *, Fts3Cursor *, const char *,
98717 SQLITE_PRIVATE void sqlite3Fts3Matchinfo(sqlite3_context *, Fts3Cursor *);
98723 SQLITE_PRIVATE void sqlite3Fts3ExprFree(Fts3Expr *);
98810 SQLITE_PRIVATE void sqlite3Fts3Dequote(char *z){
98834 static void fts3GetDeltaVarint(char **pp, sqlite3_int64 *pVal){
98840 static void fts3GetDeltaVarint2(char **pp, char *pEnd, sqlite3_int64 *pVal){
99002 void *pAux, /* Hash table containing tokenizers */
99131 void *pAux, /* Pointer to tokenizer hash table */
99141 void *pAux, /* Pointer to tokenizer hash table */
99395 static void fts3PutDeltaVarint(
99409 static void fts3PoslistCopy(char **pp, char **ppPoslist){
99436 static void fts3ColumnlistCopy(char **pp, char **ppPoslist){
99469 static void fts3ReadNextPos(
99503 static void fts3PoslistMerge(
99915 void *pContext, /* Pointer to TermSelect structure */
100075 fts3TermSelectCb, (void *)&tsc
100553 static void fts3SnippetFunc(
100590 static void fts3Snippet2Func(
100631 static void fts3OffsetsFunc(
100657 static void fts3OptimizeFunc(
100691 static void fts3MatchinfoFunc(
100717 void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), /* OUT: Result */
100718 void **ppArg /* Unused */
100722 void (*xFunc)(sqlite3_context*,int,sqlite3_value**);
100801 static void hashDestroy(void *p){
100818 SQLITE_PRIVATE void sqlite3Fts3SimpleTokenizerModule(sqlite3_tokenizer_module const**ppModule);
100819 SQLITE_PRIVATE void sqlite3Fts3PorterTokenizerModule(sqlite3_tokenizer_module const**ppModule);
100820 SQLITE_PRIVATE void sqlite3Fts3IcuTokenizerModule(sqlite3_tokenizer_module const**ppModule);
100852 if( sqlite3Fts3HashInsert(pHash, "simple", 7, (void *)pSimple)
100853 || sqlite3Fts3HashInsert(pHash, "porter", 7, (void *)pPorter)
100855 || (pIcu && sqlite3Fts3HashInsert(pHash, "icu", 4, (void *)pIcu))
100881 db, "fts3", &fts3Module, (void *)pHash, hashDestroy
101088 static void *fts3ReallocOrFree(void *pOrig, int nNew){
101089 void *pRet = sqlite3_realloc(pOrig, nNew);
101404 static void insertBinaryOperator(
101638 SQLITE_PRIVATE void sqlite3Fts3ExprFree(Fts3Expr *p){
101676 memcpy((void *)pp, sqlite3_column_blob(pStmt, 0), sizeof(*pp));
101689 static void exprToString(Fts3Expr *pExpr, char *zBuf){
101741 static void fts3ExprTest(
101863 static void *fts3HashMalloc(int n){
101864 void *p = sqlite3_malloc(n);
101870 static void fts3HashFree(void *p){
101884 SQLITE_PRIVATE void sqlite3Fts3HashInit(Fts3Hash *pNew, char keyClass, char copyKey){
101899 SQLITE_PRIVATE void sqlite3Fts3HashClear(Fts3Hash *pH){
101922 static int fts3StrHash(const void *pKey, int nKey){
101932 static int fts3StrCompare(const void *pKey1, int n1, const void *pKey2, int n2){
101940 static int fts3BinHash(const void *pKey, int nKey){
101948 static int fts3BinCompare(const void *pKey1, int n1, const void *pKey2, int n2){
101963 ** with types "const void*" and "int" and returns an "int".
101965 static int (*ftsHashFunction(int keyClass))(const void*,int){
101980 static int (*ftsCompareFunction(int keyClass))(const void*,int,const void*,int){
101991 static void fts3HashInsertElement(
102024 int (*xHash)(const void*,int); /* The hash function */
102047 const void *pKey, /* The key we are searching for */
102053 int (*xCompare)(const void*,int,const void*,int); /* comparison function */
102073 static void fts3RemoveElementByHash(
102109 const void *pKey,
102113 int (*xHash)(const void*,int); /* The hash function */
102128 SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash *pH, const void *pKey, int nKey){
102150 SQLITE_PRIVATE void *sqlite3Fts3HashInsert(
102152 const void *pKey, /* The key */
102154 void *data /* The data */
102160 int (*xHash)(const void*,int); /* The hash function */
102170 void *old_data = elem->data;
102194 memcpy((void*)new_elem->pKey, pKey, nKey);
102196 new_elem->pKey = (void*)pKey;
102500 static void copy_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){
102547 static void porter_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){
102843 SQLITE_PRIVATE void sqlite3Fts3PorterTokenizerModule(
102905 static void scalarFunc(
102911 void *pPtr = 0;
102923 void *pOld;
102929 pPtr = *(void **)sqlite3_value_blob(argv[1]);
102930 pOld = sqlite3Fts3HashInsert(pHash, (void *)zName, nName, pPtr);
102945 sqlite3_result_blob(context, (void *)&pPtr, sizeof(pPtr), SQLITE_TRANSIENT);
103042 char const **aNew = (const char **)sqlite3_realloc((void *)aArg, nNew);
103045 sqlite3_free((void *)aArg);
103061 sqlite3_free((void *)aArg);
103098 static void testFunc(
103227 memcpy((void *)pp, sqlite3_column_blob(pStmt, 0), sizeof(*pp));
103234 SQLITE_PRIVATE void sqlite3Fts3SimpleTokenizerModule(sqlite3_tokenizer_module const**ppModule);
103254 static void intTestFunc(
103312 void *p = (void *)pHash;
103318 void *pdb = (void *)db;
103564 SQLITE_PRIVATE void sqlite3Fts3SimpleTokenizerModule(
104090 SQLITE_PRIVATE void sqlite3Fts3PendingTermsClear(Fts3Table *p){
104364 static void fts3SegReaderFirstDocid(Fts3SegReader *pReader){
104382 static void fts3SegReaderNextDocid(
104423 SQLITE_PRIVATE void sqlite3Fts3SegReaderFree(Fts3Table *p, Fts3SegReader *pReader){
104537 static int fts3CompareElemByTerm(const void *lhs, const void *rhs){
104757 static void fts3SegReaderSort(
105040 static void fts3NodeFree(SegmentNode *pTree){
105238 static void fts3SegWriterFree(SegmentWriter *pWriter){
105370 static void fts3ColumnFilter(
105410 void *pContext, /* Pointer to SegmentWriter* to write with */
105426 void *pContext, /* Pointer to SegmentWriter* to write with */
105466 int (*xFunc)(Fts3Table *, void *, char *, int, char *, int), /* Callback */
105467 void *pContext /* Callback context (2nd argument) */
105705 &filter, fts3MergeCallback, (void *)&pWriter
105758 void *c = (void *)&pWriter; /* SegReaderIterate() callback context */
105969 static void fts3SnippetSbInit(StringBuffer *p){
105978 static void fts3SnippetAppend(StringBuffer *p, const char *zNew, int nNew){
106003 static void fts3SnippetAppendWhiteSpace(StringBuffer *p){
106010 static void fts3SnippetTrimWhiteSpace(StringBuffer *p){
106023 static void fts3SnippetFree(Snippet *p){
106399 static void snippetOffsetText(Snippet *p){
106481 static void snippetText(
106592 SQLITE_PRIVATE void sqlite3Fts3Offsets(
106611 SQLITE_PRIVATE void sqlite3Fts3Snippet(
106641 static void fts3GetDeltaPosition(char **pp, int *piPos){
106659 int (*x)(Fts3Expr *, void *), /* Callback function to invoke for phrases */
106660 void *pCtx /* Second argument to pass to callback */
106684 static int fts3ExprLoadDoclistsCb(Fts3Expr *pExpr, void *ctx){
106703 rc = fts3ExprIterate(pCsr->pExpr, fts3ExprLoadDoclistsCb, (void *)&sCtx);
106767 static int fts3SnippetFindPositions(Fts3Expr *pExpr, void *ctx){
106784 static void fts3SnippetCnt(
106879 (void)fts3ExprIterate(pCsr->pExpr, fts3SnippetFindPositions, (void *)&sCtx);
107091 static void fts3LoadColumnlistCounts(char **pp, u32 *aOut){
107111 void *pCtx /* Pointer to MatchInfo structure */
107134 void *pCtx /* Pointer to MatchInfo structure */
107182 (void)fts3ExprIterate(pCsr->pExpr, fts3ExprGlobalMatchinfoCb, (void *)&g);
107194 (void)fts3ExprIterate(pCsr->pExpr, fts3ExprLocalMatchinfoCb, (void *)&g);
107201 SQLITE_PRIVATE void sqlite3Fts3Snippet2(
107233 SQLITE_PRIVATE void sqlite3Fts3Matchinfo(sqlite3_context *pContext, Fts3Cursor *pCsr){
107483 static void readCoord(u8 *p, RtreeCoord *pCoord){
107541 static void nodeReference(RtreeNode *p){
107550 static void nodeZero(Rtree *pRtree, RtreeNode *p){
107582 static void nodeHashInsert(Rtree *pRtree, RtreeNode *pNode){
107595 static void nodeHashDelete(Rtree *pRtree, RtreeNode *pNode){
107691 static void nodeOverwriteCell(
107709 static void nodeDeleteCell(Rtree *pRtree, RtreeNode *pNode, int iCell){
107816 static void nodeGetCoord(
107830 static void nodeGetCell(
107848 sqlite3 *, void *, int, const char *const*, sqlite3_vtab **, char **, int
107856 void *pAux,
107869 void *pAux,
107880 static void rtreeReference(Rtree *pRtree){
107888 static void rtreeRelease(Rtree *pRtree){
108457 static void cellUnion(Rtree *pRtree, RtreeCell *p1, RtreeCell *p2){
108645 static void AdjustTree(
108711 static void LinearPickSeeds(
108805 static void QuadraticPickSeeds(
108855 static void SortByDistance(
108921 static void SortByDimension(
109342 static void fixBoundingBox(Rtree *pRtree, RtreeNode *pNode){
109902 void *pAux, /* One of the RTREE_COORD_* constants */
110016 static void rtreenode(sqlite3_context *ctx, int nArg, sqlite3_value **apArg){
110054 static void rtreedepth(sqlite3_context *ctx, int nArg, sqlite3_value **apArg){
110082 void *c = (void *)RTREE_COORD_REAL32;
110086 void *c = (void *)RTREE_COORD_INT32;
110163 static void xFree(void *p){
110263 static void icuLikeFunc(
110309 static void icuFunctionError(
110324 static void icuRegexpDelete(void *p){
110348 static void icuRegexpFunc(sqlite3_context *p, int nArg, sqlite3_value **apArg){
110429 static void icuCaseFunc16(sqlite3_context *p, int nArg, sqlite3_value **apArg){
110473 static void icuCollationDel(void *pCtx){
110483 void *pCtx,
110485 const void *zLeft,
110487 const void *zRight
110514 static void icuLoadCollation(
110541 rc = sqlite3_create_collation_v2(db, zName, SQLITE_UTF16, (void *)pUCollator,
110558 void *pContext; /* sqlite3_user_data() context */
110559 void (*xFunc)(sqlite3_context*,int,sqlite3_value**);
110565 {"upper", 1, SQLITE_UTF16, (void*)1, icuCaseFunc16},
110566 {"upper", 2, SQLITE_UTF16, (void*)1, icuCaseFunc16},
110570 {"upper", 1, SQLITE_UTF8, (void*)1, icuCaseFunc16},
110571 {"upper", 2, SQLITE_UTF8, (void*)1, icuCaseFunc16},
110576 {"icu_load_collation", 2, SQLITE_UTF8, (void*)db, icuLoadCollation},
110854 SQLITE_PRIVATE void sqlite3Fts3IcuTokenizerModule(