Lines Matching refs:sizeof
6718 #define ArraySize(X) ((int)(sizeof(X)/sizeof(X[0])))
6742 #define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v)))
9208 #define EXPR_FULLSIZE sizeof(Expr) /* Full size */
9288 #define BMS ((int)(sizeof(Bitmask)*8))
11581 memset(&tx, 0, sizeof(tx));
11663 memset(p, 0, sizeof(*p));
11721 sqlite3_snprintf(sizeof(zBuf), zBuf, "%04d-%02d-%02d %02d:%02d:%02d",
11741 sqlite3_snprintf(sizeof(zBuf), zBuf, "%02d:%02d:%02d", x.h, x.m, (int)x.s);
11760 sqlite3_snprintf(sizeof(zBuf), zBuf, "%04d-%02d-%02d", x.Y, x.M, x.D);
11831 testcase( n==sizeof(zBuf)-1 );
11832 testcase( n==sizeof(zBuf) );
11835 if( n<sizeof(zBuf) ){
12809 assert( pInt[nReserve/sizeof(int)]==(int)REARGUARD );
12835 assert( (sizeof(struct MemBlockHdr)&7) == 0 );
12898 totalSize = nReserve + sizeof(*pHdr) + sizeof(int) +
12899 mem.nBacktrace*sizeof(void*) + mem.nTitle;
12919 memcpy(pBt, &aAddr[1], pHdr->nBacktrace*sizeof(void*));
12933 pInt[nReserve/sizeof(int)] = REARGUARD;
12971 randomFill(z, sizeof(void*)*pHdr->nBacktraceSlots + sizeof(*pHdr) +
12972 pHdr->iSize + sizeof(int) + pHdr->nTitle);
13042 if( n>=sizeof(mem.zTitle) ) n = sizeof(mem.zTitle)-1;
13075 z -= pHdr->nBacktraceSlots*sizeof(void*) + pHdr->nTitle;
13476 assert( sizeof(Mem3Block)==8 );
13675 assert( sizeof(Mem3Block)==8 );
13677 mem3.nPool = (sqlite3GlobalConfig.nHeap / sizeof(Mem3Block)) - 2;
14275 assert( (sizeof(Mem5Link)&(sizeof(Mem5Link)-1))==0 );
14283 while( (int)sizeof(Mem5Link)>mem5.szAtom ){
14287 mem5.nBlock = (nByte / (mem5.szAtom+sizeof(u8)));
14433 sizeof(*pTo) - offsetof(sqlite3_mutex_methods, xMutexFree));
14647 pNew = sqlite3Malloc(sizeof(*pNew));
14656 assert( id-2 < (int)(sizeof(aStatic)/sizeof(aStatic[0])) );
14815 p = sqlite3MallocZero( sizeof(*p) );
14842 sqlite3_snprintf( sizeof(name), name, "\\SEM32\\SQLITE%04x",
14850 for( i = 0; i < sizeof(staticMutexes)/sizeof(staticMutexes[0]); i++ ){
14864 assert( iType-2 < sizeof(staticMutexes)/sizeof(staticMutexes[0]) );
15129 p = sqlite3MallocZero( sizeof(*p) );
15148 p = sqlite3MallocZero( sizeof(*p) );
15384 sInfo.dwOSVersionInfoSize = sizeof(sInfo);
15499 p = sqlite3MallocZero( sizeof(*p) );
15722 memset(&mem0, 0, sizeof(mem0));
15764 memset(&mem0, 0, sizeof(mem0));
16501 while( N>=(int)sizeof(zSpaces)-1 ){
16502 sqlite3StrAccumAppend(pAccum, zSpaces, sizeof(zSpaces)-1);
16503 N -= sizeof(zSpaces)-1;
16710 flag_longlong = sizeof(char*)==sizeof(i64);
16711 flag_long = sizeof(char*)==sizeof(long int);
17164 sqlite3StrAccumInit(&acc, zBase, sizeof(zBase),
17217 sqlite3StrAccumInit(&acc, zBase, sizeof(zBase), SQLITE_MAX_LENGTH);
17279 sqlite3StrAccumInit(&acc, zMsg, sizeof(zMsg), 0);
17308 sqlite3StrAccumInit(&acc, zBuf, sizeof(zBuf), 0);
17463 sizeof(sqlite3Prng)
17470 sizeof(sqlite3Prng)
17637 #define VdbeFrameMem(p) ((Mem *)&((u8 *)p)[ROUND8(sizeof(VdbeFrame))])
18337 memset(&m, 0, sizeof(m));
18363 memset(&m, 0, sizeof(m));
19613 if( new_size*sizeof(struct _ht)>SQLITE_MALLOC_SOFT_LIMIT ){
19614 new_size = SQLITE_MALLOC_SOFT_LIMIT/sizeof(struct _ht);
19624 new_ht = (struct _ht *)sqlite3Malloc( new_size*sizeof(struct _ht) );
19630 pH->htsize = new_size = sqlite3MallocSize(new_ht)/sizeof(struct _ht);
19631 memset(new_ht, 0, new_size*sizeof(struct _ht));
19764 new_elem = (HashElem*)sqlite3Malloc( sizeof(HashElem) );
20374 memset(&fsts3FileInfo, 0, sizeof(fsts3FileInfo));
20377 rc = DosQueryFileInfo( ((os2File*)id)->h, FIL_STANDARD, &fsts3FileInfo, sizeof(FILESTATUS3) );
20393 memset(&LockArea, 0, sizeof(LockArea));
20394 memset(&UnlockArea, 0, sizeof(UnlockArea));
20411 memset(&LockArea, 0, sizeof(LockArea));
20412 memset(&UnlockArea, 0, sizeof(UnlockArea));
20456 memset(&LockArea, 0, sizeof(LockArea));
20457 memset(&UnlockArea, 0, sizeof(UnlockArea));
20595 memset(&LockArea, 0, sizeof(LockArea));
20596 memset(&UnlockArea, 0, sizeof(UnlockArea));
20637 memset(&LockArea, 0, sizeof(LockArea));
20638 memset(&UnlockArea, 0, sizeof(UnlockArea));
20873 zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
20937 memset( pFile, 0, sizeof(*pFile) );
21050 memset( &fsts3ConfigInfo, 0, sizeof(fsts3ConfigInfo) );
21052 &fsts3ConfigInfo, sizeof(FILESTATUS3) );
21088 rc = DosLoadModule((PSZ)loadErr, sizeof(loadErr), zFilenameCp, &hmod);
21133 int sizeofULong = sizeof(ULONG);
21134 if( (int)sizeof(DATETIME) <= nBuf - n ){
21137 memcpy(&zBuf[n], &x, sizeof(x));
21138 n += sizeof(x);
21257 sizeof(os2File), /* szOsFile */
22039 pNew = sqlite3_malloc( sizeof(*pNew) + (n+1) );
22363 memset(&l, 0, sizeof(l));
22370 memset(&d, 0, sizeof(d));
22510 memset(&lockKey, 0, sizeof(lockKey));
22526 while( pLock && memcmp(&lockKey, &pLock->lockKey, sizeof(lockKey)) ){
22530 pLock = sqlite3_malloc( sizeof(*pLock) );
22535 memcpy(&pLock->lockKey,&lockKey,sizeof(lockKey));
22550 while( pOpen && memcmp(&fileId, &pOpen->fileId, sizeof(fileId)) ){
22554 pOpen = sqlite3_malloc( sizeof(*pOpen) );
22560 memset(pOpen, 0, sizeof(*pOpen));
23192 memset(pFile, 0, sizeof(unixFile));
25100 pNew->lockingContext = pCtx = sqlite3_malloc( sizeof(*pCtx) );
25238 for(i=0; i<sizeof(azDirs)/sizeof(azDirs[0]); i++){
25259 zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
25415 memset(p, 0, sizeof(unixFile));
25423 pUnused = sqlite3_malloc(sizeof(*pUnused));
25737 assert((size_t)nBuf>=(sizeof(time_t)+sizeof(int)));
25759 memcpy(zBuf, &t, sizeof(t));
25761 memcpy(&zBuf[sizeof(t)], &pid, sizeof(pid));
25762 assert( sizeof(t)+sizeof(pid)<=(size_t)nBuf );
25763 nBuf = sizeof(t) + sizeof(pid);
26072 memcpy(key, &t, sizeof(t));
26074 memcpy(&key[sizeof(t)], &pid, sizeof(pid));
26229 pNew = (unixFile *)sqlite3_malloc(sizeof(unixFile));
26233 memset(pNew, 0, sizeof(unixFile));
26251 pUnused = sqlite3_malloc(sizeof(*pUnused));
26284 pNew = (unixFile *)sqlite3_malloc(sizeof(*pNew));
26289 memset(pNew, 0, sizeof(unixFile));
26755 pCtx = sqlite3_malloc( sizeof(*pCtx) );
26759 memset(pCtx, 0, sizeof(*pCtx));
27022 sizeof(unixFile), /* szOsFile */ \
27074 for(i=0; i<(sizeof(aVfs)/sizeof(sqlite3_vfs)); i++){
27468 sInfo.dwOSVersionInfoSize = sizeof(sInfo);
27486 zWideFilename = malloc( nChar*sizeof(zWideFilename[0]) );
27532 nByte = MultiByteToWideChar(codepage, 0, zFilename, -1, NULL,0)*sizeof(WCHAR);
27533 zMbcsFilename = malloc( nByte*sizeof(zMbcsFilename[0]) );
27668 ZeroMemory(&pFile->local, sizeof(pFile->local));
27694 PAGE_READWRITE, 0, sizeof(winceLock),
27708 FILE_MAP_READ|FILE_MAP_WRITE, 0, 0, sizeof(winceLock));
27727 ZeroMemory(pFile->shared, sizeof(winceLock));
28172 sqlite3_randomness(sizeof(lk), &lk);
28549 zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
28741 memset(pFile, 0, sizeof(*pFile));
28899 zTemp = malloc( nByte*sizeof(zTemp[0]) );
28916 zTemp = malloc( nByte*sizeof(zTemp[0]) );
29072 if( sizeof(SYSTEMTIME)<=nBuf-n ){
29075 memcpy(&zBuf[n], &x, sizeof(x));
29076 n += sizeof(x);
29078 if( sizeof(DWORD)<=nBuf-n ){
29080 memcpy(&zBuf[n], &pid, sizeof(pid));
29081 n += sizeof(pid);
29083 if( sizeof(DWORD)<=nBuf-n ){
29085 memcpy(&zBuf[n], &cnt, sizeof(cnt));
29086 n += sizeof(cnt);
29088 if( sizeof(LARGE_INTEGER)<=nBuf-n ){
29091 memcpy(&zBuf[n], &i, sizeof(i));
29092 n += sizeof(i);
29209 sizeof(winFile), /* szOsFile */
29278 #define BITVEC_SZ (sizeof(void*)*128) /* 512 on 32bit. 1024 on 64bit */
29282 #define BITVEC_USIZE (((BITVEC_SZ-(3*sizeof(u32)))/sizeof(Bitvec*))*sizeof(Bitvec*))
29292 #define BITVEC_NELEM (BITVEC_USIZE/sizeof(BITVEC_TELEM))
29297 #define BITVEC_NINT (BITVEC_USIZE/sizeof(u32))
29307 #define BITVEC_NPTR (BITVEC_USIZE/sizeof(Bitvec *))
29354 assert( sizeof(*p)==BITVEC_SZ );
29355 p = sqlite3MallocZero( sizeof(*p) );
29447 u32 *aiValues = sqlite3StackAllocRaw(0, sizeof(p->u.aHash));
29451 memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash));
29452 memset(p->u.apSub, 0, sizeof(p->u.apSub));
29491 memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash));
29492 memset(p->u.aHash, 0, sizeof(p->u.aHash));
29606 sqlite3_randomness(sizeof(i), &i);
29806 SQLITE_PRIVATE int sqlite3PcacheSize(void){ return sizeof(PCache); }
29822 memset(p, 0, sizeof(PCache));
29867 nByte = pCache->szPage + pCache->szExtra + sizeof(PgHdr);
29911 memset(pPage, 0, sizeof(PgHdr) + pCache->szExtra);
29913 pPage->pData = (void *)&((char *)pPage)[sizeof(PgHdr) + pCache->szExtra];
30129 memset(a, 0, sizeof(a));
30328 ** size of the allocation is sizeof(PgHdr1)+PCache1.szPage byte). The
30429 int nByte = sizeof(PgHdr1) + pCache->szPage;
30504 apNew = (PgHdr1 **)sqlite3_malloc(sizeof(PgHdr1 *)*nNew);
30508 memset(apNew, 0, sizeof(PgHdr1 *)*nNew);
30629 memset(&pcache1, 0, sizeof(pcache1));
30645 memset(&pcache1, 0, sizeof(pcache1));
30656 pCache = (PCache1 *)sqlite3_malloc(sizeof(PCache1));
30658 memset(pCache, 0, sizeof(PCache1));
31082 ((ROWSET_ALLOCATION_SIZE-8)/sizeof(struct RowSetEntry))
31135 assert( N >= ROUND8(sizeof(*p)) );
31142 p->pFresh = (struct RowSetEntry*)(ROUND8(sizeof(*p)) + (char*)p);
31143 p->nFresh = (u16)((N - ROUND8(sizeof(*p)))/sizeof(struct RowSetEntry));
31180 pNew = sqlite3DbMallocRaw(p->db, sizeof(*pNew));
31254 memset(aBucket, 0, sizeof(aBucket));
31266 for(i=0; i<sizeof(aBucket)/sizeof(aBucket[0]); i++){
31876 int rc = sqlite3OsRead(fd, ac, sizeof(ac), offset);
32127 rc = sqlite3OsWrite(pPager->jfd, zeroHdr, sizeof(zeroHdr), 0);
32214 memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
32215 put32bits(&zHeader[sizeof(aJournalMagic)], 0xffffffff);
32217 memset(zHeader, 0, sizeof(aJournalMagic)+4);
32221 sqlite3_randomness(sizeof(pPager->cksumInit), &pPager->cksumInit);
32222 put32bits(&zHeader[sizeof(aJournalMagic)+4], pPager->cksumInit);
32224 put32bits(&zHeader[sizeof(aJournalMagic)+8], pPager->dbOrigSize);
32226 put32bits(&zHeader[sizeof(aJournalMagic)+12], pPager->sectorSize);
32229 put32bits(&zHeader[sizeof(aJournalMagic)+16], pPager->pageSize);
32236 memset(&zHeader[sizeof(aJournalMagic)+20], 0,
32237 nHeader-(sizeof(aJournalMagic)+20));
32311 rc = sqlite3OsRead(pPager->jfd, aMagic, sizeof(aMagic), iHdrOff);
32315 if( memcmp(aMagic, aJournalMagic, sizeof(aMagic))!=0 ){
33018 memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers));
34177 u8 zHeader[sizeof(aJournalMagic)+4];
34179 memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
34180 put32bits(&zHeader[sizeof(aJournalMagic)], pPager->nRec);
34211 pPager->jfd, zHeader, sizeof(zHeader), pPager->journalHdr
34331 memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers));
34613 ** Pager object (sizeof(Pager) bytes)
34622 ROUND8(sizeof(*pPager)) + /* Pager structure */
34635 pPager->pPCache = (PCache*)(pPtr += ROUND8(sizeof(*pPager)));
34777 /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */
34928 memcpy(&pPager->dbFileVers, dbFileVers, sizeof(pPager->dbFileVers));
35117 char dbFileVers[sizeof(pPager->dbFileVers)];
35127 IOTRACE(("CKVERS %p %d\n", pPager, sizeof(dbFileVers)));
35128 rc = sqlite3OsRead(pPager->fd, &dbFileVers, sizeof(dbFileVers), 24);
35133 memset(dbFileVers, 0, sizeof(dbFileVers));
35136 if( memcmp(pPager->dbFileVers, dbFileVers, sizeof(dbFileVers))!=0 ){
36341 pPager->aSavepoint, sizeof(PagerSavepoint)*nSavepoint
36346 memset(&aNew[nCurrent], 0, (nSavepoint-nCurrent) * sizeof(PagerSavepoint));
37096 #define EXTRA_SIZE sizeof(MemPage)
38095 pLock = (BtLock *)sqlite3MallocZero(sizeof(BtLock));
38435 aSpace, sizeof(aSpace));
39488 p = sqlite3MallocZero(sizeof(Btree));
39560 assert( sizeof(i64)==8 || sizeof(i64)==4 );
39561 assert( sizeof(u64)==8 || sizeof(u64)==4 );
39562 assert( sizeof(u32)==4 );
39563 assert( sizeof(u16)==2 );
39564 assert( sizeof(Pgno)==4 );
39566 pBt = sqlite3MallocZero( sizeof(*pBt) );
39574 rc = sqlite3PagerReadFileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader);
40143 memcpy(data, zMagicHeader, sizeof(zMagicHeader));
40144 assert( sizeof(zMagicHeader)==16 );
41135 ** to users so they cannot do the sizeof() themselves - they must call
41139 return ROUND8(sizeof(BtCursor));
41233 memset(&info, 0, sizeof(info));
41235 assert( memcmp(&info, &pCur->info, sizeof(info))==0 );
41514 pCur->aOverflow = (Pgno *)sqlite3MallocZero(sizeof(Pgno)*nOvfl);
43099 assert( j<(int)(sizeof(pPage->aOvfl)/sizeof(pPage->aOvfl[0])) );
43531 memset(apOld, 0, (i+1)*sizeof(MemPage*));
43574 k = pBt->pageSize + ROUND8(sizeof(MemPage));
43576 nMaxCells*sizeof(u8*) /* apCell */
43577 + nMaxCells*sizeof(u16) /* szCell */
43615 memcpy(pOld, apOld[i], sizeof(MemPage));
44095 memcpy(pChild->aOvfl, pRoot->aOvfl, pRoot->nOverflow*sizeof(pRoot->aOvfl[0]));
45190 sqlite3_snprintf(sizeof
45225 sqlite3_snprintf(sizeof(zContext), zContext,
45274 sqlite3_snprintf(sizeof(zContext), zContext,
45422 sCheck.anRef = sqlite3Malloc( (sCheck.nPage+1)*sizeof(sCheck.anRef[0]) );
45433 sqlite3StrAccumInit(&sCheck.errMsg, zErr, sizeof(zErr), 20000);
45775 pParse = sqlite3StackAllocZero(pErrorDb, sizeof(*pParse));
45835 p = (sqlite3_backup *)sqlite3_malloc(sizeof(sqlite3_backup));
45843 memset(p, 0, sizeof(sqlite3_backup));
46285 memset(&b, 0, sizeof(b));
46560 memset(&ctx, 0, sizeof(ctx));
46568 memcpy(pMem, &ctx.s, sizeof(ctx.s));
46951 memcpy(pTo, pFrom, sizeof(Mem));
47145 memset(&c1, 0, sizeof(c1));
47146 memset(&c2, 0, sizeof(c2));
47281 Mem *p = sqlite3DbMallocZero(db, sizeof(*p));
47449 p = sqlite3DbMallocZero(db, sizeof(Vdbe) );
47525 int nNew = (p->nOpAlloc ? p->nOpAlloc*2 : (int)(1024/sizeof(Op)));
47526 pNew = sqlite3DbRealloc(p->db, p->aOp, nNew*sizeof(Op));
47528 p->nOpAlloc = sqlite3DbMallocSize(p->db, pNew)/sizeof(Op);
47647 n*sizeof(p->aLabel[0]));
47648 p->nLabelAlloc = sqlite3DbMallocSize(p->db, p->aLabel)/sizeof(p->aLabel[0]);
47687 ** memset(&sIter, 0, sizeof(sIter));
47728 int nByte = (p->nSub+1)*sizeof(SubProgram*);
47771 memset(&sIter, 0, sizeof(sIter));
48088 memset(pOp, 0, sizeof(pOp[0]));
48153 nByte = sizeof(*pKeyInfo) + (nField-1)*sizeof(pKeyInfo->aColl[0]) + nField;
48368 assert( i>=0 && i<p->db->nDb && i<sizeof(u32)*8 );
48369 assert( i<(int)sizeof(p->btreeMask)*8 );
48387 zP4 = displayP4(pOp, zPtr, sizeof(zPtr));
48514 nSub = pSub->n/sizeof(Vdbe*);
48569 int nByte = (nSub+1)*sizeof(SubProgram*);
48578 pSub->n = nSub*sizeof(SubProgram*);
48681 sqlite3_snprintf(sizeof(z), z, "%s", pOp->p4.z);
48819 p->aMem = allocSpace(p->aMem, nMem*sizeof(Mem), &zCsr, zEnd, &nByte);
48820 p->aVar = allocSpace(p->aVar, nVar*sizeof(Mem), &zCsr, zEnd, &nByte);
48821 p->apArg = allocSpace(p->apArg, nArg*sizeof(Mem*), &zCsr, zEnd, &nByte);
48822 p->azVar = allocSpace(p->azVar, nVar*sizeof(char*), &zCsr, zEnd, &nByte);
48823 p->apCsr = allocSpace(p->apCsr, nCursor*sizeof(VdbeCursor*),
48989 p->aColName = pColName = (Mem*)sqlite3DbMallocZero(db, sizeof(Mem)*n );
49135 sqlite3_randomness(sizeof(iRandom), &iRandom);
49972 assert( sizeof(v)==sizeof(pMem->r) );
49973 memcpy(&v, &pMem->r, sizeof(v));
50067 assert( sizeof(r1)==sizeof(t2) && memcmp(&r1, &t2, sizeof(r1))==0 );
50077 assert( sizeof(x)==8 && sizeof(pMem->r)==8 );
50079 memcpy(&pMem->r, &x, sizeof(x));
50145 nByte = ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*(pKeyInfo->nField+1);
50156 p->aMem = pMem = (Mem*)&((char*)p)[ROUND8(sizeof(UnpackedRecord))];
50356 memset(&m, 0, sizeof(m));
50434 memset(&m, 0, sizeof(m));
51088 int nMalloc = sizeof(VdbeFunc) + sizeof(struct AuxData)*iArg;
51094 memset(&pVdbeFunc->apAux[nAux], 0, sizeof(struct AuxData)*(iArg+1-nAux));
51858 sqlite3StrAccumInit(&out, zBase, sizeof(zBase),
51898 memset(&utf8, 0, sizeof(utf8));
52131 ROUND8(sizeof(VdbeCursor)) +
52133 2*nField*sizeof(u32);
52142 memset(pCx, 0, sizeof(VdbeCursor));
52146 pCx->aType = (u32 *)&pMem->z[ROUND8(sizeof(VdbeCursor))];
52150 &pMem->z[ROUND8(sizeof(VdbeCursor))+2*nField*sizeof(u32)];
52758 char aTempRec[ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*3 + 7];
54502 memset(&u.am.sMem, 0, sizeof(u.am.sMem));
54982 u.aq.pNew = sqlite3DbMallocRaw(db, sizeof(Savepoint)+u.aq.nName+1);
55864 char aTempRec[ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*3 + 7];
55890 u.bb.aTempRec, sizeof(u.bb.aTempRec));
56195 sqlite3_randomness(sizeof(u.be.v), &u.be.v);
57182 u.bv.aRoot = sqlite3DbMallocRaw(db, sizeof(int)*(u.bv.nRoot+1) );
57382 u.by.nByte = ROUND8(sizeof(VdbeFrame))
57383 + u.by.nMem * sizeof(Mem)
57384 + u.by.pProgram->nCsr * sizeof(VdbeCursor *);
57949 memset(&u.ch.sContext, 0, sizeof(u.ch.sContext));
58376 pParse = sqlite3StackAllocRaw(db, sizeof(*pParse));
58382 memset(pParse, 0, sizeof(Parse));
58466 sqlite3VdbeAddOpList(v, sizeof(openBlob)/sizeof(VdbeOpList), openBlob);
58538 pBlob = (Incrblob *)sqlite3DbMallocZero(db, sizeof(Incrblob));
58902 return (pVfs->szOsFile+sizeof(JournalFile));
58938 #define JOURNAL_CHUNKSIZE ((int)(1024-sizeof(FileChunk*)))
59046 FileChunk *pNew = sqlite3_malloc(sizeof(FileChunk));
59162 return sizeof(MemJournal);
59396 memcpy(pExpr, pDup, sizeof(*pExpr));
59975 memset(&nc, 0, sizeof(nc));
60266 memset(&sNC, 0, sizeof(sNC));
60893 pNew = sqlite3DbMallocZero(db, sizeof(Expr)+nExtra);
61093 pParse->nVarExprAlloc*sizeof(pParse->apVarExpr[0])
61347 pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
61351 pNew->a = pItem = sqlite3DbMallocRaw(db, p->nExpr*sizeof(p->a[0]) );
61383 nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0);
61415 pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
61418 pNew->a = sqlite3DbMallocRaw(db, p->nId*sizeof(p->a[0]) );
61434 pNew = sqlite3DbMallocRaw(db, sizeof(*p) );
61478 pList = sqlite3DbMallocZero(db, sizeof(ExprList) );
61487 a = sqlite3DbRealloc(db, pList->a, n*sizeof(pList->a[0]));
61492 pList->nAlloc = sqlite3DbMallocSize(db, a)/sizeof(a[0]);
61497 memset(pItem, 0, sizeof(*pItem));
62120 memset(&keyInfo, 0, sizeof(keyInfo));
62736 sizeof(pParse->aAlias[0])*pParse->nAlias );
62740 (pParse->nAlias-pParse->nAliasAlloc)*sizeof(pParse->aAlias[0]));
63983 sizeof(pInfo->aCol[0]),
64001 sizeof(pInfo->aFunc[0]),
64995 pNew = (Table*)sqlite3DbMallocZero(db, sizeof(Table));
65004 pNew->aCol = (Column*)sqlite3DbMallocZero(db, sizeof(Column)*nAlloc);
65010 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
65631 static const int sz = sizeof(IndexSample)*SQLITE_INDEX_SAMPLES;
65794 aNew = sqlite3DbMallocRaw(db, sizeof(db->aDb[0])*3 );
65796 memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2);
65798 aNew = sqlite3DbRealloc(db, db->aDb, sizeof(db->aDb[0])*(db->nDb+1) );
65803 memset(aNew, 0, sizeof(*aNew));
65937 sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
65941 sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
65945 sqlite3_snprintf(sizeof(zErr), zErr,
65950 sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
65983 memset(&sName, 0, sizeof(NameContext));
66551 nBytes = sizeof(TableLock) * (pToplevel->nTableLock+1);
66705 # define SAVE_SZ (sizeof(Parse) - offsetof(Parse,nVar))
66927 memset(&db->aDb[j], 0, (db->nDb-j)*sizeof(db->aDb[j]));
66930 memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0]));
67286 pTable = sqlite3DbMallocZero(db, sizeof(Table));
67427 aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
67435 memset(pCol, 0, sizeof(p->aCol[0]));
67874 assert( pCol->affinity-SQLITE_AFF_TEXT < sizeof(azType)/sizeof(azType[0]) );
67940 memset(&sNC, 0, sizeof(sNC));
67941 memset(&sSrc, 0, sizeof(sSrc));
68652 nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
69035 sizeof(Index) + /* Index structure */
69036 sizeof(int)*nCol + /* Index.aiColumn */
69037 sizeof(int)*(nCol+1) + /* Index.aiRowEst */
69038 sizeof(char *)*nCol + /* Index.azColl */
69039 sizeof(u8)*nCol + /* Index.aSortOrder */
69464 pList = sqlite3DbMallocZero(db, sizeof(IdList) );
69471 sizeof(pList->a[0]),
69550 sizeof(*pSrc) + (nAlloc-1)*sizeof(pSrc->a[0]) );
69556 nGot = (sqlite3DbMallocSize(db, pNew) - sizeof(*pSrc))/sizeof(pSrc->a[0])+1;
69568 memset(&pSrc->a[iStart], 0, sizeof(pSrc->a[0])*nExtra);
69621 pList = sqlite3DbMallocZero(db, sizeof(SrcList) );
70153 int nBytes = sizeof(KeyInfo) + (nCol-1)*sizeof(CollSeq*) + nCol;
70237 memcpy(pColl, pColl2, sizeof(CollSeq));
70336 pColl = sqlite3DbMallocZero(db, 3*sizeof(*pColl) + nName + 1 );
70557 (pBest = sqlite3DbMallocZero(db, sizeof(*pBest)+nName+1))!=0 ){
70613 p = (Schema *)sqlite3BtreeSchema(pBt, sizeof(Schema), sqlite3SchemaFree);
70615 p = (Schema *)sqlite3MallocZero(sizeof(Schema));
70868 memset(&sContext, 0, sizeof(sContext));
70951 memset(&sNC, 0, sizeof(sNC));
71657 sqlite3_randomness(sizeof(r), &r);
72275 azChar = contextMalloc(context, ((i64)nChar)*(sizeof(char*)+1));
72431 p = sqlite3_aggregate_context(context, sizeof(*p));
72440 int s1 = (int)(p->iSum >> (sizeof(i64)*8-1));
72441 int s2 = (int)(v >> (sizeof(i64)*8-1));
72442 int s3 = (int)(iNewSum >> (sizeof(i64)*8-1));
72493 p = sqlite3_aggregate_context(context, sizeof(*p));
72526 pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest));
72575 pAccum = (StrAccum*)sqlite3_aggregate_context(context, sizeof(*pAccum));
73012 aiCol = (int *)sqlite3DbMallocRaw(pParse->db, nCol*sizeof(int));
73333 memset(&sNameContext, 0, sizeof(NameContext));
73865 sizeof(Trigger) + /* struct Trigger */
73866 sizeof(TriggerStep) + /* Single step in trigger program */
74189 pInfo = sqlite3DbMallocRaw(pParse->db, sizeof(*pInfo));
74464 memset(&dest, 0, sizeof(dest));
74653 memset(&sNC, 0, sizeof(sNC));
74743 aRegIdx = sqlite3DbMallocRaw(db, sizeof(int)*(nIdx+1));
75878 azCols = sqlite3DbMallocZero(db, 2*nCol*sizeof(const char*) + 1);
76743 aHandle = sqlite3DbMallocZero(db, sizeof(handle)*(db->nExtension+1));
76748 memcpy(aHandle, db->aExtension, sizeof(handle)*db->nExtension);
76863 int nByte = (wsdAutoext.nExt+1)*sizeof(wsdAutoext.aExt[0]);
77087 i64 *pI64 = sqlite3DbMallocRaw(pParse->db, sizeof(value));
77089 memcpy(pI64, &value, sizeof(value));
77436 eMode = sizeof(azModeName)/sizeof(azModeName[0]) - 1;
78903 pParse = sqlite3StackAllocZero(db, sizeof(*pParse));
79294 pNew = sqlite3DbMallocZero(db, sizeof(*pNew) );
79298 memset(pNew, 0, sizeof(*pNew));
79986 pInfo = sqlite3DbMallocZero(db, sizeof(*pInfo) + nExpr*(sizeof(CollSeq*)+1) );
80401 aCol = *paCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol);
80494 memset(&sNC, 0, sizeof(sNC));
80525 pTab = sqlite3DbMallocZero(db, sizeof(Table) );
80979 sizeof(*pKeyInfo)+nCol*(sizeof(CollSeq*) + 1));
81351 aPermute = sqlite3DbMallocRaw(db, sizeof(int)*nOrderBy);
81359 sqlite3DbMallocRaw(db, sizeof(*pKeyMerge)+nOrderBy*(sizeof(CollSeq*)+1));
81399 sizeof(*pKeyDup) + nExpr*(sizeof(CollSeq*)+1) );
82087 memset(&pSubSrc->a[i], 0, sizeof(pSubSrc->a[i]));
82325 pFrom->pTab = pTab = sqlite3DbMallocZero(db, sizeof(Table));
82818 memset(&sAggInfo, 0, sizeof(sAggInfo));
83041 memset(&sNC, 0, sizeof(sNC));
83575 azNew = sqlite3_realloc( p->azResult, sizeof(char*)*p->nAlloc );
83653 res.azResult = sqlite3_malloc(sizeof(char*)*res.nAlloc );
83660 assert( sizeof(res.azResult[0])>= sizeof(res.nData) );
83681 azNew = sqlite3_realloc( res.azResult, sizeof(char*)*res.nData );
83935 pTrigger = (Trigger*)sqlite3DbMallocZero(db, sizeof(Trigger));
84047 TriggerStep *pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep));
84071 pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep) + pName->n);
84518 pPrg = sqlite3DbMallocZero(db, sizeof(TriggerPrg));
84522 pPrg->pProgram = pProgram = sqlite3DbMallocZero(db, sizeof(SubProgram));
84532 pSubParse = sqlite3StackAllocZero(db, sizeof(Parse));
84534 memset(&sNC, 0, sizeof(sNC));
84938 memset(&sContext, 0, sizeof(sContext));
84974 aXRef = sqlite3DbMallocRaw(db, sizeof(int) * pTab->nCol );
84989 memset(&sNC, 0, sizeof(sNC));
85046 aRegIdx = sqlite3DbMallocRaw(db, sizeof(Index*) * nIdx );
85835 pMod = (Module *)sqlite3DbMallocRaw(db, sizeof(Module) + nName + 1);
86044 int nBytes = sizeof(char *)*(1+pTable->nModuleArg);
86250 pVTable = sqlite3DbMallocZero(db, sizeof(VTable));
86378 int nBytes = sizeof(sqlite3_vtab *) * (db->nVTrans + ARRAY_INCR);
86383 memset(&aVTrans[db->nVTrans], 0, sizeof(sqlite3_vtab *)*ARRAY_INCR);
86455 pParse = sqlite3StackAllocZero(db, sizeof(*pParse));
86702 pNew = sqlite3DbMallocZero(db, sizeof(*pNew)
86731 n = (pToplevel->nVtabLock+1)*sizeof(pToplevel->apVtabLock[0]);
87074 pWC->a = sqlite3DbMallocRaw(db, sizeof(pWC->a[0])*pWC->nSlot*2 );
87082 memcpy(pWC->a, pOld, sizeof(pWC->a[0])*pWC->nTerm);
87086 pWC->nSlot = sqlite3DbMallocSize(db, pWC->a)/sizeof(pWC->a[0]);
87127 #define initMaskSet(P) memset(P, 0, sizeof(*P))
87135 assert( pMaskSet->n<=sizeof(Bitmask)*8 );
87606 pTerm->u.pOrInfo = pOrInfo = sqlite3DbMallocZero(db, sizeof(*pOrInfo));
87627 pAndInfo = sqlite3DbMallocRaw(db, sizeof(*pAndInfo));
88431 pIdxInfo = sqlite3DbMallocZero(pParse->db, sizeof(*pIdxInfo)
88432 + (sizeof(*pIdxCons) + sizeof(*pUsage))*nTerm
88433 + sizeof(*pIdxOrderBy)*nOrderBy );
88569 memset(pCost, 0, sizeof(*pCost));
88624 memset(pUsage, 0, sizeof(pUsage[0])*pIdxInfo->nConstraint);
88968 memset(pCost, 0, sizeof(*pCost));
88991 memset(&sPk, 0, sizeof(Index));
89419 sizeof(pLevel->u.in.aInLoop[0])*pLevel->u.in.nIn);
90037 sizeof(*pOrTab)+ nNotReady*sizeof(pOrTab->a[0]));
90041 memcpy(pOrTab->a, pTabItem, sizeof(*pTabItem));
90044 memcpy(&pOrTab->a[k], &origSrc[pLevel[k].iFrom], sizeof(pOrTab->a[k]));
90341 nByteWInfo = ROUND8(sizeof(WhereInfo)+(nTabList-1)*sizeof(WhereLevel));
90344 sizeof(WhereClause) +
90345 sizeof(WhereMaskSet)
90453 memset(&bestPlan, 0, sizeof(bestPlan));
90687 if( n+nQPlan < sizeof(sqlite3_query_plan)-10 ){
90704 if( n+nQPlan < sizeof(sqlite3_query_plan)-2 ){
92175 pNew = realloc(p->yystack, newSize*sizeof(pNew[0]));
92203 pParser = (yyParser*)(*mallocProc)( (size_t)sizeof(yyParser) );
92401 if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
92901 && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){
92921 /*memset(&yygotominor, 0, sizeof(yygotominor));*/
93278 {yygotominor.yy65 = sqlite3DbMallocZero(pParse->db, sizeof(*yygotominor.yy65));}
93570 {memset(&yygotominor.yy346,0,sizeof(yygotominor.yy346));}
94136 /*memset(&yyminorunion, 0, sizeof(yyminorunion));*/
95606 memset(pHash, 0, sizeof(sqlite3GlobalFunctions));
95647 assert(sizeof(x)==8);
95648 assert(sizeof(x)==sizeof(y));
95802 memset(&sqlite3GlobalConfig.m, 0, sizeof(sqlite3GlobalConfig.m));
95870 if( sz<=(int)sizeof(LookasideSlot*) ) sz = 0;
95890 assert( sz > (int)sizeof(LookasideSlot*) );
96231 if( ALWAYS(rc>=0) && rc<(int)(sizeof(aMsg)/sizeof(aMsg[0])) && aMsg[rc]!=0 ){
96253 # define NDELAY (sizeof(delays)/sizeof(delays[0]))
97028 db = sqlite3MallocZero( sizeof(sqlite3) );
97044 assert( sizeof(db->aLimit)==sizeof(aHardLimit) );
97045 memcpy(db->aLimit, aHardLimit, sizeof(db->aLimit));
98049 || (aDyn && nArg==(int)(sqlite3DbMallocSize(db, aDyn)/sizeof(void*)))
98052 void **pNew = (void **)sqlite3Malloc(nArg*sizeof(void *)*2);
98054 memcpy(pNew, aArg, nArg*sizeof(void *));
98726 #define SizeofArray(X) ((int)(sizeof(X)/sizeof(X[0])))
99308 nByte = sizeof(Fts3Table) + /* Fts3Table */
99309 nCol * sizeof(char *) + /* azColumn */
99479 *ppCsr = pCsr = (sqlite3_vtab_cursor *)sqlite3_malloc(sizeof(Fts3Cursor));
99483 memset(pCsr, 0, sizeof(Fts3Cursor));
100247 apSegment = (Fts3SegReader **)sqlite3_malloc(sizeof(Fts3SegReader*)*nAlloc);
100305 apSegment, nAlloc*sizeof(Fts3SegReader *)
100322 memset(&tsc, 0, sizeof(TermSelect));
100568 memset(&pCursor[1], 0, sizeof(Fts3Cursor)-sizeof(sqlite3_vtab_cursor));
100660 sqlite3_result_blob(pContext, &pCsr, sizeof(pCsr), SQLITE_TRANSIENT);
100784 ** sizeof(Fts3Cursor*), then the blob contents are copied to the
100797 || sqlite3_value_bytes(pVal)!=sizeof(Fts3Cursor *)
100804 memcpy(&pRet, sqlite3_value_blob(pVal), sizeof(Fts3Cursor *));
101102 pHash = sqlite3_malloc(sizeof(Fts3Hash));
101309 nByte = sizeof(Fts3Expr) + sizeof(Fts3Phrase) + nToken;
101389 int nByte = sizeof(Fts3Expr) + sizeof(Fts3Phrase);
101390 p = fts3ReallocOrFree(p, nByte+ii*sizeof(struct PhraseToken));
101420 int nByte = sizeof(Fts3Expr) + sizeof(Fts3Phrase);
101421 nByte += (p?(p->pPhrase->nToken-1):0) * sizeof(struct PhraseToken);
101508 for(ii=0; ii<(int)(sizeof(aKeyword)/sizeof(struct Fts3Keyword)); ii++){
101539 pRet = (Fts3Expr *)sqlite3_malloc(sizeof(Fts3Expr));
101543 memset(pRet, 0, sizeof(Fts3Expr));
101719 Fts3Expr *pNot = sqlite3_malloc(sizeof(Fts3Expr));
101725 memset(pNot, 0, sizeof(Fts3Expr));
101753 pAnd = sqlite3_malloc(sizeof(Fts3Expr));
101759 memset(pAnd, 0, sizeof(Fts3Expr));
101935 memcpy((void *)pp, sqlite3_column_blob(pStmt, 0), sizeof(*pp));
102044 azCol = (char **)sqlite3_malloc(nCol*sizeof(char *));
102286 new_ht = (struct _fts3ht *)fts3HashMalloc( new_size*sizeof(struct _fts3ht) );
102445 new_elem = (Fts3HashElem*)fts3HashMalloc( sizeof(Fts3HashElem) );
102533 t = (porter_tokenizer *) sqlite3_malloc(sizeof(*t));
102535 memset(t, 0, sizeof(*t));
102563 c = (porter_tokenizer_cursor *) sqlite3_malloc(sizeof(*c));
102810 if( nIn<3 || nIn>=sizeof(zReverse)-7 ){
102816 for(i=0, j=sizeof(zReverse)-6; i<nIn; i++, j--){
102829 memset(&zReverse[sizeof(zReverse)-5], 0, 5);
103184 if( n!=sizeof(pPtr) ){
103204 sqlite3_result_blob(context, (void *)&pPtr, sizeof(pPtr), SQLITE_TRANSIENT);
103300 int nNew = sizeof(char *)*(iArg+1);
103461 sqlite3_bind_blob(pStmt, 2, &p, sizeof(p), SQLITE_STATIC);
103486 memcpy((void *)pp, sqlite3_column_blob(pStmt, 0), sizeof(*pp));
103665 t = (simple_tokenizer *) sqlite3_malloc(sizeof(*t));
103667 memset(t, 0, sizeof(*t));
103720 c = (simple_tokenizer_cursor *) sqlite3_malloc(sizeof(*c));
104174 p = sqlite3_malloc(sizeof(*p) + 100);
104184 p = sqlite3_realloc(p, sizeof(*p) + nNew);
104308 p->nPendingData -= (pList->nData + nToken + sizeof(Fts3HashElem));
104321 p->nPendingData += (pList->nData + nToken + sizeof(Fts3HashElem));
104720 pReader = (Fts3SegReader *)sqlite3_malloc(sizeof(Fts3SegReader) + nExtra);
104724 memset(pReader, 0, sizeof(Fts3SegReader));
104758 p->aLeavesStmt, nNew*sizeof(sqlite3_stmt *)
104838 aElem, nAlloc*sizeof(Fts3HashElem *)
104856 qsort(aElem, nElem, sizeof(Fts3HashElem *), fts3CompareElemByTerm);
104868 int nByte = sizeof(Fts3SegReader) + (nElem+1)*sizeof(Fts3HashElem *);
104876 memcpy(pReader->ppNextElem, aElem, nElem*sizeof(Fts3HashElem *));
105197 pNew = (SegmentNode *)sqlite3_malloc(sizeof(SegmentNode) + p->nNodeSize);
105201 memset(pNew, 0, sizeof(SegmentNode));
105344 pWriter = (SegmentWriter *)sqlite3_malloc(sizeof(SegmentWriter));
105346 memset(pWriter, 0, sizeof(SegmentWriter));
105931 apSegment = (Fts3SegReader**)sqlite3_malloc(sizeof(Fts3SegReader *)*nSegment);
105936 memset(apSegment, 0, sizeof(Fts3SegReader *)*nSegment);
105960 memset(&filter, 0, sizeof(Fts3SegFilter));
106020 memset(&f, 0, sizeof(Fts3SegFilter));
106305 pNew = sqlite3_realloc(p->aMatch, p->nAlloc*sizeof(p->aMatch[0]) );
106616 pSnippet = (Snippet *)sqlite3_malloc(sizeof(Snippet));
106621 memset(pSnippet, 0, sizeof(Snippet));
106674 sqlite3_snprintf(sizeof(zBuf)-1, &zBuf[cnt>0], "%d %d %d %d",
107118 sizeof(u8*)*nList + /* apList */
107119 sizeof(int)*(nList) + /* anToken */
107120 sizeof(int)*nList + /* aiPrev */
107121 sizeof(int)*(nList+1) /* anCnt */
107126 memset(apList, 0, sizeof(u8*)*nList+sizeof(int)*nList+sizeof(int)*nList);
107402 memset(&p->aGlobal[iOffset], 0, p->nCol*sizeof(u32));
107433 g.aGlobal = (u32 *)sqlite3_malloc(sizeof(u32)*nMatchinfo);
107437 memset(g.aGlobal, 0, sizeof(u32)*nMatchinfo);
107497 int n = sizeof(u32)*(2+pCsr->aMatchinfo[0]*pCsr->aMatchinfo[1]*2);
107776 assert( sizeof(RtreeCoord)==4 );
107777 assert( sizeof(u32)==4 );
107872 pNode = (RtreeNode *)sqlite3_malloc(sizeof(RtreeNode) + pRtree->iNodeSize);
107874 memset(pNode, 0, sizeof(RtreeNode) + (zero?pRtree->iNodeSize:0));
107911 pNode = (RtreeNode *)sqlite3_malloc(sizeof(RtreeNode) + pRtree->iNodeSize);
108205 pCsr = (RtreeCursor *)sqlite3_malloc(sizeof(RtreeCursor));
108207 memset(pCsr, 0, sizeof(RtreeCursor));
108524 pCsr->aConstraint = sqlite3_malloc(sizeof(RtreeConstraint)*argc);
108607 memset(zIdxStr, 0, sizeof(zIdxStr));
108669 assert( iIdx<sizeof(zIdxStr)-1 );
108756 memcpy(&cell, p, sizeof(RtreeCell));
108848 aCell = sqlite3_malloc(sizeof(RtreeCell)*nCell);
109132 memcpy(aSpare, aLeft, sizeof(int)*nLeft);
109201 memcpy(aSpare, aLeft, sizeof(int)*nLeft);
109257 int nByte = (pRtree->nDim+1)*(sizeof(int*)+nCell*sizeof(int));
109293 memcpy(&left, &aCell[aaSorted[ii][0]], sizeof(RtreeCell));
109294 memcpy(&right, &aCell[aaSorted[ii][nCell-1]], sizeof(RtreeCell));
109323 memcpy(pBboxLeft, &aCell[aaSorted[iBestDim][0]], sizeof(RtreeCell));
109324 memcpy(pBboxRight, &aCell[aaSorted[iBestDim][iBestSplit]], sizeof(RtreeCell));
109356 aiUsed = sqlite3_malloc(sizeof(int)*nCell);
109360 memset(aiUsed, 0, sizeof(int)*nCell);
109364 memcpy(pBboxLeft, &aCell[iLeftSeed], sizeof(RtreeCell));
109365 memcpy(pBboxRight, &aCell[iRightSeed], sizeof(RtreeCell));
109436 aCell = sqlite3_malloc((sizeof(RtreeCell)+sizeof(int))*(nCell+1));
109442 memset(aiUsed, 0, sizeof(int)*(nCell+1));
109447 memcpy(&aCell[nCell], pCell, sizeof(RtreeCell));
109671 memset(aCenterCoord, 0, sizeof(float)*RTREE_MAX_DIMENSIONS);
109679 sizeof(RtreeCell) + /* aCell array */
109680 sizeof(int) + /* aOrder array */
109681 sizeof(int) + /* aSpare array */
109682 sizeof(float) /* aDistance array */
109693 memcpy(&aCell[ii], pCell, sizeof(RtreeCell));
110195 pRtree = (Rtree *)sqlite3_malloc(sizeof(Rtree)+nDb+nName+2);
110199 memset(pRtree, 0, sizeof(Rtree)+nDb+nName+2);
110281 memset(&node, 0, sizeof(RtreeNode));
110282 memset(&tree, 0, sizeof(Rtree));
110841 for(i=0; rc==SQLITE_OK && i<(sizeof(scalars)/sizeof(struct IcuScalar)); i++){
110925 p = (IcuTokenizer *)sqlite3_malloc(sizeof(IcuTokenizer)+n);
110929 memset(p, 0, sizeof(IcuTokenizer));
110980 sizeof(IcuCursor) + /* IcuCursor */
110981 nChar * sizeof(UChar) + /* IcuCursor.aChar[] */
110982 (nChar+1) * sizeof(int) /* IcuCursor.aOffset[] */
110987 memset(pCsr, 0, sizeof(IcuCursor));
