Lines Matching refs:aData
45102 ** Parameter aData must point to a buffer of pPager->pageSize bytes
45120 static u32 pager_cksum(Pager *pPager, const u8 *aData){
45124 cksum += aData[i];
45207 char *aData; /* Temporary storage for the page */
45216 aData = pPager->pTmpSpace;
45217 assert( aData ); /* Temp storage must have already been allocated */
45237 rc = sqlite3OsRead(jfd, (u8*)aData, pPager->pageSize, (*pOffset)+4);
45256 if( !isSavepnt && pager_cksum(pPager, (u8*)aData)!=cksum ){
45270 if( pgno==1 && pPager->nReserve!=((u8*)aData)[20] ){
45271 pPager->nReserve = ((u8*)aData)[20];
45318 PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, (u8*)aData),
45333 rc = sqlite3OsWrite(pPager->fd, (u8 *)aData, pPager->pageSize, ofst);
45338 CODEC1(pPager, aData, pgno, 3, rc=SQLITE_NOMEM);
45339 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData);
45340 CODEC2(pPager, aData, pgno, 7, rc=SQLITE_NOMEM, aData);
45378 memcpy(pData, (u8*)aData, pPager->pageSize);
49734 void *aData = 0;
49735 CODEC2(pPg->pPager, pPg->pData, pPg->pgno, 6, return 0, aData);
49736 return aData;
50921 u32 *aData = (u32 *)a;
50936 s1 += *aData++ + s2;
50937 s2 += *aData++ + s1;
50938 }while( aData<aEnd );
50941 s1 += BYTESWAP32(aData[0]) + s2;
50942 s2 += BYTESWAP32(aData[1]) + s1;
50943 aData += 2;
50944 }while( aData<aEnd );
50992 u8 *aData, /* Pointer to page data */
51004 walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum);
51012 ** in aData[] is valid. If it is a valid frame, fill *piPage and
51019 u8 *aData, /* Pointer to page data (for checksum) */
51048 walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum);
51416 u8 *aData; /* Pointer to data part of aFrame buffer */
51474 aData = &aFrame[WAL_FRAME_HDRSIZE];
51486 isValid = walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame);
53808 u16 cellOffset; /* Index in aData of first cell pointer */
53816 u8 *aData; /* Pointer to disk image of the page data */
53819 u8 *aDataOfst; /* Same as aData for leaves. aData+4 for interior */
55516 ((P)->aData + ((P)->maskPage & get2byteAligned(&(P)->aCellIdx[2*(I)])))
55854 src = data = pPage->aData;
55924 u8 * const aData = pPg->aData;
55926 int pc = get2byte(&aData[iAddr]);
55942 size = get2byte(&aData[pc+2]);
55952 if( aData[hdr+7]>57 ) return 0;
55956 memcpy(&aData[iAddr], &aData[pc], 2);
55957 aData[hdr+7] += (u8)x;
55961 put2byte(&aData[pc+2], x);
55963 return &aData[pc + x];
55966 pc = get2byte(&aData[pc]);
55974 ** as the first argument. Write into *pIdx the index into pPage->aData[]
55987 u8 * const data = pPage->aData; /* Local cache of pPage->aData */
56063 ** Return a section of the pPage->aData to the freelist.
56064 ** The first byte of the new free block is pPage->aData[iStart]
56083 unsigned char *data = pPage->aData; /* Page content */
56242 assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) );
56245 u16 pc; /* Address of a freeblock within pPage->aData[] */
56247 u8 *data; /* Equal to pPage->aData */
56259 data = pPage->aData;
56367 unsigned char *data = pPage->aData;
56405 pPage->aData = sqlite3PagerGetData(pDbPage);
56415 ** MemPage.aData elements if needed. See also: btreeGetUnusedPage().
56444 ** MemPage.aData elements if needed.
56536 assert( pPage->aData );
56540 assert( sqlite3PagerGetData(pPage->pDbPage)==pPage->aData );
57331 nPage = nPageHeader = get4byte(28+(u8*)pPage1->aData);
57333 if( nPage==0 || memcmp(24+(u8*)pPage1->aData, 92+(u8*)pPage1->aData,4)!=0 ){
57339 u8 *page1 = pPage1->aData;
57517 assert( pPage1->aData );
57540 data = pP1->aData;
57731 if( pBt->nPage!=get4byte(&pPage1->aData[28]) ){
57734 put4byte(&pPage1->aData[28], pBt->nPage);
57789 Pgno childPgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
57817 if( get4byte(pPage->aData)!=iFrom ){
57820 put4byte(pPage->aData, iTo);
57837 && pCell+info.iOverflow+3<=pPage->aData+pPage->maskPage
57853 get4byte(&pPage->aData[pPage->hdrOffset+8])!=iFrom ){
57856 put4byte(&pPage->aData[pPage->hdrOffset+8], iTo);
57915 Pgno nextOvfl = get4byte(pDbPage->aData);
57978 nFreeList = get4byte(&pBt->pPage1->aData[36]);
58099 Pgno nFree = get4byte(&pBt->pPage1->aData[36]);
58112 put4byte(&pBt->pPage1->aData[28], pBt->nPage);
58154 nFree = get4byte(&pBt->pPage1->aData[36]);
58165 put4byte(&pBt->pPage1->aData[32], 0);
58166 put4byte(&pBt->pPage1->aData[36], 0);
58167 put4byte(&pBt->pPage1->aData[28], nFin);
58441 /* The rollback may have destroyed the pPage1->aData value. So
58443 ** sure pPage1->aData is set correctly. */
58445 int nPage = get4byte(28+(u8*)pPage1->aData);
58524 pBt->nPage = get4byte(28 + pBt->pPage1->aData);
58591 assert( pBt->pPage1 && pBt->pPage1->aData );
58849 next = get4byte(pPage->aData);
58954 if( &aPayload[pCur->info.nLocal] > &pPage->aData[pBt->usableSize] ){
59078 && pBt->pPage1->aData[19]==0x01 /* (5) */
59195 assert( pCur->info.pPayload>pCur->apPage[pCur->iPage]->aData || CORRUPT_DB );
59266 assert( get4byte(&pParent->aData[pParent->hdrOffset+8])==iChild );
59382 subpage = get4byte(&pRoot->aData[pRoot->hdrOffset+8]);
59431 pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
59740 chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]);
59833 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
60021 n = get4byte(&pPage1->aData[36]);
60058 put4byte(&pPage1->aData[36], n-1);
60071 iTrunk = get4byte(&pPrevTrunk->aData[0]);
60076 iTrunk = get4byte(&pPage1->aData[32]);
60089 assert( pTrunk->aData!=0 );
60092 k = get4byte(&pTrunk->aData[4]);
60103 memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4);
60127 memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4);
60133 memcpy(&pPrevTrunk->aData[0], &pTrunk->aData[0], 4);
60141 Pgno iNewTrunk = get4byte(&pTrunk->aData[8]);
60156 memcpy(&pNewTrunk->aData[0], &pTrunk->aData[0], 4);
60157 put4byte(&pNewTrunk->aData[4], k-1);
60158 memcpy(&pNewTrunk->aData[8], &pTrunk->aData[12], (k-1)*4);
60162 put4byte(&pPage1->aData[32], iNewTrunk);
60168 put4byte(&pPrevTrunk->aData[0], iNewTrunk);
60178 unsigned char *aData = pTrunk->aData;
60184 iPage = get4byte(&aData[8+i*4]);
60192 dist = sqlite3AbsInt32(get4byte(&aData[8]) - nearby);
60194 int d2 = sqlite3AbsInt32(get4byte(&aData[8+i*4]) - nearby);
60205 iPage = get4byte(&aData[8+closest*4]);
60223 memcpy(&aData[8+closest*4], &aData[4+k*4], 4);
60225 put4byte(&aData[4], k-1);
60286 put4byte(28 + (u8*)pBt->pPage1->aData, pBt->nPage);
60345 nFree = get4byte(&pPage1->aData[36]);
60346 put4byte(&pPage1->aData[36], nFree+1);
60357 memset(pPage->aData, 0, pPage->pBt->pageSize);
60378 iTrunk = get4byte(&pPage1->aData[32]);
60384 nLeaf = get4byte(&pTrunk->aData[4]);
60412 put4byte(&pTrunk->aData[4], nLeaf+1);
60413 put4byte(&pTrunk->aData[8+nLeaf*4], iPage);
60437 put4byte(pPage->aData, iTrunk);
60438 put4byte(&pPage->aData[4], 0);
60439 put4byte(&pPage1->aData[32], iPage);
60479 if( pCell+info.iOverflow+3 > pPage->aData+pPage->maskPage ){
60537 ** Note that pCell does not necessary need to point to the pPage->aData
60539 ** be constructed in this temporary area then copied into pPage->aData
60566 assert( pCell<pPage->aData || pCell>=&pPage->aData[pBt->pageSize]
60679 assert( pPrior<pPage->aData || pPrior>=&pPage->aData[pBt->pageSize]
60685 pPrior = pOvfl->aData;
60687 pPayload = &pOvfl->aData[4];
60699 assert( pPayload<pPage->aData || pPayload>=&pPage->aData[pBt->pageSize]
60733 u8 *data; /* pPage->aData */
60744 data = pPage->aData;
60840 data = pPage->aData;
60938 u8 * const aData = pPg->aData; /* Pointer to data for pPg */
60940 u8 * const pEnd = &aData[usableSize];
60946 i = get2byte(&aData[hdr+5]);
60947 memcpy(&pTmp[i], &aData[i], usableSize - i);
60952 if( pCell>aData && pCell<pEnd ){
60953 pCell = &pTmp[pCell - aData];
60956 put2byte(pCellptr, (pData - aData));
60968 put2byte(&aData[hdr+1], 0);
60969 put2byte(&aData[hdr+3], pPg->nCell);
60970 put2byte(&aData[hdr+5], pData - aData);
60971 aData[hdr+7] = 0x00;
61010 u8 *aData = pPg->aData;
61018 if( (aData[1]==0 && aData[2]==0) || (pSlot = pageFindSlot(pPg,sz,&rc))==0 ){
61030 put2byte(pCellptr, (pSlot - aData));
61052 u8 * const aData = pPg->aData;
61053 u8 * const pEnd = &aData[pPg->pBt->usableSize];
61054 u8 * const pStart = &aData[pPg->hdrOffset + 8 + pPg->childPtrSize];
61071 assert( pFree>aData && (pFree - aData)<65536 );
61072 freeSpace(pPg, (u16)(pFree - aData), szFree);
61085 assert( pFree>aData && (pFree - aData)<65536 );
61086 freeSpace(pPg, (u16)(pFree - aData), szFree);
61110 u8 * const aData = pPg->aData;
61122 memcpy(pTmp, aData, pPg->pBt->usableSize);
61135 pData = &aData[get2byteNotZero(&aData[hdr+5])];
61175 put2byte(&aData[hdr+3], pPg->nCell);
61176 put2byte(&aData[hdr+5], pData - aData);
61182 if( pCell>=aData && pCell<&aData[pPg->pBt->usableSize] ){
61183 pCell = &pTmp[pCell - aData];
61185 assert( 0==memcmp(pCell, &aData[iOff],
61264 assert( pPage->aData[0]==(PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF) );
61310 put4byte(&pParent->aData[pParent->hdrOffset+8], pgnoNew);
61353 Pgno child = get4byte(&pPage->aData[pPage->hdrOffset+8]);
61382 u8 * const aFrom = pFrom->aData;
61383 u8 * const aTo = pTo->aData;
61434 ** might not actually be stored in MemPage.aData[]. This can happen
61436 ** to the page and its siblings fit into MemPage.aData[] before returning.
61480 int pageFlags; /* Value of pPage->aData[0] */
61549 pRight = &pParent->aData[pParent->hdrOffset+8];
61588 iOff = SQLITE_PTR_TO_INT(apDiv[i]) - SQLITE_PTR_TO_INT(pParent->aData);
61595 apDiv[i] = &aOvflSpace[apDiv[i]-pParent->aData];
61648 u8 *aData = pOld->aData;
61650 u8 *piCell = aData + pOld->cellOffset;
61656 if( pOld->aData[0]!=apOld[0]->aData[0] ){
61683 b.apCell[b.nCell] = aData + (maskPage & get2byteAligned(piCell));
61693 piEnd = aData + pOld->cellOffset + 2*pOld->nCell;
61696 b.apCell[b.nCell] = aData + (maskPage & get2byteAligned(piCell));
61720 memcpy(b.apCell[b.nCell], &pOld->aData[8], 4);
61865 pageFlags = apOld[0]->aData[0];
61959 memcpy(&apNew[nNew-1]->aData[8], &pOld->aData[8], 4);
61980 u8 *aOld = pNew->aData;
61991 aOld = pOld->aData;
62034 memcpy(&pNew->aData[8], pCell, 4);
62158 (get2byte(&apNew[0]->aData[5])-apNew[0]->cellOffset-apNew[0]->nCell*2)
62168 u32 key = get4byte(&apNew[i]->aData[8]);
62272 zeroPage(pRoot, pChild->aData[0] & ~PTF_LEAF);
62273 put4byte(&pRoot->aData[pRoot->hdrOffset+8], pgnoChild);
62679 if( pCell<&pLeaf->aData[4] ) return SQLITE_CORRUPT_BKPT;
62936 rc = clearDatabasePage(pBt, get4byte(&pPage->aData[hdr+8]), 1, pnChange);
62946 zeroPage(pPage, pPage->aData[hdr] | PTF_LEAF);
63160 *pMeta = get4byte(&pBt->pPage1->aData[36 + idx*4]);
63186 pP1 = pBt->pPage1->aData;
63266 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
63582 data = pPage->aData;
63840 checkList(&sCheck, 1, get4byte(&pBt->pPage1->aData[32]),
63841 get4byte(&pBt->pPage1->aData[36]));
64129 u8 *aData = pBt->pPage1->aData;
64130 if( aData[18]!=(u8)iVersion || aData[19]!=(u8)iVersion ){
64135 aData[18] = (u8)iVersion;
64136 aData[19] = (u8)iVersion;
64868 const u8 *aData
64881 rc = backupOnePage(p, iPage, aData, 1);
64890 SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *pBackup, Pgno iPage, const u8 *aData){
64891 if( pBackup ) backupUpdate(pBackup, iPage, aData);
146019 char *aData;
146110 int nSize; /* Size of allocation at aData */
146111 int nData; /* Bytes of data in aData */
146112 char *aData; /* Pointer to block from malloc() */
146144 char *aData; /* Node data */
146569 p->aData = (char *)&p[1];
146581 p->aData = (char *)&p[1];
146585 p->nData += sqlite3Fts3PutVarint(&p->aData[p->nData], i);
146586 p->aData[p->nData] = '\0';
146616 assert( p->aData[p->nData]==0 );
147252 memcpy(aCopy, pList->aData, nCopy);
147944 assert( pTree->aData==(char *)&pTree[1] );
147945 pTree->aData = (char *)sqlite3_malloc(nReq);
147946 if( !pTree->aData ){
147953 nData += sqlite3Fts3PutVarint(&pTree->aData[nData], nPrefix);
147956 nData += sqlite3Fts3PutVarint(&pTree->aData[nData], nSuffix);
147957 memcpy(&pTree->aData
147995 pNew->aData = (char *)&pNew[1];
148029 pTree->aData[nStart] = (char)iHeight;
148030 sqlite3Fts3PutVarint(&pTree->aData[nStart+1], iLeftChild);
148064 *paRoot = &pTree->aData[nStart];
148073 rc = fts3WriteSegment(p, iNextFree, &pIter->aData[nStart], nWrite);
148097 if( p->aData!=(char *)&p[1] ){
148098 sqlite3_free(p->aData);
148142 pWriter->aData = (char *)sqlite3_malloc(p->nNodeSize);
148143 if( !pWriter->aData ) return SQLITE_NOMEM;
148172 rc = fts3WriteSegment(p, pWriter->iFree++, pWriter->aData, nData);
148211 char *aNew = sqlite3_realloc(pWriter->aData, nReq);
148213 pWriter->aData = aNew;
148219 nData += sqlite3Fts3PutVarint(&pWriter->aData[nData], nPrefix);
148220 nData += sqlite3Fts3PutVarint(&pWriter->aData[nData], nSuffix);
148221 memcpy(&pWriter->aData[nData], &zTerm[nPrefix], nSuffix);
148223 nData += sqlite3Fts3PutVarint(&pWriter->aData[nData], nDoclist);
148224 memcpy(&pWriter->aData[nData], aDoclist, nDoclist);
148272 rc = fts3WriteSegment(p, pWriter->iFree++, pWriter->aData, pWriter->nData);
148284 0, 0, 0, pWriter->nLeafData, pWriter->aData, pWriter->nData);
148296 sqlite3_free(pWriter->aData);
151342 nSkip = sqlite3Fts3GetVarint(p->pList->aData, &dummy);
151346 memcpy(pRet, &p->pList->aData[nSkip], *pnData);
163201 u8 *aData = sqlite3PagerGetData(p->pPg);
163202 u8 *aHdr = &aData[p->iPgno==1 ? 100 : 0];
163215 nUnused += get2byte(&aData[iOff+2]);
163216 iOff = get2byte(&aData[iOff]);
163236 iOff = get2byte(&aData[nHdr+i*2]);
163238 pCell->iChildPg = sqlite3Get4byte(&aData[iOff]);
163246 iOff += getVarint32(&aData[iOff], nPayload);
163249 iOff += sqlite3GetVarint(&aData[iOff], &dummy);
163264 pCell->aOvfl[0] = sqlite3Get4byte(&aData[iOff+nLocal]);
175778 const u8 *aData,
175782 const u8 *a = aData;
