Lines Matching +full:4224 +full:h
11 ** programs, you need this file and the "sqlite3.h" header file that defines
13 ** the "sqlite3.h" header file at hand, you will find a copy embedded within
14 ** the text of this file. Search for "Begin file sqlite3.h" to find the start
15 ** of the embedded sqlite3.h header file.) Additional code files may be needed
28 /************** Begin file sqliteInt.h ***************************************/
87 /************** Include msvc.h in the middle of sqliteInt.h ******************/
88 /************** Begin file msvc.h ********************************************/
135 /************** End of msvc.h ************************************************/
136 /************** Continuing where we left off in sqliteInt.h ******************/
141 /************** Include vxworks.h in the middle of sqliteInt.h ***************/
142 /************** Begin file vxworks.h *****************************************/
160 #include <vxWorks.h>
161 #include <pthread.h> /* amalgamator: dontcache */
176 /************** End of vxworks.h *********************************************/
177 /************** Continuing where we left off in sqliteInt.h ******************/
236 ** Some C99 functions in "math.h" are only present for MSVC when its version
280 # include "mingw.h"
282 # include "_mingw.h"
312 /************** Include sqlite3.h in the middle of sqliteInt.h ***************/
313 /************** Begin file sqlite3.h *****************************************/
341 ** The name of this file under configuration management is "sqlite.h.in".
343 ** the version number) and changes its name to "sqlite3.h" as
348 #include <stdarg.h> /* Needed for the definition of va_list */
435 ** ^(The [SQLITE_VERSION] C preprocessor macro in the sqlite3.h header
11163 /******** Begin file sqlite3rtree.h *********/
11281 /******** End of sqlite3rtree.h *********/
11282 /******** Begin file sqlite3session.h *********/
13111 /******** End of sqlite3session.h *********/
13112 /******** Begin file fts5.h *********/
13738 /******** End of fts5.h *********/
13740 /************** End of sqlite3.h *********************************************/
13741 /************** Continuing where we left off in sqliteInt.h ******************/
13753 #include "sqlite_cfg.h"
13757 /************** Include sqliteLimit.h in the middle of sqliteInt.h ***********/
13758 /************** Begin file sqliteLimit.h *************************************/
13970 /************** End of sqliteLimit.h *****************************************/
13971 /************** Continuing where we left off in sqliteInt.h ******************/
14003 #include <stdint.h>
14006 #include <inttypes.h>
14066 # include <intrin.h>
14072 # include <cmnintrin.h>
14387 /************** Include hash.h in the middle of sqliteInt.h ******************/
14388 /************** Begin file hash.h ********************************************/
14465 ** Hash h;
14468 ** for(p=sqliteHashFirst(&h); p; p=sqliteHashNext(p)){
14473 #define sqliteHashFirst(H) ((H)->first) argument
14482 #define sqliteHashCount(H) ((H)->count) argument
14486 /************** End of hash.h ************************************************/
14487 /************** Continuing where we left off in sqliteInt.h ******************/
14488 /************** Include parse.h in the middle of sqliteInt.h *****************/
14489 /************** Begin file parse.h *******************************************/
14676 /************** End of parse.h ***********************************************/
14677 /************** Continuing where we left off in sqliteInt.h ******************/
14678 #include <stdio.h>
14679 #include <stdlib.h>
14680 #include <string.h>
14681 #include <assert.h>
14682 #include <stddef.h>
15104 # include <TargetConditionals.h>
15437 ** Defer sourcing vdbe.h and btree.h until after the "u8" and
15438 ** "BusyHandler" typedefs. vdbe.h also requires a few of the opaque
15441 /************** Include os.h in the middle of sqliteInt.h ********************/
15442 /************** Begin file os.h **********************************************/
15459 ** This header file is #include-ed by sqliteInt.h and thus ends up
15469 /************** Include os_setup.h in the middle of os.h *********************/
15470 /************** Begin file os_setup.h ****************************************/
15563 /************** End of os_setup.h ********************************************/
15564 /************** Continuing where we left off in os.h *************************/
15573 /* Maximum pathname length. Note: FILENAME_MAX defined by stdio.h
15764 /************** End of os.h **************************************************/
15765 /************** Continuing where we left off in sqliteInt.h ******************/
15766 /************** Include pager.h in the middle of sqliteInt.h *****************/
15767 /************** Begin file pager.h *******************************************/
15826 ** NOTE: These values must match the corresponding BTREE_ values in btree.h.
16016 /************** End of pager.h ***********************************************/
16017 /************** Continuing where we left off in sqliteInt.h ******************/
16018 /************** Include btree.h in the middle of sqliteInt.h *****************/
16019 /************** Begin file btree.h *******************************************/
16077 ** pager.h.
16442 /************** End of btree.h ***********************************************/
16443 /************** Continuing where we left off in sqliteInt.h ******************/
16444 /************** Include vdbe.h in the middle of sqliteInt.h ******************/
16445 /************** Begin file vdbe.h ********************************************/
16465 /* #include <stdio.h> */
16475 ** The names of the following types declared in vdbeInt.h are required
16609 ** The makefile scans the vdbe.c source file and creates the "opcodes.h"
16612 /************** Include opcodes.h in the middle of vdbe.h ********************/
16613 /************** Begin file opcodes.h *****************************************/
16853 /************** End of opcodes.h *********************************************/
16854 /************** Continuing where we left off in vdbe.h ***********************/
17102 /************** End of vdbe.h ************************************************/
17103 /************** Continuing where we left off in sqliteInt.h ******************/
17104 /************** Include pcache.h in the middle of sqliteInt.h ****************/
17105 /************** Begin file pcache.h ******************************************/
17297 /************** End of pcache.h **********************************************/
17298 /************** Continuing where we left off in sqliteInt.h ******************/
17299 /************** Include mutex.h in the middle of sqliteInt.h *****************/
17300 /************** Begin file mutex.h *******************************************/
17314 ** The sqliteInt.h header #includes this file so that it is available
17319 ** Source files should #include the sqliteInt.h file and let that file
17373 /************** End of mutex.h ***********************************************/
17374 /************** Continuing where we left off in sqliteInt.h ******************/
17563 ** functions use a regular table table from hash.h.)
20566 ** The ctype.h header is needed for non-ASCII systems. It is also
20571 # include <ctype.h>
21147 # define sqlite3CodeRowTrigger(A,B,C,D,E,F,G,H,I) argument
21247 SQLITE_PRIVATE u8 sqlite3HexToInt(int h);
21776 /************** End of sqliteInt.h *******************************************/
21777 /************** Begin file os_common.h ***************************************/
21878 /************** End of os_common.h *******************************************/
21910 /* #include "sqlite_cfg.h" */
21924 /* #include "sqliteInt.h" */
22693 /* #include "sqliteInt.h" */
23038 /* #include "opcodes.h" */
23099 /* #include "sqliteInt.h" */
23100 /************** Include vdbeInt.h in the middle of status.c ******************/
23101 /************** Begin file vdbeInt.h *****************************************/
23480 ** There is a typedef for this structure in sqlite.h. So all routines,
23485 ** This structure is defined inside of vdbeInt.h because it uses substructures
23834 /************** End of vdbeInt.h *********************************************/
24265 /* #include "sqliteInt.h" */
24266 /* #include <stdlib.h> */
24267 /* #include <assert.h> */
24268 #include <time.h>
24289 int h, m; /* Hour and minutes */ member
24294 char validHMS; /* True (1) if h,m,s are valid */
24423 int h, m, s; in parseHhMmSs() local
24425 if( getDigits(zDate, "20c:20e", &h, &m)!=2 ){ in parseHhMmSs()
24451 p->h = h; in parseHhMmSs()
24500 p->iJD += p->h*3600000 + p->m*60000 + (sqlite3_int64)(p->s*1000 + 0.5); in computeJD()
24714 p->h = day_min / 60; in computeHMS()
24858 p->h = sLocal.tm_hour; in toLocaltime()
25131 p->h = p->m = 0; in parseModifier()
25162 int Y,M,D,h,m,x; in parseModifier() local
25215 && getDigits(&z[12], "20c:20e", &h, &m)==2 in parseModifier()
25425 zBuf[12] = '0' + (x.h/10)%10; in datetimeFunc()
25426 zBuf[13] = '0' + (x.h)%10; in datetimeFunc()
25472 zBuf[0] = '0' + (x.h/10)%10; in timeFunc()
25473 zBuf[1] = '0' + (x.h)%10; in timeFunc()
25594 ** %H hour 00-24
25674 case 'H': in strftimeFunc()
25676 sqlite3_str_appendf(&sRes, cf=='H' ? "%02d" : "%2d", x.h); in strftimeFunc()
25681 int h = x.h; in strftimeFunc() local
25682 if( h>12 ) h -= 12; in strftimeFunc()
25683 if( h==0 ) h = 12; in strftimeFunc()
25684 sqlite3_str_appendf(&sRes, cf=='I' ? "%02d" : "%2d", h); in strftimeFunc()
25705 if( x.h>=12 ){ in strftimeFunc()
25713 sqlite3_str_appendf(&sRes, "%02d:%02d", x.h, x.m); in strftimeFunc()
25731 sqlite3_str_appendf(&sRes,"%02d:%02d:%02d", x.h, x.m, (int)x.s); in strftimeFunc()
25911 sign, Y, M, d1.D-1, d1.h, d1.m, d1.s); in timediffFunc()
25992 "{iJD:%lld,Y:%d,M:%d,D:%d,h:%d,m:%d,tz:%d," in datedebugFunc()
25996 x.iJD, x.Y, x.M, x.D, x.h, x.m, x.tz, in datedebugFunc()
26028 STR_FUNCTION(current_time, 0, "%H:%M:%S", 0, currentTimeFunc), in sqlite3RegisterDateTimeFunctions()
26030 STR_FUNCTION(current_timestamp, 0, "%Y-%m-%d %H:%M:%S", 0, currentTimeFunc), in sqlite3RegisterDateTimeFunctions()
26053 /* #include "sqliteInt.h" */
26514 /* #include "sqliteInt.h" */
26596 /* #include "sqliteInt.h" */
26683 /* #include "sqliteInt.h" */
26697 #include <sys/sysctl.h>
26698 #include <malloc/malloc.h>
26700 #include <libkern/OSAtomic.h>
26720 ** The malloc.h header file is needed for malloc_usable_size() function
26730 ** the malloc.h header file.
26738 ** Include the malloc.h header file, if necessary. Also set define macro
26745 # include <malloc.h>
26955 /* #include "sqliteInt.h" */
26973 /* #include <stdio.h> */
27490 /* #include "sqliteInt.h" */
28205 /* #include "sqliteInt.h" */
28758 /* #include "sqliteInt.h" */
29134 /* #include "sqliteInt.h" */
29338 /* #include "sqliteInt.h" */
29349 #include <pthread.h>
29735 /* #include "sqliteInt.h" */
29741 /* #include "os_common.h" */
29746 /************** Include os_win.h in the middle of mutex_w32.c ****************/
29747 /************** Begin file os_win.h ******************************************/
29768 #include "windows.h"
29771 # include <sys/cygwin.h>
29772 # include <errno.h> /* amalgamator: dontcache */
29837 /************** End of os_win.h **********************************************/
30230 /* #include "sqliteInt.h" */
30231 /* #include <stdarg.h> */
31150 /* #include "sqliteInt.h" */
32604 /* #include "sqliteInt.h" */
33921 /* #include "sqliteInt.h" */
34091 /* #include "sqliteInt.h" */
34093 /* # include "os_win.h" */
34102 /* #include <pthread.h> */
34174 #include <process.h>
34376 /* #include "sqliteInt.h" */
34377 /* #include <assert.h> */
34378 /* #include "vdbeInt.h" */
34927 /* #include "sqliteInt.h" */
34928 /* #include <stdarg.h> */
34930 #include <math.h>
35361 u8 h = 0; in sqlite3StrIHash() local
35364 h += UpperToLower[(unsigned char)z[0]]; in sqlite3StrIHash()
35367 return h; in sqlite3StrIHash()
36414 ** This routine only works if h really is a valid hexadecimal
36417 SQLITE_PRIVATE u8 sqlite3HexToInt(int h){ in sqlite3HexToInt() argument
36418 assert( (h>='0' && h<='9') || (h>='a' && h<='f') || (h>='A' && h<='F') ); in sqlite3HexToInt()
36420 h += 9*(1&(h>>6)); in sqlite3HexToInt()
36423 h += 9*(1&~(h>>4)); in sqlite3HexToInt()
36425 return (u8)(h & 0xf); in sqlite3HexToInt()
36801 /************** Include hwtime.h in the middle of util.c *********************/
36802 /************** Begin file hwtime.h ******************************************/
36889 /************** End of hwtime.h **********************************************/
36909 /* #include "sqliteInt.h" */
36910 /* #include <assert.h> */
36950 unsigned int h = 0;
36956 h += sqlite3UpperToLower[c];
36957 h *= 0x9e3779b1;
36959 return h;
37029 unsigned int h = strHash(elem->pKey) % new_size;
37031 insertElement(pH, &new_ht[h], elem);
37048 unsigned int h; /* The computed hash */
37053 h = strHash(pKey) % pH->htsize;
37054 pEntry = &pH->ht[h];
37058 h = 0;
37062 if( pHash ) *pHash = h;
37080 unsigned int h /* Hash value for the element */
37092 pEntry = &pH->ht[h];
37133 unsigned int h; /* the hash of the key modulo hash table size */
37139 elem = findElementWithHash(pH,pKey,&h);
37143 removeElementGivenHash(pH,elem,h);
37159 h = strHash(pKey) % pH->htsize;
37162 insertElement(pH, pH->ht ? &pH->ht[h] : 0, new_elem);
37393 /* #include <sqliteInt.h> */
37541 #include <sys/types.h>
37542 #include <sys/stat.h>
37543 #include <unistd.h>
38329 #include <sys/time.h>
38404 /* #include "sqliteInt.h" */
38448 #include <sys/types.h> /* amalgamator: keep */
38449 #include <sys/stat.h> /* amalgamator: keep */
38450 #include <fcntl.h>
38451 #include <sys/ioctl.h>
38452 #include <unistd.h> /* amalgamator: keep */
38453 /* #include <time.h> */
38454 #include <sys/time.h> /* amalgamator: keep */
38455 #include <errno.h>
38458 # include <sys/mman.h>
38462 /* # include <sys/ioctl.h> */
38463 # include <sys/file.h>
38464 # include <sys/param.h>
38496 /* # include <sys/ioctl.h> */
38497 # include <semaphore.h>
38498 # include <limits.h>
38502 # include <sys/mount.h>
38506 # include <utime.h>
38518 /* # include <pthread.h> */
38619 int h; /* The file descriptor */
38696 /* #include "os_common.h" */
39243 static int robust_ftruncate(int h, sqlite3_int64 sz){
39254 do{ rc = osFtruncate(h,sz); }while( rc<0 && errno==EINTR );
39696 static void robust_close(unixFile *pFile, int h, int lineno){
39697 if( osClose(h) ){
39785 fd = pFile->h;
39890 rc = osFstat(pFile->h, &buf);
39941 if( osFcntl(pFile->h, F_GETLK, &lock) ){
39951 OSTRACE(("TEST WR-LOCK %d %d %d (unix)\n", pFile->h, rc, reserved));
39974 # define osSetPosixAdvisoryLock(h,x,t) osFcntl(h,F_SETLK,x)
39977 int h, /* The file descriptor on which to take the lock */
39982 int rc = osFcntl(h,F_SETLK,pLock);
39990 rc = osFcntl(h,F_SETLK,pLock);
40030 rc = osSetPosixAdvisoryLock(pFile->h, &lock, pFile);
40038 rc = osSetPosixAdvisoryLock(pFile->h, pLock, pFile);
40075 ** Symbols defined in os.h identify the 'pending byte' and the 'reserved
40115 OSTRACE(("LOCK %d %s was %s(%s,%d) pid=%d (unix)\n", pFile->h,
40125 OSTRACE(("LOCK %d %s ok (already held) (unix)\n", pFile->h,
40285 OSTRACE(("LOCK %d %s %s (unix)\n", pFile->h, azFileLock(eFileLock),
40300 pFile->h = -1;
40324 OSTRACE(("UNLOCK %d %d was %d(%d,%d) pid=%d (unix)\n", pFile->h, eFileLock,
40504 if( pFile->h>=0 ){
40505 robust_close(pFile, pFile->h, __LINE__);
40506 pFile->h = -1;
40524 OSTRACE(("CLOSE %-3d\n", pFile->h));
40657 OSTRACE(("TEST WR-LOCK %d %d %d (dotlock)\n", pFile->h, rc, reserved));
40745 OSTRACE(("UNLOCK %d %d was %d pid=%d (dotlock)\n", pFile->h, eFileLock,
40845 int lrc = robust_flock(pFile->h, LOCK_EX | LOCK_NB);
40848 lrc = robust_flock(pFile->h, LOCK_UN);
40867 OSTRACE(("TEST WR-LOCK %d %d %d (flock)\n", pFile->h, rc, reserved));
40923 if (robust_flock(pFile->h, LOCK_EX | LOCK_NB)) {
40934 OSTRACE(("LOCK %d %s %s (flock)\n", pFile->h, azFileLock(eFileLock),
40956 OSTRACE(("UNLOCK %d %d was %d pid=%d (flock)\n", pFile->h, eFileLock,
40972 if( robust_flock(pFile->h, LOCK_UN) ){
41047 OSTRACE(("TEST WR-LOCK %d %d %d (sem)\n", pFile->h, rc, reserved));
41121 OSTRACE(("UNLOCK %d %d was %d pid=%d (sem)\n", pFile->h, eFileLock,
41226 pb.fd = pFile->h;
41229 (setLockFlag?"ON":"OFF"), pFile->h, (pb.fd==-1?"[testval-1]":""),
41297 OSTRACE(("TEST WR-LOCK %d %d %d (afp)\n", pFile->h, rc, reserved));
41334 OSTRACE(("LOCK %d %s was %s(%s,%d) pid=%d (afp)\n", pFile->h,
41343 OSTRACE(("LOCK %d %s ok (already held) (afp)\n", pFile->h,
41497 OSTRACE(("LOCK %d %s %s (afp)\n", pFile->h, azFileLock(eFileLock),
41517 OSTRACE(("UNLOCK %d %d was %d(%d,%d) pid=%d (afp)\n", pFile->h, eFileLock,
41689 assert( id->h>2 );
41692 got = osPread(id->h, pBuf, cnt, offset);
41695 got = osPread64(id->h, pBuf, cnt, offset);
41698 newOffset = lseek(id->h, offset, SEEK_SET);
41704 got = osRead(id->h, pBuf, cnt);
41721 id->h, got+prior, offset-prior, TIMER_ELAPSED));
41853 return seekAndWriteFd(id->h, offset, pBuf, cnt, &id->lastErrno);
42147 OSTRACE(("SYNC %-3d\n", pFile->h));
42148 rc = full_fsync(pFile->h, isFullsync, isDataOnly);
42194 rc = robust_ftruncate(pFile->h, nByte);
42233 rc = osFstat(((unixFile*)id)->h, &buf);
42272 if( osFstat(pFile->h, &buf) ){
42285 err = osFallocate(pFile->h, buf.st_size, nSize-buf.st_size);
42316 if( robust_ftruncate(pFile->h, nByte) ){
42360 int rc = osIoctl(pFile->h, F2FS_IOC_START_ATOMIC_WRITE);
42364 int rc = osIoctl(pFile->h, F2FS_IOC_COMMIT_ATOMIC_WRITE);
42368 int rc = osIoctl(pFile->h, F2FS_IOC_ABORT_VOLATILE_WRITE);
42504 res = osIoctl(pFd->h, F2FS_IOC_GET_FEATURES, &f);
42519 #include <sys/dcmd_blk.h>
42520 #include <sys/statvfs.h>
42528 if( fstatvfs(pFile->h, &fsInfo) == -1 ) {
43066 if( osFstat(pDbFd->h, &sStat) ){
43674 int h = pFd->h; /* File descriptor open on db file */
43709 pNew = osMmap(pReq, nNew-nReuse, flags, MAP_SHARED, h, nReuse);
43728 pNew = osMmap(0, nNew, flags, MAP_SHARED, h, 0);
43768 if( osFstat(pFd->h, &statbuf) ){
44097 if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) {
44137 if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) {
44166 int h, /* Open file descriptor of file being opened */
44180 OSTRACE(("OPEN %-3d %s\n", h, zFilename));
44181 pNew->h = h;
44235 ** handle h - as it is guaranteed that no posix locks will be released
44242 robust_close(pNew, h, __LINE__);
44243 h = -1;
44268 robust_close(pNew, h, __LINE__);
44269 h = -1;
44320 if( h>=0 ) robust_close(pNew, h, __LINE__);
44321 h = -1;
44327 if( h>=0 ) robust_close(pNew, h, __LINE__);
45105 #include <dlfcn.h>
45736 readLen = osPread(conchFile->h, buf, PROXY_MAXCONCHLEN, 0);
45757 robust_close(pFile, conchFile->h, __LINE__);
45758 conchFile->h = fd;
45794 if( osFstat(conchFile->h, &buf) ){
45813 int len = osPread(conchFile->h, tBuf, PROXY_MAXCONCHLEN, 0);
45872 OSTRACE(("TAKECONCH %d for %s pid=%d\n", conchFile->h,
45952 futimes(conchFile->h, NULL);
45977 robust_ftruncate(conchFile->h, writeSize);
45979 full_fsync(conchFile->h,0,0);
45985 int err = osFstat(pFile->h, &buf);
45991 osFchmod(conchFile->h, cmode);
45994 rc = osFchmod(conchFile->h, cmode);
46014 OSTRACE(("TRANSPROXY: CLOSE %d\n", pFile->h));
46017 if( pFile->h>=0 ){
46018 robust_close(pFile, pFile->h, __LINE__);
46020 pFile->h = -1;
46024 pFile->h = fd;
46064 OSTRACE(("TAKECONCH %d %s\n", conchFile->h,
46082 OSTRACE(("RELEASECONCH %d for %s pid=%d\n", conchFile->h,
46089 OSTRACE(("RELEASECONCH %d %s\n", conchFile->h,
46225 OSTRACE(("TRANSPROXY %d for %s pid=%d\n", pFile->h,
46286 OSTRACE(("TRANSPROXY %d %s\n", pFile->h,
46666 /* #include "sqliteInt.h" */
46672 /* #include "os_common.h" */
46677 /* #include "os_win.h" */
46760 ** This constant should already be defined (in the "WinDef.h" SDK file).
46775 ** This constant should already be defined (in the "WinNT.h" SDK file).
46917 HANDLE h; /* Handle for accessing the file */
48854 /* # include <time.h> */
48882 #define HANDLE_TO_WINFILE(a) (winFile*)&((char*)a)[-(int)offsetof(winFile,h)]
48885 ** Acquire a lock on the handle h
48887 static void winceMutexAcquire(HANDLE h){
48890 dwErr = osWaitForSingleObject(h, INFINITE);
48896 #define winceMutexRelease(h) ReleaseMutex(h)
49249 OSTRACE(("SEEK file=%p, offset=%lld\n", pFile->h, iOffset));
49261 dwRet = osSetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);
49268 OSTRACE(("SEEK file=%p, rc=SQLITE_IOERR_SEEK\n", pFile->h));
49272 OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h));
49283 bRet = osSetFilePointerEx(pFile->h, x, 0, FILE_BEGIN);
49289 OSTRACE(("SEEK file=%p, rc=SQLITE_IOERR_SEEK\n", pFile->h));
49293 OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h));
49323 assert( pFile->h!=NULL && pFile->h!=INVALID_HANDLE_VALUE );
49325 osGetCurrentProcessId(), pFile, pFile->h));
49332 rc = osCloseHandle(pFile->h);
49356 pFile->h = NULL;
49360 osGetCurrentProcessId(), pFile, pFile->h, rc ? "ok" : "failed"));
49390 pFile->h, pBuf, amt, offset, pFile->locktype));
49399 osGetCurrentProcessId(), pFile, pFile->h));
49414 osGetCurrentProcessId(), pFile, pFile->h));
49417 while( !osReadFile(pFile->h, pBuf, amt, &nRead, 0) ){
49422 while( !osReadFile(pFile->h, pBuf, amt, &nRead, &overlapped) &&
49429 osGetCurrentProcessId(), pFile, pFile->h));
49438 osGetCurrentProcessId(), pFile, pFile->h));
49443 osGetCurrentProcessId(), pFile, pFile->h));
49468 pFile->h, pBuf, amt, offset, pFile->locktype));
49477 osGetCurrentProcessId(), pFile, pFile->h));
49511 if( !osWriteFile(pFile->h, aRem, nRem, &nWrite, 0) ){
49513 if( !osWriteFile(pFile->h, aRem, nRem, &nWrite, &overlapped) ){
49541 osGetCurrentProcessId(), pFile, pFile->h));
49546 osGetCurrentProcessId(), pFile, pFile->h));
49553 osGetCurrentProcessId(), pFile, pFile->h));
49591 osGetCurrentProcessId(), pFile, pFile->h, nByte, pFile->locktype));
49615 }else if( 0==osSetEndOfFile(pFile->h) &&
49633 osGetCurrentProcessId(), pFile, pFile->h, sqlite3ErrName(rc)));
49679 osGetCurrentProcessId(), pFile, pFile->h, flags,
49696 osGetCurrentProcessId(), pFile, pFile->h));
49715 rc = osFlushFileBuffers(pFile->h);
49719 osGetCurrentProcessId(), pFile, pFile->h));
49724 osGetCurrentProcessId(), pFile, pFile->h));
49741 OSTRACE(("SIZE file=%p, pSize=%p\n", pFile->h, pSize));
49746 if( osGetFileInformationByHandleEx(pFile->h, FileStandardInfo,
49761 lowerBits = osGetFileSize(pFile->h, &upperBits);
49772 pFile->h, pSize, *pSize, sqlite3ErrName(rc)));
49814 OSTRACE(("READ-LOCK file=%p, lock=%d\n", pFile->h, pFile->locktype));
49821 res = winceLockFile(&pFile->h, SHARED_FIRST, 0, 1, 0);
49823 res = winLockFile(&pFile->h, SQLITE_LOCKFILEEX_FLAGS, SHARED_FIRST, 0,
49832 res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS,
49840 OSTRACE(("READ-LOCK file=%p, result=%d\n", pFile->h, res));
49850 OSTRACE(("READ-UNLOCK file=%p, lock=%d\n", pFile->h, pFile->locktype));
49852 res = winUnlockFile(&pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
49856 res = winUnlockFile(&pFile->h, SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0);
49864 OSTRACE(("READ-UNLOCK file=%p, result=%d\n", pFile->h, res));
49904 pFile->h, pFile->locktype, pFile->sharedLockByte, locktype));
49911 OSTRACE(("LOCK-HELD file=%p, rc=SQLITE_OK\n", pFile->h));
49936 while( cnt-->0 && (res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS,
49946 pFile->h, cnt, res));
49951 pFile->h, cnt, sqlite3ErrName(rc)));
49978 res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS, RESERVED_BYTE, 0, 1, 0);
49998 res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS, SHARED_FIRST, 0,
50012 winUnlockFile(&pFile->h, PENDING_BYTE, 0, 1, 0);
50024 pFile->h, locktype, newLocktype));
50028 pFile->h, pFile->locktype, sqlite3ErrName(rc)));
50042 OSTRACE(("TEST-WR-LOCK file=%p, pResOut=%p\n", pFile->h, pResOut));
50047 OSTRACE(("TEST-WR-LOCK file=%p, result=%d (local)\n", pFile->h, res));
50049 res = winLockFile(&pFile->h, SQLITE_LOCKFILEEX_FLAGS,RESERVED_BYTE,0,1,0);
50051 winUnlockFile(&pFile->h, RESERVED_BYTE, 0, 1, 0);
50054 OSTRACE(("TEST-WR-LOCK file=%p, result=%d (remote)\n", pFile->h, res));
50058 pFile->h, pResOut, *pResOut));
50080 pFile->h, pFile->locktype, pFile->sharedLockByte, locktype));
50083 winUnlockFile(&pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
50092 winUnlockFile(&pFile->h, RESERVED_BYTE, 0, 1, 0);
50098 winUnlockFile(&pFile->h, PENDING_BYTE, 0, 1, 0);
50102 pFile->h, pFile->locktype, sqlite3ErrName(rc)));
50171 OSTRACE(("FCNTL file=%p, op=%d, pArg=%p\n", pFile->h, op, pArg));
50175 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50180 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50185 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50200 OSTRACE(("FCNTL file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc)));
50203 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50208 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50213 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50218 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50233 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50238 *phFile = pFile->h;
50239 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50245 HANDLE hOldFile = pFile->h;
50246 pFile->h = *phFile;
50249 hOldFile, pFile->h));
50259 OSTRACE(("FCNTL file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc)));
50285 OSTRACE(("FCNTL file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc)));
50290 OSTRACE(("FCNTL file=%p, rc=SQLITE_NOTFOUND\n", pFile->h));
50456 pFile->hFile.h, lockType, ofst, nByte));
50460 rc = winUnlockFile(&pFile->hFile.h, ofst, 0, nByte, 0);
50465 rc = winLockFile(&pFile->hFile.h, dwFlags, ofst, 0, nByte, 0);
50476 pFile->hFile.h, (lockType == WINSHM_UNLCK) ? "winUnlockFile" :
50513 if( p->hFile.h!=NULL && p->hFile.h!=INVALID_HANDLE_VALUE ){
50614 ((winFile*)(&pShmNode->hFile))->h = INVALID_HANDLE_VALUE;
50947 hMap = osCreateFileMappingFromApp(pShmNode->hFile.h,
50951 hMap = osCreateFileMappingW(pShmNode->hFile.h,
50955 hMap = osCreateFileMappingA(pShmNode->hFile.h,
51105 pFd->hMap = osCreateFileMappingFromApp(pFd->h, NULL, protect, nMap, NULL);
51107 pFd->hMap = osCreateFileMappingW(pFd->h, NULL, protect,
51111 pFd->hMap = osCreateFileMappingA(pFd->h, NULL, protect,
51680 HANDLE h;
51750 pFile->h = INVALID_HANDLE_VALUE;
51851 h = osCreateFile2((LPCWSTR)zConverted,
51856 if( h!=INVALID_HANDLE_VALUE ) break;
51867 h = osCreateFileW((LPCWSTR)zConverted,
51873 if( h!=INVALID_HANDLE_VALUE ) break;
51887 h = osCreateFileA((LPCSTR)zConverted,
51893 if( h!=INVALID_HANDLE_VALUE ) break;
51906 OSTRACE(("OPEN file=%p, name=%s, access=%lx, rc=%s\n", h, zUtf8Name,
51907 dwDesiredAccess, (h==INVALID_HANDLE_VALUE) ? "failed" : "ok"));
51909 if( h==INVALID_HANDLE_VALUE ){
51933 "rc=%s\n", h, zUtf8Name, dwDesiredAccess, pOutFlags, pOutFlags ?
51934 *pOutFlags : 0, (h==INVALID_HANDLE_VALUE) ? "failed" : "ok"));
51944 osCloseHandle(h);
51962 pFile->h = h;
52448 HANDLE h;
52474 h = osLoadPackagedLibrary((LPCWSTR)zConverted, 0);
52476 h = osLoadLibraryW((LPCWSTR)zConverted);
52481 h = osLoadLibraryA((char*)zConverted);
52484 OSTRACE(("DLOPEN name=%s, handle=%p\n", zFilename, (void*)h));
52486 return (void*)h;
52884 /* #include "sqliteInt.h" */
53841 /* #include "sqliteInt.h" */
53949 u32 h = BITVEC_HASH(i++);
53950 while( p->u.aHash[h] ){
53951 if( p->u.aHash[h]==i ) return 1;
53952 h = (h+1) % BITVEC_NINT;
53974 u32 h;
53992 h = BITVEC_HASH(i++);
53996 if( !p->u.aHash[h] ){
54006 if( p->u.aHash[h]==i ) return SQLITE_OK;
54007 h++;
54008 if( h>=BITVEC_NINT ) h = 0;
54009 } while( p->u.aHash[h] );
54010 /* we didn't find it in the hash. h points to the first */
54034 p->u.aHash[h] = i;
54066 u32 h = BITVEC_HASH(aiValues[j]-1);
54068 while( p->u.aHash[h] ){
54069 h++;
54070 if( h>=BITVEC_NINT ) h = 0;
54072 p->u.aHash[h] = aiValues[j];
54232 /* #include "sqliteInt.h" */
55240 /* #include "sqliteInt.h" */
55715 unsigned int h = pPage->iKey % nNew;
55717 pPage->pNext = apNew[h];
55718 apNew[h] = pPage;
55760 unsigned int h;
55765 h = pPage->iKey % pCache->nHash;
55766 for(pp=&pCache->apHash[h]; (*pp)!=pPage; pp=&(*pp)->pNext);
55807 unsigned int h, iStop;
55816 h = iLimit % pCache->nHash;
55822 h = pCache->nHash/2;
55823 iStop = h - 1;
55828 assert( h<pCache->nHash );
55829 pp = &pCache->apHash[h];
55841 if( h==iStop ) break;
55842 h = (h+1) % pCache->nHash;
56082 unsigned int h = iKey % pCache->nHash;
56085 pPage->pNext = pCache->apHash[h];
56091 pCache->apHash[h] = pPage;
56503 /* #include "sqliteInt.h" */
56545 ** A typedef of this structure if found in sqliteInt.h.
56966 /* #include "sqliteInt.h" */
56967 /************** Include wal.h in the middle of pager.c ***********************/
56968 /************** Begin file wal.h *********************************************/
56988 /* #include "sqliteInt.h" */
57130 /************** End of wal.h *************************************************/
65163 /* #include "wal.h" */
65544 #include <Windows.h>
69511 /************** Include btreeInt.h in the middle of btmutex.c ****************/
69512 /************** Begin file btreeInt.h ****************************************/
69728 /* #include "sqliteInt.h" */
70248 /************** End of btreeInt.h ********************************************/
70502 ** are null #defines in btree.h.
70505 ** the ones below, are no-ops and are null #defines in btree.h.
70556 ** See the header comment on "btreeInt.h" for additional information.
70559 /* #include "btreeInt.h" */
82027 /* #include "sqliteInt.h" */
82028 /* #include "btreeInt.h" */
82800 /* #include "sqliteInt.h" */
82801 /* #include "vdbeInt.h" */
84852 /* #include "sqliteInt.h" */
84853 /* #include "vdbeInt.h" */
90392 /* #include "sqliteInt.h" */
90393 /* #include "vdbeInt.h" */
90394 /* #include "opcodes.h" */
92936 /* #include "sqliteInt.h" */
92937 /* #include "vdbeInt.h" */
93134 /* #include "sqliteInt.h" */
93135 /* #include "vdbeInt.h" */
93793 u64 h = 0;
93799 h += p->u.i;
93801 h += sqlite3VdbeIntValue(p);
93806 h += 4093 + (p->flags & (MEM_Str|MEM_Blob));
93809 return h;
94097 ** generates two C files "opcodes.h" and "opcodes.c" by scanning this
94098 ** file looking for lines that begin with "case OP_". The opcodes.h files
96480 ** macros defined in sqliteInt.h.
97551 ** in btree.h. These flags control aspects of the operation of
101868 u64 h;
101874 h = filterHash(aMem, pOp);
101881 printf("hash: %llu modulo %d -> %u\n", h, pIn1->n, (int)(h%pIn1->n));
101884 h %= (pIn1->n*8);
101885 pIn1->z[h/8] |= 1<<(h&7);
101904 u64 h;
101910 h = filterHash(aMem, pOp);
101917 printf("hash: %llu modulo %d -> %u\n", h, pIn1->n, (int)(h%pIn1->n));
101920 h %= (pIn1->n*8);
101921 if( (pIn1->z[h/8] & (1<<(h&7)))==0 ){
102299 /* #include "sqliteInt.h" */
102300 /* #include "vdbeInt.h" */
102939 /* #include "sqliteInt.h" */
102940 /* #include "vdbeInt.h" */
105586 /* #include "sqliteInt.h" */
105588 /* #include "vdbeInt.h" */
106045 /* #include "sqliteInt.h" */
106477 /* #include "sqliteInt.h" */
106478 /* #include <stdlib.h> */
106479 /* #include <string.h> */
106741 /* #include "sqliteInt.h" */
109026 /* #include "sqliteInt.h" */
116157 /* #include "sqliteInt.h" */
118599 /* #include "sqliteInt.h" */
120490 /* #include "sqliteInt.h" */
121113 /* #include "sqliteInt.h" */
121392 /* #include "sqliteInt.h" */
123019 u32 h = 0;
123026 h = (h<<8) + sqlite3UpperToLower[x];
123028 if( h==(('c'<<24)+('h'<<16)+('a'<<8)+'r') ){ /* CHAR */
123031 }else if( h==(('c'<<24)+('l'<<16)+('o'<<8)+'b') ){ /* CLOB */
123033 }else if( h==(('t'<<24)+('e'<<16)+('x'<<8)+'t') ){ /* TEXT */
123035 }else if( h==(('b'<<24)+('l'<<16)+('o'<<8)+'b') /* BLOB */
123040 }else if( h==(('r'<<24)+('e'<<16)+('a'<<8)+'l') /* REAL */
123043 }else if( h==(('f'<<24)+('l'<<16)+('o'<<8)+'a') /* FLOA */
123046 }else if( h==(('d'<<24)+('o'<<16)+('u'<<8)+'b') /* DOUB */
123050 }else if( (h&0x00FFFFFF)==(('i'<<16)+('n'<<8)+'t') ){ /* INT */
127091 /* #include "sqliteInt.h" */
127410 int h, /* Hash of the name */
127414 for(p=sqlite3BuiltinFunctions.a[h]; p; p=p->u.pHash){
127435 int h = SQLITE_FUNC_HASH(zName[0], nName);
127437 pOther = sqlite3FunctionSearch(h, zName);
127444 aDef[i].u.pHash = sqlite3BuiltinFunctions.a[h];
127445 sqlite3BuiltinFunctions.a[h] = &aDef[i];
127481 int h; /* Hash value */
127514 h = SQLITE_FUNC_HASH(sqlite3UpperToLower[(u8)zName[0]], nName);
127515 p = sqlite3FunctionSearch(h, zName);
127632 /* #include "sqliteInt.h" */
128664 /* #include "sqliteInt.h" */
128665 /* #include <stdlib.h> */
128666 /* #include <assert.h> */
128668 /* #include <math.h> */
128670 /* #include "vdbeInt.h" */
131397 int h = p->zName[0] + n;
131399 printf(" %s(%d)", p->zName, h);
131422 /* #include "sqliteInt.h" */
132908 /* #include "sqliteInt.h" */
136287 /* #include "sqliteInt.h" */
136430 #define SQLITE_CORE 1 /* Disable the API redefinition in sqlite3ext.h */
136432 /************** Include sqlite3ext.h in the middle of loadext.c **************/
136433 /************** Begin file sqlite3ext.h **************************************/
136449 ** sqlite3.h.
136453 /* #include "sqlite3.h" */
137154 /************** End of sqlite3ext.h ******************************************/
137156 /* #include "sqliteInt.h" */
138074 /* #include "sqliteInt.h" */
138085 ** The "pragma.h" include file is an automatically generated file that
138089 ** Do not edit pragma.h directly. Edit and rerun the script in at
138091 /************** Include pragma.h in the middle of pragma.c *******************/
138092 /************** Begin file pragma.h ******************************************/
138754 /************** End of pragma.h **********************************************/
139010 ** defined in pager.h. This function returns the associated lowercase
141819 /* #include "sqliteInt.h" */
142086 ** Note: The #defined SQLITE_UTF* symbols in sqliteInt.h correspond to
142906 /* #include "sqliteInt.h" */
143213 u8 h = sqlite3StrIHash(zCol);
143216 if( pCol->hName==h && sqlite3StrICmp(pCol->zCnName, zCol)==0 ) return i;
147146 ** (17h) The corresponding result set expressions in all arms of the
147366 /* Restriction (17h) */
150181 ** See comments in sqliteInt.h for further information.
151530 /* #include "sqliteInt.h" */
151725 /* #include "sqliteInt.h" */
153288 /* #include "sqliteInt.h" */
154659 /* #include "sqliteInt.h" */
154993 /* #include "sqliteInt.h" */
154994 /* #include "vdbeInt.h" */
155407 /* #include "sqliteInt.h" */
156788 /* #include "sqliteInt.h" */
156789 /************** Include whereInt.h in the middle of wherecode.c **************/
156790 /************** Begin file whereInt.h ****************************************/
157431 /************** End of whereInt.h ********************************************/
160260 /* #include "sqliteInt.h" */
160261 /* #include "whereInt.h" */
162136 /* #include "sqliteInt.h" */
162137 /* #include "whereInt.h" */
168351 u16 wctrlFlags, /* The WHERE_* flags defined in sqliteInt.h */
169360 /* #include "sqliteInt.h" */
172477 /* #include "sqliteInt.h" */
173954 /* #include <assert.h> */
173956 /* #include <stdio.h> */
178009 /* #include "sqliteInt.h" */
178010 /* #include <stdlib.h> */
178100 ** Used by keywordhash.h
178136 ** named keywordhash.h and then included into this source file by
178139 /************** Include keywordhash.h in the middle of tokenize.c ************/
178140 /************** Begin file keywordhash.h *************************************/
178169 'R','E','I','N','D','E','X','E','D','E','S','C','A','P','E','A','C','H',
178172 'S','E','L','E','C','T','A','B','L','E','F','T','H','E','N','D','E','F',
178180 'G','E','N','E','R','A','T','E','D','E','T','A','C','H','A','V','I','N',
178182 'E','S','U','N','I','Q','U','E','R','Y','W','I','T','H','O','U','T','E',
178183 'R','E','L','E','A','S','E','A','T','T','A','C','H','B','E','T','W','E',
178184 'E','N','O','T','H','I','N','G','R','O','U','P','S','C','A','S','C','A',
178188 'A','T','C','H','P','L','A','N','A','L','Y','Z','E','P','R','A','G','M',
178191 'S','V','I','R','T','U','A','L','W','A','Y','S','W','H','E','N','W','H',
178201 'I','C','T','O','T','H','E','R','S','O','V','E','R','E','T','U','R','N',
178202 'I','N','G','R','I','G','H','T','R','O','L','L','B','A','C','K','R','O',
178624 /************** End of keywordhash.h *****************************************/
179387 /* #include "sqliteInt.h" */
179678 /* #include "sqliteInt.h" */
179681 /************** Include fts3.h in the middle of main.c ***********************/
179682 /************** Begin file fts3.h ********************************************/
179698 /* #include "sqlite3.h" */
179710 /************** End of fts3.h ************************************************/
179714 /************** Include rtree.h in the middle of main.c **********************/
179715 /************** Begin file rtree.h *******************************************/
179731 /* #include "sqlite3.h" */
179747 /************** End of rtree.h ***********************************************/
179751 /************** Include sqliteicu.h in the middle of main.c ******************/
179752 /************** Begin file sqliteicu.h ***************************************/
179768 /* #include "sqlite3.h" */
179780 /************** End of sqliteicu.h *******************************************/
182470 'o', 'r', ' ', 'o', 't', 'h', 'e', 'r', ' ', 'A', 'P', 'I', ' ',
182616 ** #defines in sqlite3.h.
183680 ** See comment in sqlite3.h (sqlite.h.in) for details.
184884 /* #include "sqliteInt.h" */
184885 /* #include "btreeInt.h" */
185302 ** label: A B C D E F G H I J K
185309 ** (14-2 and 35-2+12). The 0 at H indicate the end-of-document. The
185497 /************** Include fts3Int.h in the middle of fts3.c ********************/
185498 /************** Begin file fts3Int.h *****************************************/
185536 /* If not building as part of the core, include sqlite3ext.h. */
185538 /* # include "sqlite3ext.h" */
185542 /* #include "sqlite3.h" */
185543 /************** Include fts3_tokenizer.h in the middle of fts3Int.h **********/
185544 /************** Begin file fts3_tokenizer.h **********************************/
185571 /* #include "sqlite3.h" */
185707 /************** End of fts3_tokenizer.h **************************************/
185708 /************** Continuing where we left off in fts3Int.h ********************/
185709 /************** Include fts3_hash.h in the middle of fts3Int.h ***************/
185710 /************** Begin file fts3_hash.h ***************************************/
185803 ** Fts3Hash h;
185806 ** for(p=fts3HashFirst(&h); p; p=fts3HashNext(p)){
185811 #define fts3HashFirst(H) ((H)->first)
185820 #define fts3HashCount(H) ((H)->count)
185824 /************** End of fts3_hash.h *******************************************/
185825 /************** Continuing where we left off in fts3Int.h ********************/
186440 /************** End of fts3Int.h *********************************************/
186448 /* #include <assert.h> */
186449 /* #include <stdlib.h> */
186450 /* #include <stddef.h> */
186451 /* #include <stdio.h> */
186452 /* #include <string.h> */
186453 /* #include <stdarg.h> */
186455 /* #include "fts3.h" */
186457 /* # include "sqlite3ext.h" */
192356 /* #include "fts3Int.h" */
192359 /* #include <string.h> */
192360 /* #include <assert.h> */
192920 /* #include "fts3Int.h" */
192983 /* #include <string.h> */
192984 /* #include <assert.h> */
194012 /* #include <stdio.h> */
194224 /* #include "fts3Int.h" */
194227 /* #include <assert.h> */
194228 /* #include <stdlib.h> */
194229 /* #include <string.h> */
194231 /* #include "fts3_hash.h" */
194297 unsigned h = 0;
194300 h = (h<<3) ^ h ^ *z++;
194303 return (int)(h & 0x7fffffff);
194314 int h = 0;
194317 h = (h<<3) ^ h ^ *(z++);
194319 return h & 0x7fffffff;
194407 int h = (*xHash)(elem->pKey, elem->nKey) & (new_size-1);
194409 fts3HashInsertElement(pH, &new_ht[h], elem);
194422 int h /* The hash for this key. */
194429 struct _fts3ht *pEntry = &pH->ht[h];
194449 int h /* Hash value for the element */
194460 pEntry = &pH->ht[h];
194485 int h; /* A hash on key */
194491 h = (*xHash)(pKey,nKey);
194493 return fts3FindElementByHash(pH,pKey,nKey, h & (pH->htsize-1));
194530 int h; /* the hash of the key modulo hash table size */
194540 h = hraw & (pH->htsize-1);
194541 elem = fts3FindElementByHash(pH,pKey,nKey,h);
194545 fts3RemoveElementByHash(pH,elem,h);
194575 h = hraw & (pH->htsize-1);
194576 fts3HashInsertElement(pH, &pH->ht[h], new_elem);
194609 /* #include "fts3Int.h" */
194612 /* #include <assert.h> */
194613 /* #include <stdlib.h> */
194614 /* #include <stdio.h> */
194615 /* #include <string.h> */
194617 /* #include "fts3_tokenizer.h" */
195275 /* #include "fts3Int.h" */
195278 /* #include <assert.h> */
195279 /* #include <string.h> */
195479 # include "sqlite_tcl.h"
195481 # include "tcl.h"
195483 /* #include <string.h> */
195797 /* #include "fts3Int.h" */
195800 /* #include <assert.h> */
195801 /* #include <stdlib.h> */
195802 /* #include <stdio.h> */
195803 /* #include <string.h> */
195805 /* #include "fts3_tokenizer.h" */
196050 /* #include "fts3Int.h" */
196053 /* #include <string.h> */
196054 /* #include <assert.h> */
196491 /* #include "fts3Int.h" */
196494 /* #include <string.h> */
196495 /* #include <assert.h> */
196496 /* #include <stdlib.h> */
196497 /* #include <stdio.h> */
202322 /* #include "fts3Int.h" */
202325 /* #include <string.h> */
202326 /* #include <assert.h> */
204084 /* #include "fts3Int.h" */
204087 /* #include <assert.h> */
204088 /* #include <stdlib.h> */
204089 /* #include <stdio.h> */
204090 /* #include <string.h> */
204092 /* #include "fts3_tokenizer.h" */
204487 /* #include <assert.h> */
204651 'd', 'e', 'e', 'g', 'h', 'i',
204658 't', 'h', 'a', 'e', 'o'|HIBIT, 'o',
204662 'f', 'g', 'h', 'h', 'i', 'i'|HIBIT,
204666 'w', 'x', 'y', 'z', 'h', 't',
204973 /* #include "sqliteInt.h" */
205729 ** This routine only gives a correct answer if h really is a valid hexadecimal
205733 static u8 jsonHexToInt(int h){
205735 h += 9*(1&(h>>6));
205738 h += 9*(1&~(h>>4));
205740 return (u8)(h & 0xf);
210373 /* #include "sqlite3ext.h" */
210376 /* #include "sqlite3.h" */
210382 ** found in sqliteInt.h
210385 #include "sqlite3rtree.h"
210417 /* #include <string.h> */
210418 /* #include <stdio.h> */
210419 /* #include <assert.h> */
210420 /* #include <stdlib.h> */
210773 /* # include <intrin.h> */
210777 /* # include <cmnintrin.h> */
214620 /* #include <stdlib.h> */
214639 #include <ctype.h> /* amalgamator: keep */
216661 #include <unicode/utypes.h>
216662 #include <unicode/uregex.h>
216663 #include <unicode/ustring.h>
216664 #include <unicode/ucol.h>
216666 /* #include <assert.h> */
216669 /* #include "sqlite3ext.h" */
216672 /* #include "sqlite3.h" */
217230 /* #include "fts3Int.h" */
217234 /* #include <assert.h> */
217235 /* #include <string.h> */
217236 /* #include "fts3_tokenizer.h" */
217238 #include <unicode/ubrk.h>
217239 /* #include <unicode/ucol.h> */
217240 /* #include <unicode/ustring.h> */
217241 #include <unicode/utf16.h>
217499 ** sqlite3rbu.h. Essentially, for each table xyz in the target database
217564 /* #include <assert.h> */
217565 /* #include <string.h> */
217566 /* #include <stdio.h> */
217568 /* #include "sqlite3.h" */
217571 /************** Include sqlite3rbu.h in the middle of sqlite3rbu.c ***********/
217572 /************** Begin file sqlite3rbu.h **************************************/
217842 /* #include "sqlite3.h" ** Required for error code definitions ** */
218207 /************** End of sqlite3rbu.h ******************************************/
218211 /* #include "windows.h" */
221266 ** in zipvfs.h.
223563 /* #include "sqliteInt.h" ** Requires access to internal data structures ** */
224481 /* #include "sqliteInt.h" ** Requires access to internal data structures ** */
224888 /* #include "sqlite3session.h" */
224889 /* #include <assert.h> */
224890 /* #include <string.h> */
224893 /* # include "sqliteInt.h" */
224894 /* # include "vdbeInt.h" */
225054 ** and so on in sqlite3.h. For undefined and NULL values, the field consists
225385 static unsigned int sessionHashAppendI64(unsigned int h, i64 i){
225386 h = HASH_APPEND(h, i & 0xFFFFFFFF);
225387 return HASH_APPEND(h, (i>>32)&0xFFFFFFFF);
225394 static unsigned int sessionHashAppendBlob(unsigned int h, int n, const u8 *z){
225396 for(i=0; i<n; i++) h = HASH_APPEND(h, z[i]);
225397 return h;
225404 static unsigned int sessionHashAppendType(unsigned int h, int eType){
225405 return HASH_APPEND(h, eType);
225427 unsigned int h = 0; /* Hash value to return */
225432 h = sessionHashAppendI64(h, iRowid);
225450 h = sessionHashAppendType(h, eType);
225460 h = sessionHashAppendI64(h, iVal);
225471 h = sessionHashAppendBlob(h, n, z);
225481 *piHash = (h % pTab->nChange);
225516 unsigned int h = 0; /* Value to return */
225536 h = sessionHashAppendType(h, eType);
225538 h = sessionHashAppendI64(h, sessionGetI64(a));
225543 h = sessionHashAppendBlob(h, n, a);
225550 return (h % nBucket);
228415 ** database table is, according to sqliteLimit.h, 32676. So
231444 /* #include "sqlite3.h" */
232063 /* #include "fts5.h" */
232064 /* #include "sqlite3ext.h" */
232067 /* #include <string.h> */
232068 /* #include <assert.h> */
232990 /* #include "fts5Int.h" */
232991 /* #include "fts5parse.h" */
233338 /* #include <assert.h> */
233340 /* #include <stdio.h> */
234478 /* #include "fts5Int.h" */
234479 #include <math.h> /* amalgamator: keep */
235233 /* #include "fts5Int.h" */
235646 /* #include "fts5Int.h" */
236687 /* #include "fts5Int.h" */
236688 /* #include "fts5parse.h" */
236695 ** All token types in the generated fts5parse.h file are greater than 0.
236710 /* #include <stdio.h> */
239950 /* #include "fts5Int.h" */
240080 unsigned int h = 13;
240082 h = (h << 3) ^ h ^ p[i];
240084 return (h % nSlot);
240089 unsigned int h = 13;
240091 h = (h << 3) ^ h ^ p[i];
240093 h = (h << 3) ^ h ^ b;
240094 return (h % nSlot);
240540 ** the interface defined in fts5Int.h.
240544 /* #include "fts5Int.h" */
248817 sqlite3Fts5BufferAppendPrintf(pRc, pBuf, "{%s%ssegid=%d h=%d pgno=%d}",
249611 /* #include "fts5Int.h" */
249673 fts5_api api; /* User visible part of object (see fts5.h) */
249710 Fts5Table p; /* Public class members from fts5Int.h */
252729 /* #include "fts5Int.h" */
253958 /* #include "fts5Int.h" */
255423 /* #include <assert.h> */
255458 'd', 'e', 'e', 'g', 'h', 'i',
255465 't', 'h', 'a', 'e', 'o'|HIBIT, 'o',
255469 'f', 'g', 'h', 'h', 'i', 'i'|HIBIT,
255473 'w', 'x', 'y', 'z', 'h', 't',
255935 4198, 4224, 4226, 4227, 4272, 4275, 4279, 4281, 4283, 4285,
256200 /* #include "fts5Int.h" */
256568 /* #include "fts5Int.h" */
257352 /* #include "sqlite3ext.h" */
257355 /* #include <assert.h> */
257356 /* #include <string.h> */