Lines Matching defs:u32
8497 typedef UINT32_TYPE u32; /* 4-byte unsigned integer */
8505 ** that can be stored in a u32 without loss of data. The value
8520 typedef u32 tRowcnt; /* 32-bit is the default */
8905 SQLITE_PRIVATE u32 sqlite3BtreeLastPage(Btree*);
8952 SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *pBtree, int idx, u32 *pValue);
8953 SQLITE_PRIVATE int sqlite3BtreeUpdateMeta(Btree*, int idx, u32 value);
9014 SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor*, u32 offset, u32 amt, void*);
9015 SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor*, u32 *pAmt);
9016 SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor*, u32 *pAmt);
9017 SQLITE_PRIVATE int sqlite3BtreeDataSize(BtCursor*, u32 *pSize);
9018 SQLITE_PRIVATE int sqlite3BtreeData(BtCursor*, u32 offset, u32 amt, void*);
9023 SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor*, u32 offset, u32 amt, void*);
9159 u32 cnt; /* Number of times this instruction was executed */
9464 SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe*, u32 addr, int P1);
9465 SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe*, u32 addr, int P2);
9466 SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe*, u32 addr, int P3);
9612 typedef u32 Pgno;
9699 SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager*, u32*, int);
9827 u32 pageHash; /* Hash of page content */
10457 u32 magic; /* Magic number for detect library misuse */
11094 u32 nRef; /* Number of references to this KeyInfo object */
11352 u32 flags; /* Various flags. EP_* See below */
11562 u32 nAlloc; /* Number of entries allocated in a[] below */
11869 u32 aColmask[2]; /* Masks of old.*, new.* columns accessed */
11963 u32 nQueryLoop; /* Est number of iterations of a query (10*log2(N)) */
11964 u32 oldmask; /* Mask of old.* columns referenced */
11965 u32 newmask; /* Mask of new.* columns referenced */
12450 SQLITE_PRIVATE void sqlite3VXPrintf(StrAccum*, u32, const char*, va_list);
12451 SQLITE_PRIVATE void sqlite3XPrintf(StrAccum*, u32, const char*, ...);
12539 SQLITE_PRIVATE Bitvec *sqlite3BitvecCreate(u32);
12540 SQLITE_PRIVATE int sqlite3BitvecTest(Bitvec*, u32);
12541 SQLITE_PRIVATE int sqlite3BitvecSet(Bitvec*, u32);
12542 SQLITE_PRIVATE void sqlite3BitvecClear(Bitvec*, u32, void*);
12544 SQLITE_PRIVATE u32 sqlite3BitvecSize(Bitvec*);
12719 SQLITE_PRIVATE u32 sqlite3TriggerColmask(Parse*,Trigger*,ExprList*,int,int,Table*,int);
12761 SQLITE_PRIVATE u32 sqlite3Utf8Read(const u8**);
12777 SQLITE_PRIVATE int sqlite3PutVarint32(unsigned char*, u32);
12779 SQLITE_PRIVATE u8 sqlite3GetVarint32(const unsigned char *, u32 *);
12800 (u8)((*(A)<(u8)0x80)?((B)=(u32)*(A)),1:sqlite3GetVarint32((A),(u32 *)&(B)))
12802 (u8)(((u32)(B)<(u32)0x80)?(*(A)=(unsigned char)(B)),1:\
13031 SQLITE_PRIVATE u32 sqlite3FkOldmask(Parse*, Table*);
13082 SQLITE_PRIVATE int sqlite3FindInIndex(Parse *, Expr *, u32, int*);
13108 SQLITE_PRIVATE u32 sqlite3Get4byte(const u8*);
13109 SQLITE_PRIVATE void sqlite3Put4byte(u8*, u32);
13956 u32 cacheStatus; /* Cache is valid if this matches Vdbe.cacheCtr */
13957 u32 payloadSize; /* Total number of bytes in the record */
13958 u32 szRow; /* Byte available in aRow */
13959 u32 iHdrOffset; /* Offset to next unparsed byte of the header */
13961 u32 aType[1]; /* Type values for all entries in the record */
14181 u32 magic; /* Magic number for sanity checking */
14189 u32 cacheCtr; /* VdbeCursor row cache generation counter */
14209 u32 aCounter[5]; /* Counters used by sqlite3_stmt_status() */
14226 u32 expmask; /* Binding to these vars invalidates VM */
14250 SQLITE_PRIVATE u32 sqlite3VdbeSerialTypeLen(u32);
14251 SQLITE_PRIVATE u32 sqlite3VdbeSerialType(Mem*, int);
14252 SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(unsigned char*, Mem*, u32);
14253 SQLITE_PRIVATE u32 sqlite3VdbeSerialGet(const unsigned char*, u32, Mem*);
14286 SQLITE_PRIVATE int sqlite3VdbeMemFromBtree(BtCursor*,u32,u32,int,Mem*);
17186 u32 prevSize; /* Size of previous chunk in Mem3Block elements */
17187 u32 size4x; /* 4x the size of current chunk in Mem3Block elements */
17190 u32 next; /* Index in mem3.aPool[] of next free chunk */
17191 u32 prev; /* Index in mem3.aPool[] of previous free chunk */
17207 u32 nPool;
17223 u32 mnMaster;
17231 u32 iMaster;
17232 u32 szMaster;
17239 u32 aiSmall[MX_SMALL-1]; /* For sizes 2 through MX_SMALL, inclusive */
17240 u32 aiHash[N_HASH]; /* For sizes MX_SMALL+1 and larger */
17249 static void memsys3UnlinkFromList(u32 i, u32 *pRoot){
17250 u32 next = mem3.aPool[i].u.list.next;
17251 u32 prev = mem3.aPool[i].u.list.prev;
17269 static void memsys3Unlink(u32 i){
17270 u32 size, hash;
17289 static void memsys3LinkIntoList(u32 i, u32 *pRoot){
17303 static void memsys3Link(u32 i){
17304 u32 size, hash;
17354 static void *memsys3Checkout(u32 i, u32 nBlock){
17355 u32 x;
17372 static void *memsys3FromMaster(u32 nBlock){
17384 u32 newi, x;
17417 static void memsys3Merge(u32 *pRoot){
17418 u32 iNext, prev, size, i, x;
17457 u32 i;
17458 u32 nBlock;
17459 u32 toFree;
17541 u32 size, x;
17694 u32 i, j;
17695 u32 size;
17902 u32 currentOut; /* Current checkout, including internal fragmentation */
17903 u32 currentCount; /* Current number of distinct checkouts */
17904 u32 maxOut; /* Maximum instantaneous currentOut */
17905 u32 maxCount; /* Maximum instantaneous currentCount */
17906 u32 maxRequest; /* Largest allocation (exclusive of internal frag) */
18024 if( (u32)nByte>mem5.maxRequest ){
18083 u32 size, iLogsize;
18098 assert( iBlock+size-1<(u32)mem5.nBlock );
19810 u32 nScratchFree;
20151 assert( mem0.nScratchFree <= (u32)sqlite3GlobalConfig.nScratch );
20705 u32 bFlags, /* SQLITE_PRINTF_* flags */
21572 SQLITE_PRIVATE void sqlite3XPrintf(StrAccum *p, u32 bFlags, const char *zFormat, ...){
21872 SQLITE_PRIVATE u32 sqlite3Utf8Read(
22121 u32 c;
22862 u32 u = 0;
22972 SQLITE_PRIVATE int sqlite3PutVarint32(unsigned char *p, u32 v){
23005 u32 a,b,s;
23174 SQLITE_PRIVATE u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){
23175 u32 a,b;
23238 *v = (u32)v64;
23287 *v = (u32)v64;
23310 SQLITE_PRIVATE u32 sqlite3Get4byte(const u8 *p){
23314 SQLITE_PRIVATE void sqlite3Put4byte(unsigned char *p, u32 v){
23389 u32 magic;
23406 u32 magic;
28552 (u32)sStat.st_ino, (u32)sStat.st_dev);
32356 u32 magic1; /* Magic number to detect structure corruption. */
32361 u32 magic2; /* Magic number to detect structure corruption. */
37579 #define BITVEC_USIZE (((BITVEC_SZ-(3*sizeof(u32)))/sizeof(Bitvec*))*sizeof(Bitvec*))
37593 /* Number of u32 values in hash table. */
37594 #define BITVEC_NINT (BITVEC_USIZE/sizeof(u32))
37629 u32 iSize; /* Maximum bit index. Max iSize is 4,294,967,296. */
37630 u32 nSet; /* Number of bits that are set - only valid for aHash
37633 u32 iDivisor; /* Number of bits handled by each apSub[] entry. */
37635 /* Max iDivisor is max(u32) / BITVEC_NPTR + 1. */
37639 u32 aHash[BITVEC_NINT]; /* Hash table representation */
37649 SQLITE_PRIVATE Bitvec *sqlite3BitvecCreate(u32 iSize){
37664 SQLITE_PRIVATE int sqlite3BitvecTest(Bitvec *p, u32 i){
37669 u32 bin = i/p->iDivisor;
37679 u32 h = BITVEC_HASH(i++);
37700 SQLITE_PRIVATE int sqlite3BitvecSet(Bitvec *p, u32 i){
37701 u32 h;
37707 u32 bin = i/p->iDivisor;
37744 u32 *aiValues = sqlite3StackAllocRaw(0, sizeof(p->u.aHash));
37771 SQLITE_PRIVATE void sqlite3BitvecClear(Bitvec *p, u32 i, void *pBuf){
37776 u32 bin = i/p->iDivisor;
37787 u32 *aiValues = pBuf;
37793 u32 h = BITVEC_HASH(aiValues[j]-1);
37823 SQLITE_PRIVATE u32 sqlite3BitvecSize(Bitvec *p){
40223 SQLITE_PRIVATE int sqlite3WalFindFrame(Wal *, Pgno, u32 *);
40224 SQLITE_PRIVATE int sqlite3WalReadFrame(Wal *, u32, int, u8 *);
40238 SQLITE_PRIVATE void sqlite3WalSavepoint(Wal *pWal, u32 *aWalData);
40242 SQLITE_PRIVATE int sqlite3WalSavepointUndo(Wal *pWal, u32 *aWalData);
40718 u32 aWalData[WAL_SAVEPOINT_NDATA]; /* WAL savepoint context */
40921 u32 cksumInit; /* Quasi-random value added to every checksum */
40922 u32 nSubRec; /* Number of records written to sub-journal */
40944 u32 vfsFlags; /* Flags for sqlite3_vfs.xOpen() */
40945 u32 sectorSize; /* Assumed sector size during rollback */
41319 static int read32bits(sqlite3_file *fd, i64 offset, u32 *pRes){
41338 static int write32bits(sqlite3_file *fd, i64 offset, u32 val){
41444 static u32 pager_datahash(int nByte, unsigned char *pData){
41445 u32 hash = 0;
41452 static u32 pager_pagehash(PgHdr *pPage){
41503 static int readMasterJournal(sqlite3_file *pJrnl, char *zMaster, u32 nMaster){
41505 u32 len; /* Length in bytes of master journal name */
41507 u32 cksum; /* MJ checksum value read from journal */
41508 u32 u; /* Unsigned loop counter */
41642 u32 nHeader = (u32)pPager->pageSize;/* Size of buffer pointed to by zHeader */
41643 u32 nWrite; /* Bytes of header sector written */
41761 u32 *pNRec, /* OUT: Value read from the nRec field */
41762 u32 *pDbSize /* OUT: Value of original database size field */
41807 u32 iPageSize; /* Page-size field of journal header */
41808 u32 iSectorSize; /* Sector-size field of journal header */
41887 u32 cksum = 0; /* Checksum of string zMaster */
42353 static u32 pager_cksum(Pager *pPager, const u8 *aData){
42354 u32 cksum = pPager->cksumInit; /* Checksum value to return */
42425 u32 cksum; /* Checksum used for sanity checking */
42936 u32 nRec; /* Number of Records in the journal */
42937 u32 u; /* Unsigned loop counter */
43141 static int readDbPage(PgHdr *pPg, u32 iFrame){
43204 u32 change_counter;
43241 u32 iFrame = 0;
43595 u32 ii; /* Loop counter */
43596 u32 nJRec = 0; /* Number of Journal Records */
43597 u32 dummy;
43609 nJRec = (u32)((szJ - pPager->journalOff)/JOURNAL_PG_SZ(pPager));
43623 u32 ii; /* Loop counter */
43870 SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager *pPager, u32 *pPageSize, int nReserve){
43883 u32 pageSize = *pPageSize;
43887 && pageSize && pageSize!=(u32)pPager->pageSize
44803 u32 szPageDflt = SQLITE_DEFAULT_PAGE_SIZE; /* Default page size */
44953 szPageDflt = (u32)pPager->sectorSize;
45542 u32 iFrame = 0; /* Frame to read from WAL file */
45966 u32 cksum;
46066 if( pPager->sectorSize > (u32)pPager->pageSize ){
47802 u32 iVersion; /* Wal-index version */
47803 u32 unused; /* Unused (padding) field */
47804 u32 iChange; /* Counter incremented each transaction */
47808 u32 mxFrame; /* Index of last valid frame in the WAL */
47809 u32 nPage; /* Size of database in pages */
47810 u32 aFrameCksum[2]; /* Checksum of last frame in log */
47811 u32 aSalt[2]; /* Two salt values copied from WAL header */
47812 u32 aCksum[2]; /* Checksum over all prior fields */
47865 u32 nBackfill; /* Number of WAL frames backfilled into DB */
47866 u32 aReadMark[WAL_NREADER]; /* Reader marks */
47915 u32 iCallback; /* Value to pass to log callback (or 0) */
47919 volatile u32 **apWiData; /* Pointer to wal-index content in memory */
47920 u32 szPage; /* Database page size */
47932 u32 nCkpt; /* Checkpoint sequence counter in the wal-header */
47979 u32 *aPgno; /* Array of page numbers. */
48002 #define HASHTABLE_NPAGE_ONE (HASHTABLE_NPAGE - (WALINDEX_HDR_SIZE/sizeof(u32)))
48006 sizeof(ht_slot)*HASHTABLE_NSLOT + HASHTABLE_NPAGE*sizeof(u32) \
48018 static int walIndexPage(Wal *pWal, int iPage, volatile u32 **ppPage){
48023 int nByte = sizeof(u32*)*(iPage+1);
48024 volatile u32 **apNew;
48025 apNew = (volatile u32 **)sqlite3_realloc((void *)pWal->apWiData, nByte);
48031 sizeof(u32*)*(iPage+1-pWal->nWiData));
48039 pWal->apWiData[iPage] = (u32 volatile *)sqlite3MallocZero(WALINDEX_PGSZ);
48074 ** The argument to this macro must be of type u32. On a little-endian
48075 ** architecture, it returns the u32 value that results from interpreting
48098 const u32 *aIn, /* Initial checksum value input */
48099 u32 *aOut /* OUT: Final checksum value output */
48101 u32 s1, s2;
48102 u32 *aData = (u32 *)a;
48103 u32 *aEnd = (u32 *)&a[nByte];
48171 u32 iPage, /* Database page number for frame */
48172 u32 nTruncate, /* New db size (or 0 for non-commit frames) */
48177 u32 *aCksum = pWal->hdr.aFrameCksum;
48198 u32 *piPage, /* OUT: Database page number for frame */
48199 u32 *pnTruncate, /* OUT: New db size (or 0 if not commit) */
48204 u32 *aCksum = pWal->hdr.aFrameCksum;
48205 u32 pgno; /* Page number of the frame */
48314 static int walHash(u32 iPage){
48341 volatile u32 **paPgno, /* OUT: Pointer to page number array */
48342 u32 *piZero /* OUT: Frame associated with *paPgno[0] */
48345 volatile u32 *aPgno;
48351 u32 iZero;
48356 aPgno = &aPgno[WALINDEX_HDR_SIZE/sizeof(u32)];
48375 static int walFramePage(u32 iFrame){
48389 static u32 walFramePgno(Wal *pWal, u32 iFrame){
48392 return pWal->apWiData[0][WALINDEX_HDR_SIZE/sizeof(u32) + iFrame - 1];
48411 volatile u32 *aPgno = 0; /* Page number array for hash table */
48412 u32 iZero = 0; /* frame == (aHash[x]+iZero) */
48471 static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){
48473 u32 iZero = 0; /* One less than frame number of aPgno[1] */
48474 volatile u32 *aPgno = 0; /* Page number array */
48563 u32 aFrameCksum[2] = {0, 0};
48600 u32 magic; /* Magic value read from WAL header */
48601 u32 version; /* Magic value read from WAL header */
48659 u32 pgno; /* Database page number for frame */
48660 u32 nTruncate; /* dbsize field from frame header */
48839 u32 *piPage, /* OUT: The page number of the next page */
48840 u32 *piFrame /* OUT: Wal frame index of next page */
48842 u32 iMin; /* Result pgno must be greater than iMin */
48843 u32 iRet = 0xFFFFFFFF; /* 0xffffffff is never a valid page number */
48851 u32 iPg = pSegment->aPgno[pSegment->aIndex[pSegment->iNext]];
48891 const u32 *aContent, /* Pages in wal - keys for the sort */
48948 const u32 *aContent, /* Pages in wal */
49025 u32 iLast; /* Last frame in log */
49061 u32 iZero;
49062 volatile u32 *aPgno;
49074 nEntry = (int)((u32*)aHash - (u32*)aPgno);
49082 walMergesort((u32 *)aPgno, aTmp, aIndex, &nEntry);
49086 p->aSegment[i].aPgno = (u32 *)aPgno;
49168 u32 iDbpage = 0; /* Next database page to write */
49169 u32 iFrame = 0; /* Wal frame containing data for iDbpage */
49170 u32 mxSafeFrame; /* Max frame that can be backfilled */
49171 u32 mxPage; /* Max database page to write */
49199 u32 y = pInfo->aReadMark[i];
49219 u32 nBackfill = pInfo->nBackfill;
49402 u32 aCksum[2]; /* Checksum on the header content */
49462 volatile u32 *page0; /* Chunk of wal-index containing header */
49578 u32 mxReadMark; /* Largest aReadMark[] value */
49684 u32 thisMark = pInfo->aReadMark[i];
49802 u32 *piRead /* OUT: Frame number (or zero) */
49804 u32 iRead = 0; /* If !=0, WAL frame to return data from */
49805 u32 iLast = pWal->hdr.mxFrame; /* Last page in WAL for this reader */
49849 volatile u32 *aPgno; /* Pointer to array of page numbers */
49850 u32 iZero; /* Frame number corresponding to aPgno[0] */
49861 u32 iFrame = aHash[iKey] + iZero;
49877 u32 iRead2 = 0;
49878 u32 iTest;
49900 u32 iRead, /* Frame to read */
50033 ** Argument aWalData must point to an array of WAL_SAVEPOINT_NDATA u32
50038 SQLITE_PRIVATE void sqlite3WalSavepoint(Wal *pWal, u32 *aWalData){
50049 ** of WAL_SAVEPOINT_NDATA u32 values that has been previously populated
50052 SQLITE_PRIVATE int sqlite3WalSavepointUndo(Wal *pWal, u32 *aWalData){
50098 u32 salt1;
50113 u32 *aSalt = pWal->hdr.aSalt; /* Big-endian salt values */
50225 u32 iFrame; /* Next frame address */
50261 u32 aCksum[2]; /* Checksum for wal-header */
50504 u32 ret = 0;
51039 u32 pageSize; /* Total number of bytes on a page */
51040 u32 usableSize; /* Number of usable bytes on each page */
51042 u32 nPage; /* Number of pages in the database */
51076 u32 nData; /* Number of bytes of data */
51077 u32 nPayload; /* Total amount of payload */
52502 u32 nPayload; /* Number of bytes of cell payload */
52581 u32 nSize;
52621 nSize += (u32)(pIter - pCell);
53191 SQLITE_PRIVATE u32 sqlite3BtreeLastPage(Btree *p){
53438 assert( sizeof(u32)==4 );
53818 pBt->pageSize = (u32)pageSize;
53978 u32 pageSize;
53979 u32 usableSize;
54039 if( (u32)pageSize!=pBt->pageSize ){
55369 SQLITE_PRIVATE int sqlite3BtreeDataSize(BtCursor *pCur, u32 *pSize){
55517 u32 offset, /* Begin reading this far into payload */
55518 u32 amt, /* Read this many bytes */
55524 u32 nKey;
55567 const u32 ovflSize = pBt->usableSize - 4; /* Bytes content per ovfl page */
55714 SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
55731 SQLITE_PRIVATE int sqlite3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
55772 u32 *pAmt /* Write the number of available bytes here */
55799 SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor *pCur, u32 *pAmt){
55802 SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor *pCur, u32 *pAmt){
55816 static int moveToChild(BtCursor *pCur, u32 newPgno){
56559 u32 n; /* Number of pages on the freelist */
56560 u32 k; /* Number of leaves on the trunk of the freelist */
56647 }else if( k>(u32)(pBt->usableSize/4 - 2) ){
56716 u32 closest;
56720 u32 i;
56922 u32 nLeaf; /* Initial number of leaf cells on trunk page */
56932 if( nLeaf > (u32)pBt->usableSize/4 - 2 ){
56936 if( nLeaf < (u32)pBt->usableSize/4 - 8 ){
57006 u32 ovflPageSize;
57116 assert( info.nData==(u32)(nData+nZero) );
57233 u32 pc; /* Offset to cell content of cell being deleted */
57251 if( pc < (u32)get2byte(&data[hdr+5]) || pc+sz > pPage->pBt->usableSize ){
58266 u32 key = get4byte(&apNew[i]->aData[8]);
59176 SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *p, int idx, u32 *pMeta){
59202 SQLITE_PRIVATE int sqlite3BtreeUpdateMeta(Btree *p, int idx, u32 iMeta){
59551 u32 sz;
59667 u32 size = 65536;
59986 SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor *pCsr, u32 offset, u32 amt, void *z){
60114 u32 iDestSchema; /* Original schema cookie in destination */
60348 u32 newPgsz = nSrcPgsz;
61640 u32 offset, /* Offset from the start of data to return bytes from. */
61641 u32 amt, /* Number of bytes to return. */
61646 u32 available = 0; /* Number of bytes available on the local btree page */
62144 u32 t; /* a column type code */
62842 SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe *p, u32 addr, int val){
62844 if( ((u32)p->nOp)>addr ){
62853 SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe *p, u32 addr, int val){
62855 if( ((u32)p->nOp)>addr ){
62863 SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe *p, u32 addr, int val){
62865 if( ((u32)p->nOp)>addr ){
64246 u32 iRandom;
65037 SQLITE_PRIVATE u32 sqlite3VdbeSerialType(Mem *pMem, int file_format){
65039 u32 n;
65057 return ((i&1)==i && file_format>=4) ? 8+(u32)u : 1;
65070 n = (u32)pMem->n;
65080 SQLITE_PRIVATE u32 sqlite3VdbeSerialTypeLen(u32 serial_type){
65127 u32 i[2];
65129 u32 t;
65155 SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(u8 *buf, Mem *pMem, u32 serial_type){
65156 u32 len;
65161 u32 i;
65196 #define FOUR_BYTE_UINT(x) (((u32)(x)[0]<<24)|((x)[1]<<16)|((x)[2]<<8)|(x)[3])
65202 SQLITE_PRIVATE u32 sqlite3VdbeSerialGet(
65204 u32 serial_type, /* Serial type to deserialize */
65208 u32 y;
65284 u32 len = (serial_type-12)/2;
65354 u32 idx; /* Offset in aKey[] to read from */
65356 u32 szHdr;
65365 u32 serial_type;
65393 u32 d1; /* Offset into aKey[] of next data element */
65394 u32 idx1; /* Offset into aKey[] of next header element */
65395 u32 szHdr1; /* Number of bytes in header */
65424 u32 serial_type1;
65435 if( d1+serial_type1+2>(u32)nKey1
65436 && d1+sqlite3VdbeSerialTypeLen(serial_type1)>(u32)nKey1
65607 static i64 vdbeRecordDecodeInt(u32 serial_type, const u8 *aKey){
65608 u32 y;
65665 u32 d1; /* Offset into aKey[] of next data element */
65667 u32 szHdr1; /* Size of record header in bytes */
65668 u32 idx1; /* Offset of first type in header */
65679 u32 s1;
65702 u32 serial_type;
65862 u32 y;
66065 u32 szHdr; /* Size of the header */
66066 u32 typeRowid; /* Serial type of the rowid */
66067 u32 lenRowid; /* Size of the rowid */
66084 rc = sqlite3VdbeMemFromBtree(pCur, 0, (u32)nCellKey, 1, &m);
66112 testcase( (u32)m.n==szHdr+lenRowid );
66113 if( unlikely((u32)m.n<szHdr+lenRowid) ){
66162 rc = sqlite3VdbeMemFromBtree(pC->pCursor, 0, (u32)nCellKey, 1, &m);
66247 v->expmask |= ((u32)1 << (iVar-1));
67328 ((i<32 && p->expmask & ((u32)1 << i)) || p->expmask==0xffffffff)
67617 u32 v = pVdbe->aCounter[op];
68126 ROUND8(sizeof(VdbeCursor)) + 2*sizeof(u32)*nField +
68141 &pMem->z[ROUND8(sizeof(VdbeCursor))+2*sizeof(u32)*nField];
70336 u32 *aType; /* aType[i] holds the numeric type of the i-th column */
70337 u32 *aOffset; /* aOffset[i] is offset to start of data for i-th column */
70345 u32 offset; /* Offset into the data */
70346 u32 szField; /* Number of bytes in the content of a field */
70347 u32 avail; /* Number of bytes of available data */
70348 u32 t; /* A type code from the record header */
70395 pC->payloadSize = (u32)payloadSize64;
70403 if( pC->payloadSize <= (u32)avail ){
70408 if( pC->payloadSize > (u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
70485 pC->iHdrOffset = (u32)(zHdr - zData);
70632 u32 serial_type; /* Type field */
71108 sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&iMeta);
71164 sqlite3BtreeGetMeta(db->aDb[iDb].pBt, iCookie, (u32 *)&iMeta);
71280 if( pCur && pCur->pgnoRoot==(u32)pOp->p2 ){
72365 u32 n;
72400 n = (u32)n64;
72404 if( n>(u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
74620 u32 type = pC->aType[p->iCol];
74911 int (*xCall)(BtCursor*, u32, u32, void*)
77155 pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
77159 pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
78878 u32 n = sqlite3Strlen30(z);
79072 u32 staticFlag = 0;
79832 SQLITE_PRIVATE int sqlite3FindInIndex(Parse *pParse, Expr *pX, u32 inFlags, int *prRhsHasNull){
79936 u32 savedNQueryLoop = pParse->nQueryLoop;
80997 u32 constMask = 0; /* Mask of function arguments that are constant */
82167 u32 combinedFlags;
83706 u32 nRowid; /* Sizeof aRowid[] */
83709 u32 iHash; /* Tiebreaker hash */
83719 u32 iPrn; /* Pseudo-random number used for sampling */
87223 u32 h = 0;
89611 if( (u32)pSrc->nSrc+nExtra>pSrc->nAlloc ){
91475 u32 mask; /* Mask of OLD.* columns in use */
92305 u32 esc /* The escape character */
92307 u32 c, c2;
92361 u32 prior_c = 0;
92444 u32 escape = 0;
94446 #define COLUMN_MASK(x) (((x)>31) ? 0xffffffff : ((u32)1<<(x)))
94452 SQLITE_PRIVATE u32 sqlite3FkOldmask(
94456 u32 mask = 0;
98298 u32 iArg; /* Extra argument */
100833 sqlite3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]);
101063 sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&cookie);
108173 SQLITE_PRIVATE u32 sqlite3TriggerColmask(
108183 u32 mask = 0;
108674 u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0);
109277 u32 meta;
110599 u32 wsFlags; /* WHERE_* flags describing the plan */
110757 u32 opMask; /* Acceptable operators */
111450 u32 opMask, /* Operator(s) to scan for */
111505 u32 op, /* Mask of WO_xx values describing operator */
112595 assert( (u32)n==pLoop->u.btree.nEq );
113167 (u32)iLower, (u32)iUpper, nOut));
113725 u32 flags; /* Flags that describe this loop */
115187 u32 saved_wsFlags; /* Original value of pNew->wsFlags */
122819 u32 mask; /* Mask of the bit in sqlite3.flags to set/clear */
126695 typedef unsigned int u32; /* 4-byte unsigned integer */
126762 u32 nLeafAdd; /* Number of leaf blocks added this trans */
126852 u32 *aMatchinfo; /* Information about most recent match */
126969 u32 *aMI;
127086 SQLITE_PRIVATE int sqlite3Fts3EvalPhraseStats(Fts3Cursor *, Fts3Expr *, u32 *);
127200 u32 a;
127224 u32 a;
127237 *pi = (int)(a | ((u32)(*p & 0x0F) << 28));
130155 const u32 nMinMerge = 64; /* Minimum amount of incr-merge work to do */
132350 pE->aMI = (u32 *)sqlite3_malloc(pTab->nColumn * 3 * sizeof(u32));
132352 memset(pE->aMI, 0, pTab->nColumn * 3 * sizeof(u32));
132436 u32 *aiOut /* Array to write results into (see above) */
132445 aiOut[iCol*3 + 1] = (u32)pCsr->nDoc;
132446 aiOut[iCol*3 + 2] = (u32)pCsr->nDoc;
137519 u32 *pnWord /* IN/OUT: Incr. by number tokens inserted */
137646 u32 *aSz
137790 u32 *aSz, /* Sizes of deleted document written here */
140013 u32 *a, /* The integer values */
140029 u32 *a, /* Write the integer values */
140039 a[i] = (u32)(x & 0xffffffff);
140051 u32 *aSz /* Sizes of each column, in tokens */
140095 u32 *aSzIns, /* Size increases */
140096 u32 *aSzDel, /* Size decreases */
140101 u32 *a; /* Array of integers that becomes the BLOB */
140109 a = sqlite3_malloc( (sizeof(u32)+10)*nStat );
140127 memset(a, 0, sizeof(u32)*(nStat) );
140135 if( nChng<0 && a[0]<(u32)(-nChng) ){
140141 u32 x = a[i+1];
140212 u32 *aSz = 0;
140213 u32 *aSzIns = 0;
140214 u32 *aSzDel = 0;
140228 int nByte = sizeof(u32) * (p->nColumn+1)*3;
140229 aSz = (u32 *)sqlite3_malloc(nByte);
142183 u32 *aSzDel
142199 memset(aSzDel, 0, sizeof(u32) * (p->nColumn+1) * 2);
142237 u32 *aSzIns = 0; /* Sizes of inserted documents */
142238 u32 *aSzDel = 0; /* Sizes of deleted documents */
142484 u32 *aMatchinfo; /* Pre-allocated buffer */
143263 *pnDoc = (u32)nDoc;
143442 pInfo->aMatchinfo[0] = (u32)nDoc;
143455 u32 iVal;
143458 iVal = (u32)(((u32)(nToken&0xffffffff)+nDoc/2)/nDoc);
143474 pInfo->aMatchinfo[iCol] = (u32)nToken;
143517 ** 'matchinfo' data is an array of 32-bit unsigned integers (C type u32).
143548 int nMatchinfo = 0; /* Number of u32 elements in match-info */
143563 pCsr->aMatchinfo = (u32 *)sqlite3_malloc(sizeof(u32)*nMatchinfo + nArg + 1);
143569 memset(pCsr->aMatchinfo, 0, sizeof(u32)*nMatchinfo);
143909 int n = pCsr->nMatchinfo * sizeof(u32);
144750 typedef unsigned int u32;
144912 u32 anQueue[RTREE_MAX_DEPTH+1]; /* Number of queued entries by iLevel */
144925 u32 u; /* Unsigned for byte-order conversions */
145028 u32 magic; /* Always RTREE_GEOMETRY_MAGIC */
145049 u32 i = (
145050 (((u32)p[0]) << 24) +
145051 (((u32)p[1]) << 16) +
145052 (((u32)p[2]) << 8) +
145053 (((u32)p[3]) << 0)
145055 *(u32 *)pCoord = i;
145081 u32 i;
145083 assert( sizeof(u32)==4 );
145084 i = *(u32 *)pCoord;
145617 c.u = ((u32)a[0]<<24) + ((u32)a[1]<<16) \
145618 +((u32)a[2]<<8) + a[3]; \
146251 memset(pCsr->anQueue, 0, sizeof(u32)*(pRtree->iDepth + 1));