Lines Matching defs:memcpy
14183 ** Use a macro to replace memcpy() if compiled with SQLITE_INLINE_MEMCPY.
14184 ** This allows better measurements of where memcpy() is used when running
14185 ** cachegrind. But this macro version of memcpy() is very slow so it
14190 # define memcpy(D,S,N) {char*xxd=(char*)(D);const char*xxs=(const char*)(S);\
24826 if( pTm ) memcpy(&sNow, pTm, sizeof(sNow));
25140 memcpy(zBufOut, &sqlite3Config.iPrngSeed, nByte);
26034 memcpy(pBt, &aAddr[1], pHdr->nBacktrace*sizeof(void*));
26043 memcpy(z, mem.zTitle, mem.nTitle);
26110 memcpy(pNew, pPrior, (int)(nByte<pOldHdr->iSize ? nByte : pOldHdr->iSize));
26216 memcpy(mem.zTitle, zTitle, n);
26829 memcpy(p, pPrior, nOld);
26831 memcpy(p, pPrior, nBytes);
27386 memcpy(p, pPrior, nOld);
29766 memcpy(pNew, p, lookasideMallocSize(db, p));
29813 memcpy(zNew, z, n);
29824 memcpy(zNew, z, (size_t)n);
30491 memcpy(&u, &rx, sizeof(u));
30514 memcpy(buf+(prefix!=0),"Inf",4);
30946 if( !isMalloced(p) && p->nChar>0 ) memcpy(zNew, p->zText, p->nChar);
30981 memcpy(&p->zText[p->nChar], z, N);
31000 memcpy(&p->zText[p->nChar-N], z, N);
31022 memcpy(zText, p->zText, p->nChar+1);
32666 memcpy(x, in, 64);
32726 memcpy(&wsdPrng.s[0], chacha20_init, 16);
32740 memcpy(zBuf, &wsdPrng.out[wsdPrng.n-N], N);
32745 memcpy(zBuf, wsdPrng.out, wsdPrng.n);
32768 memcpy(
32775 memcpy(
33660 memcpy(&y,&x,sizeof(y));
34254 memcpy(zOut, &zTemp[i+1], sizeof(zTemp)-1-i);
34418 memcpy(pOut, &u, 8);
34459 memcpy(pValue, &u, 4);
34899 memcpy(&x,p,4);
34903 memcpy(&x,p,4);
34907 memcpy(&x,p,4);
34916 memcpy(p,&v,4);
34919 memcpy(p,&x,4);
34922 memcpy(p,&x,4);
35195 memcpy(&a, &x, 8);
35277 memcpy(z, zName, nName);
36322 memcpy(zBuf, pFile->aJrnl+iOfst, iAmt);
36366 memcpy(zBuf, &aData[2000+iOfst], iAmt);
36407 memcpy(pFile->aJrnl+iOfst, zBuf, iAmt);
36702 memcpy(zOut, zPath, nPath);
37794 memcpy(pNew->zCanonicalName, zAbsoluteName, n+1);
38256 memcpy(&pInode->fileId, &fileId, sizeof(fileId));
40189 ** data from the memory mapping using memcpy(). */
40192 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt);
40196 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], nCopy);
40347 ** data from the memory mapping using memcpy(). */
40350 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt);
40354 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, nCopy);
42939 memcpy(zDb, zPath, nDb);
43489 memcpy(zDel, zIn, n);
43604 memcpy(zBuf, &t, sizeof(t));
43605 memcpy(&zBuf[sizeof(t)], &randomnessPid, sizeof(randomnessPid));
44341 memcpy(lockPath, &readBuf[PROXY_PATHINDEX], pathLen);
44391 memcpy(&writeBuffer[PROXY_HEADERLEN], myHostID, PROXY_HOSTIDLEN);
44538 memcpy(conchPath, dbPath, len+1);
44554 memcpy(&conchPath[i+1], "-conch", 7);
44614 memcpy(dbPath, (char *)pFile->lockingContext, len + 1);
46423 memcpy(zDbgBuf, zBuf, nMin);
46439 memcpy(zDbgBuf, zBuf, nMin);
47816 ** data from the memory mapping using memcpy(). */
47819 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt);
47825 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], nCopy);
47894 ** data from the memory mapping using memcpy(). */
47897 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt);
47903 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, nCopy);
51533 if( iOfst<p->sz ) memcpy(zBuf, p->aData+iOfst, p->sz - iOfst);
51537 memcpy(zBuf, p->aData+iOfst, iAmt);
51590 memcpy(p->aData+iOfst, z, iAmt);
51859 memcpy(p->zFName, zName, szName+1);
52057 if( pOut ) memcpy(pOut, pStore->aData, pStore->sz);
52087 memcpy(pTo, sqlite3PagerGetData(pPage), szPage);
52412 memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash));
52452 memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash));
56997 memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
57981 memcpy(pData, (u8*)aData, pPager->pageSize);
57992 memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers));
58572 memcpy(&pPager->dbFileVers, dbFileVers, sizeof(pPager->dbFileVers));
59832 memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
59990 memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers));
60408 memcpy(pPtr, &pPager, sizeof(pPager)); pPtr += sizeof(pPager);
60414 memcpy(pPtr, zPathname, nPathname); pPtr += nPathname + 1;
60416 memcpy(pPtr, zUri, nUriByte); pPtr += nUriByte;
60426 memcpy(pPtr, zPathname, nPathname); pPtr += nPathname;
60427 memcpy(pPtr, "-journal",8); pPtr += 8 + 1;
60440 memcpy(pPtr, zPathname, nPathname); pPtr += nPathname;
60441 memcpy(pPtr, "-wal", 4); pPtr += 4 + 1;
61886 memcpy(&pPager->dbFileVers, pCopy, sizeof(pPager->dbFileVers));
64165 memcpy((void*)&aHdr[1], (const void*)&pWal->hdr, sizeof(WalIndexHdr));
64167 memcpy((void*)&aHdr[0], (const void*)&pWal->hdr, sizeof(WalIndexHdr));
64196 memcpy(&aFrame[8], pWal->hdr.aSalt, 8);
64650 memcpy(&pWal->hdr.aSalt, &aBuf[16], 8);
64722 ** Technically, memcpy() might change the destination to some
64725 ** do that, according to the spec, but no memcpy() implementation that
64726 ** we know of actually does that, which is why we say that memcpy()
64729 memcpy(&aShare[nHdr32], &aPrivate[nHdr32], WALINDEX_PGSZ-nHdr);
64731 /* In the event that some platform is found for which memcpy()
65041 memcpy(aLeft, aTmp, sizeof(aTmp[0])*iOut);
65356 memcpy(&pWal->hdr.aSalt[1], &salt1, 4);
65709 memcpy(&h1, (void *)&aHdr[0], sizeof(h1)); /* Possible TSAN false-positive */
65711 memcpy(&h2, (void *)&aHdr[1], sizeof(h2));
65726 memcpy(&pWal->hdr, &h1, sizeof(WalIndexHdr));
65936 memcpy(&pWal->hdr, (void*)walIndexHdr(pWal), sizeof(WalIndexHdr));
66454 memcpy(&pWal->hdr, pSnapshot, sizeof(WalIndexHdr));
66728 memcpy(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr));
67040 memcpy(&aWalHdr[16], pWal->hdr.aSalt, 8);
67455 memcpy(pRet, &pWal->hdr, sizeof(WalIndexHdr));
70190 memcpy(&temp[iCellStart], &data[iCellStart], usableSize - iCellStart);
70214 memcpy(&data[cbrk], &src[pc], size);
70274 memcpy(&aData[iAddr], &aData[pc], 2);
71145 memcpy(zFullPathname, zFilename, nFilename);
72053 memcpy(data, zMagicHeader, sizeof(zMagicHeader));
73543 memcpy(pPayload, pBuf, nByte);
73546 memcpy(pBuf, pPayload, nByte);
73730 memcpy(aSave, aWrite, 4);
73734 memcpy(aWrite, aSave, 4);
74982 memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4);
75006 memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4);
75012 memcpy(&pPrevTrunk->aData[0], &pTrunk->aData[0], 4);
75035 memcpy(&pNewTrunk->aData[0], &pTrunk->aData[0], 4);
75037 memcpy(&pNewTrunk->aData[8], &pTrunk->aData[12], (k-1)*4);
75102 memcpy(&aData[8+closest*4], &aData[4+k*4], 4);
75491 memcpy(pPayload, pSrc, nSrc);
75549 memcpy(pPayload, pSrc, n);
75552 memcpy(pPayload, pSrc, n);
75712 memcpy(pTemp, pCell, sz);
75756 memcpy(&data[idx+4], pCell+4, sz-4);
75759 memcpy(&data[idx], pCell, sz);
75941 memcpy(&pTmp[j], &aData[j], usableSize - j);
76040 ** since memcpy() sends SIGABORT with overlapping buffers on OpenBSD */
76152 memcpy(pTmp, aData, pPg->pBt->usableSize);
76434 memcpy(&aTo[iData], &aFrom[iData], pBt->usableSize-iData);
76435 memcpy(&aTo[iToHdr], &aFrom[iFromHdr], pFrom->cellOffset + 2*pFrom->nCell);
76631 memcpy(&aOvflSpace[iOff], apDiv[i], szNew[i]);
76751 memcpy(pTemp, apDiv[i], sz);
76760 memcpy(b.apCell[b.nCell], &pOld->aData[8], 4);
77013 memcpy(&apNew[nNew-1]->aData[8], &pOld->aData[8], 4);
77089 memcpy(&pNew->aData[8], pCell, 4);
77324 memcpy(pChild->aiOvfl, pRoot->aiOvfl,
77326 memcpy(pChild->apOvfl, pRoot->apOvfl,
77834 memcpy(newCell, oldCell, 4);
77858 memcpy(oldCell, newCell, szNew);
77914 memcpy(pCur->pKey, pX->pKey, pX->nKey);
77964 memcpy(aOut, aIn, nIn);
77994 memcpy(aOut, aIn, nCopy);
80046 memcpy(zOut, zIn, nCopy);
80664 memcpy(&x, (char*)&p->u, (p->flags&MEM_Int)*2);
80824 memcpy(pMem->zMalloc, pMem->z, pMem->n);
81023 memcpy(pMem, &t, sizeof(t));
81617 memcpy(pTo, pFrom, MEMCELLSIZE);
81634 memcpy(pTo, pFrom, MEMCELLSIZE);
81658 memcpy(pTo, pFrom, sizeof(Mem));
81753 memcpy(pMem->z, z, nAlloc);
82626 memcpy(pStr->z, z, n+1);
82684 memcpy(pB->aCounter, pA->aCounter, sizeof(pB->aCounter));
82943 if( p4copy ) memcpy(p4copy, zP4, 8);
86466 memcpy(&pMem->u.r, &x, sizeof(x));
88205 memcpy(pNew, pOrig, MEMCELLSIZE);
91761 memcpy(pOut, pVar, MEMCELLSIZE);
92001 ** to avoid a memcpy().
92044 memcpy(pOut->z, pIn2->z, pIn2->n);
92048 memcpy(&pOut->z[pIn2->n], pIn1->z, pIn1->n);
92274 memcpy(&uA, &iA, sizeof(uA));
92282 memcpy(&iA, &uA, sizeof(iA));
93408 memcpy(pDest->z, zData, len);
93904 memcpy(&v, &pRec->u.r, sizeof(v));
93922 memcpy(zPayload, pRec->z, pRec->n);
93929 memcpy(zPayload, pRec->z, pRec->n);
94027 memcpy(pNew->zName, zName, nName+1);
100326 memcpy(p->aAlloc, &p->aBuffer[iBuf], nAvail);
100342 memcpy(&p->aAlloc[nByte - nRem], aNext, nCopy);
100752 memcpy(pKeyInfo, pCsr->pKeyInfo, szKeyInfo);
101259 memcpy(&p->aBuffer[p->iBufEnd], &pData[nData-nRem], nCopy);
101643 memcpy(SRVAL(pNew), pVal->z, pVal->n);
102487 memcpy(pOut->z, pKey, nKey);
103091 memcpy(zOut, (u8*)pChunk->zChunk + iChunkOffset, nCopy);
103192 memcpy((u8*)p->pFirst->zChunk, zBuf, iAmt);
103218 memcpy((u8*)pChunk->zChunk + iChunkOffset, zWrite, iSpace);
103769 memcpy(&temp, pDup, sizeof(Expr));
103770 memcpy(pDup, pExpr, sizeof(Expr));
103771 memcpy(pExpr, &temp, sizeof(Expr));
106681 if( pToken->n ) memcpy(pNew->u.zToken, pToken->z, pToken->n);
107265 memcpy(zAlloc, p, nNewSize);
107268 memcpy(zAlloc, p, nSize);
107286 memcpy(zToken, p->u.zToken, nToken);
112861 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
113552 memcpy(zOut, zSql, nSql);
113575 memcpy(zBuf1, pBest->t.z, pBest->t.n);
113593 memcpy(&zOut[iOff], zReplace, nReplace);
114930 memcpy(p->u.aRowid, pData, n);
114957 memcpy(pTo->anEq, pFrom->anEq, sizeof(tRowcnt)*p->nCol);
114958 memcpy(pTo->anLt, pFrom->anLt, sizeof(tRowcnt)*p->nCol);
114959 memcpy(pTo->anDLt, pFrom->anDLt, sizeof(tRowcnt)*p->nCol);
115636 memcpy(pStat1->zName, "sqlite_stat1", 13);
116422 memcpy(pSample->p, sqlite3_column_blob(pStmt, 4), pSample->n);
116690 memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2);
117780 memcpy(saveBuf, PARSE_TAIL(pParse), PARSE_TAIL_SZ);
117786 memcpy(PARSE_TAIL(pParse), saveBuf, PARSE_TAIL_SZ);
118086 memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0]));
118208 memcpy(pCol->zCnName + n, zColl, nColl);
118362 memcpy(db->mDropTableName, zTabName, strlen(zTabName) + 1);
118366 memcpy(db->mDropSchemaName, db->aDb[iDb].zDbSName, strlen(db->aDb[iDb].zDbSName) + 1);
119025 memcpy(z, sName.z, sName.n);
119063 memcpy(zType, sType.z, sType.n);
119637 memcpy(&zStmt[k], zType, len);
119657 memcpy(zExtra, pIdx->azColl, sizeof(char*)*pIdx->nColumn);
119660 memcpy(zExtra, pIdx->aiRowLogEst, sizeof(LogEst)*(pIdx->nKeyCol+1));
119663 memcpy(zExtra, pIdx->aiColumn, sizeof(i16)*pIdx->nColumn);
119666 memcpy(zExtra, pIdx->aSortOrder, pIdx->nColumn);
121106 memcpy(z, pTo->z, pTo->n);
121140 memcpy(z, pToCol->a[i].zEName, n);
121611 memcpy(pIndex->zName, zName, nName+1);
121693 memcpy(zExtra, zColl, nColl);
122017 memcpy(&a[1], aVal, nCopy*sizeof(LogEst));
122511 memcpy(&p1->a[1], p2->a, p2->nSrc*sizeof(SrcItem));
123215 memcpy(pColl, pColl2, sizeof(CollSeq));
123281 memcpy(pColl[0].zName, zName, nName);
123617 memcpy((char*)&pBest[1], zName, nName+1);
125634 memcpy(&backupInfo, pInfo, sizeof(backupInfo));
126044 memcpy(&zOut[j], zRep, nRep);
126050 memcpy(&zOut[j], &zStr[i], nStr-i);
126715 /* The memcpy() statement assumes that the wildcard characters are
126719 memcpy(aWc, pDef->pUserData, 3);
128477 memcpy((char *)pStep->zTarget, zFrom, nFrom);
133253 memcpy(zAltEntry, "sqlite3_", 8);
133262 memcpy(zAltEntry+iEntry, "_init", 6);
133299 memcpy(aHandle, db->aExtension, sizeof(handle)*db->nExtension);
140564 memcpy(&pCol->zCnName[n+1], zType, m+1);
146254 memcpy(z, argv[i], n);
146829 memcpy(z, pName->z, pName->n);
149996 memcpy(zCopy, zName, nName+1);
151118 memcpy((char*)&pNew[1], pDef->zName, sqlite3Strlen30(pDef->zName)+1);
154090 memcpy(pOrTab->a, pTabItem, sizeof(*pTabItem));
154093 memcpy(&pOrTab->a[k], &origSrc[pLevel[k].iFrom], sizeof(pOrTab->a[k]));
154656 memcpy(&sFrom.a[0], pTabItem, sizeof(SrcItem));
154772 memcpy(pWC->a, pOld, sizeof(pWC->a[0])*pWC->nTerm);
156719 memcpy(aiCur, pWInfo->aiCurOnePass, sizeof(int)*2);
156743 memcpy(pDest->a, pSrc->a, pDest->n*sizeof(pDest->a[0]));
156825 memcpy(pNew, pOld, pOldBlk->sz);
158639 memcpy(zType, "....", 5);
158791 memcpy(paNew, p->aLTerm, sizeof(p->aLTerm[0])*p->nLSlot);
158809 memcpy(pTo, pFrom, WHERE_LOOP_XFER_SZ);
158810 memcpy(pTo->aLTerm, pFrom->aLTerm, pTo->nLTerm*sizeof(pTo->aLTerm[0]));
161587 memcpy(pTo->aLoop, pFrom->aLoop, sizeof(WhereLoop*)*iLoop);
164218 memcpy(pTab, pTab2, sizeof(Table));
166404 memcpy(p->u.zToken, t.z, t.n);
173755 memcpy(&y, &x, 8);
176549 memcpy(zFile, zUri, nUri);
176715 memcpy(db->aLimit, aHardLimit, sizeof(db->aLimit));
177977 memcpy(p, z, n+1);
178630 memcpy(pNew, aArg, nArg*sizeof(void *));
180786 memcpy(p, zCol, n);
181083 memcpy(p->aIndex, aIndex, sizeof(struct Fts3Index) * nIndex);
181093 memcpy(zCsr, argv[2], nName);
181096 memcpy(zCsr, argv[1], nDb);
181105 memcpy(zCsr, z, n);
181597 memcpy(&zBuffer[nPrefix], zCsr, nSuffix);
181755 memcpy(p, *ppPoslist, n);
181793 memcpy(p, *ppPoslist, n);
182517 ** buffer using memcpy().
182535 memcpy(pTS->aaOutput[0], aDoclist, nDoclist);
184391 memcpy(aDoclist, a[p->nToken-1].pList, nByte+1);
185871 memcpy((char *)p->pFts3Tab->zDb, zDb, nDb);
185872 memcpy((char *)p->pFts3Tab->zName, zFts3, nFts3);
186535 memcpy(pRet->pPhrase->aToken[0].z, zToken, nToken);
186650 memcpy(&zTemp[nTemp], zByte, nByte);
186678 memcpy(zBuf, zTemp, nTemp);
187984 memcpy((void*)new_elem->pKey, pKey, nKey);
189062 memcpy((void *)pp, sqlite3_column_blob(pStmt, 0), sizeof(*pp));
189559 memcpy(pSpace, argv[i], n+1);
189780 if( nByte>0 ) memcpy(pCsr->zInput, zByte, nByte);
191233 memcpy(pReader->zTerm, fts3HashKey(pElem), nTerm);
191239 memcpy(aCopy, pList->aData, nCopy);
191304 memcpy(&pReader->zTerm[nPrefix], pNext, nSuffix);
191540 if( nRoot ) memcpy(pReader->aNode, zRoot, nRoot);
191664 memcpy(pReader->ppNextElem, aElem, nElem*sizeof(Fts3HashElem *));
191962 memcpy(&pTree->aData[nData], &zTerm[nPrefix], nSuffix);
191976 memcpy(pTree->zTerm, zTerm, nTerm);
192233 memcpy(&pWriter->aData[nData], &zTerm[nPrefix], nSuffix);
192237 memcpy(&pWriter->aData[nData], aDoclist, nDoclist);
192257 memcpy(pWriter->zTerm, zTerm, nTerm);
192566 memcpy(pMsr->aBuffer, pList, nList);
192919 memcpy(&pCsr->aBuffer[nDoclist], pList, nList);
193684 memcpy(&p->term.a[nPrefix], &p->aNode[p->iOff], nSuffix);
193793 memcpy(&pBlk->a[pBlk->n], &zTerm[nPrefix], nSuffix);
193796 memcpy(pNode->key.a, zTerm, nTerm);
193870 memcpy(pPrev->a, zTerm, nTerm);
193877 memcpy(&pNode->a[pNode->n], &zTerm[nPrefix], nSuffix);
193882 memcpy(&pNode->a[pNode->n], aDoclist, nDoclist);
194228 memcpy(pNode->block.a, aRoot, nRoot);
194244 memcpy(pNode->key.a, reader.term.a, reader.term.n);
194257 memcpy(pNode->block.a, aBlock, nBlock);
194728 if( ALWAYS(pHint->a!=0) ) memcpy(pHint->a, aHint, nHint);
195456 memcpy(pRet, &p->pList->aData[nSkip], *pnData);
195852 memcpy(pRet->zMatchinfo, zMatchinfo, nStr+1);
195893 if( p->bGlobal ) memcpy(aOut, &p->aMatchinfo[1], p->nElem*sizeof(u32));
195903 memcpy(&p->aMatchinfo[2+p->nElem], &p->aMatchinfo[1], p->nElem*sizeof(u32));
196330 memcpy(&pStr->z[pStr->n], zAppend, nAppend);
198445 memcpy(zNew, p->zBuf, (size_t)p->nUsed);
198465 memcpy(p->zBuf+p->nUsed, zIn, N);
199302 memcpy((char*)p->zJson, zJson, nJson+1);
200767 memcpy(p->zJson, z, (size_t)n+1);
200789 memcpy(p->zRoot, zRoot, (size_t)n+1);
201469 memcpy(&x, p, 8);
201473 memcpy(&x, p, 8);
201477 memcpy(&x, p, 8);
201509 memcpy(p, &i, 4);
201512 memcpy(p, &i, 4);
201515 memcpy(p, &i, 4);
201528 memcpy(p, &i, 8);
201531 memcpy(p, &i, 8);
201533 memcpy(p, &i, 8);
202116 memcpy(&c.u,a,4); \
202124 memcpy(&c.u,a,4); \
202759 memcpy(pBlob, pSrc, pSrc->iSize);
203105 memcpy(&cell, p, sizeof(RtreeCell));
203296 memcpy(aSpare, aLeft, sizeof(int)*nLeft);
203365 memcpy(aSpare, aLeft, sizeof(int)*nLeft);
203456 memcpy(&left, &aCell[aaSorted[ii][0]], sizeof(RtreeCell));
203457 memcpy(&right, &aCell[aaSorted[ii][nCell-1]], sizeof(RtreeCell));
203486 memcpy(pBboxLeft, &aCell[aaSorted[iBestDim][0]], sizeof(RtreeCell));
203487 memcpy(pBboxRight, &aCell[aaSorted[iBestDim][iBestSplit]], sizeof(RtreeCell));
203559 memcpy(&aCell[nCell], pCell, sizeof(RtreeCell));
203856 memcpy(&aCell[ii], pCell, sizeof(RtreeCell));
204720 memcpy(pRtree->zDb, argv[1], nDb);
204721 memcpy(pRtree->zName, argv[2], nName);
205000 memcpy(pRet, pNode, nNode);
205623 memcpy(pOut->a, s.a, s.nVertex*2*sizeof(GeoCoord));
205676 memcpy(p->hdr, a, nByte);
206087 memcpy(pBBox->a, a, sizeof(RtreeCoord)*4);
206604 memcpy(pRtree->zDb, argv[1], nDb);
206605 memcpy(pRtree->zName, argv[2], nName);
207978 memcpy(p->zLocale, argv[0], n);
209417 memcpy(zOut, &zSrc[ofst], cnt);
209432 memcpy(zOut, zDelta, cnt);
209929 memcpy(zRet, zStr, nCopy);
210085 memcpy(pIter->abIndexed, pIter->abTblPk, sizeof(u8)*pIter->nTblCol);
211439 memcpy(pUp->zMask, zMask, pIter->nTblCol);
211603 memcpy(p->zStateDb, "stat", 4);
211605 memcpy(p->zStateDb, "main", 4);
212803 memcpy(p->zTarget, zTarget, nTarget+1);
212807 memcpy(p->zRbu, zRbu, nRbu+1);
214139 memcpy(&pNew->base, &vfs_template, sizeof(sqlite3_vfs));
214144 memcpy(zSpace, zName, nName);
214739 memcpy(pPg->aPg, a, pgsz);
215449 memcpy(sqlite3PagerGetData(pDbPage), pData, szPage);
215914 memcpy(&i, &r, 8);
215938 if( n>0 ) memcpy(&aBuf[nVarint + 1], z, n);
216064 memcpy(&iVal, &rVal, 8);
216220 memcpy(aOut, a2, n2);
216223 memcpy(aOut, a1, n1);
216318 memcpy(aOut, aOld, nOld);
216346 memcpy(aOut, aNew, nNew);
216408 memcpy(&rVal, &iVal, 8);
216590 memcpy(pAlloc, zThis, nThis+1);
216600 memcpy(pAlloc, zName, nName+1);
216757 memcpy(&dVal, &iVal, 8);
217366 memcpy(pNew->zDb, zDb, nDb+1);
217494 memcpy(pTab->zName, zName, nName+1);
217610 memcpy(&p->aBuf[p->nBuf], aBlob, nBlob);
217630 memcpy(&p->aBuf[p->nBuf], zStr, nStr);
217703 memcpy(&i, &r, 8);
217787 memcpy(&dVal, &iVal, 8);
217993 memcpy(&rVal, &iVal, 8);
218492 memcpy(aCopy, aData, nData);
218576 memcpy(&d, &v, 8);
218712 memcpy(&p->tblhdr.aBuf[iPK], &p->in.aData[p->in.iNext], nCopy);
219384 memcpy(pUp->aMask, p->aUpdateMask, nU32*sizeof(u32));
220505 memcpy(pNew->aRecord, aRec, nRec);
220517 memcpy(pOut, pIn, nIn);
220549 memcpy(pOut, a1, n1);
220552 memcpy(pOut, a2, n2);
220615 memcpy(aCsr, aRec, nRec);
220640 memcpy(aCsr, aRec, nRec);
220710 memcpy(pTab->abPK, abPK, nCol);
220712 memcpy(pTab->zName, zNew, nNew+1);
221003 memcpy(pOut, a2, nn2);
221006 memcpy(pOut, a1, nn1);
221059 memcpy(pOut, a1, n1);
221063 memcpy(pOut, a2, n2);
221077 memcpy(pOut, a1, n1);
225068 memcpy(&pBuf->p[pBuf->n], pData, nData);
225287 memcpy(zRet, pIn, nIn);
225382 memcpy(pEntry->pTerm, pTerm, nTerm);
225722 memcpy(pSpace, p2, p-p2);
225842 memcpy(zOut, zIn, (size_t)(nIn+1));
226191 if( zRank ) memcpy(zRank, pRank, p-pRank);
226211 if( zRankArgs ) memcpy(zRankArgs, pArgs, p-pArgs);
226854 memcpy(aNew, aIter, sizeof(Fts5PoslistReader) * nIter);
228060 memcpy(pSyn->zTerm, pToken, nToken);
228225 memcpy(pColset, pColsetOrig, (size_t)nByte);
228442 memcpy(pRet, pOrig, (size_t)nByte);
228569 memcpy(&p->apChild[p->nChild], pSub->apChild, nByte);
229734 memcpy(&zKey[1], pToken, nToken);
229954 memcpy(&pRet[nPre], &((u8*)p)[nHashPre], nList);
230863 memcpy(pNew, p, nByte);
230876 memcpy(pLvl->aSeg, p->aLevel[i].aSeg, nByte);
231164 memcpy(&(pBuf)->p[(pBuf)->n], pBlob, nBlob); \
231262 memcpy(pOut->aSeg, &pLvl->aSeg[is], sizeof(Fts5StructureSegment));
235327 if( doclist.n ) memcpy(pData->p, doclist.p, doclist.n);
235575 if( nToken>0 ) memcpy(&buf.p[1], pToken, nToken);
236571 if( n>0 ) memcpy(a, aBlob, n);
239448 memcpy(pAux->zFunc, zName, nName);
239486 memcpy(pNew->zName, zName, nName);
241005 memcpy(p->aTokenChar, aAsciiTokenChar, sizeof(aAsciiTokenChar));
241424 memcpy(aFold, p->aFold, nFold);
241565 memcpy(&aBuf[nStem], p->zOutput, p->nOutput);
241804 memcpy(&aBuf[nBuf-2], "ate", 3);
241812 memcpy(&aBuf[nBuf-2], "ble", 3);
241820 memcpy(&aBuf[nBuf-2], "ize", 3);
241839 memcpy(&aBuf[nBuf-7], "ate", 3);
241844 memcpy(&aBuf[nBuf-6], "tion", 4);
241853 memcpy(&aBuf[nBuf-4], "ence", 4);
241858 memcpy(&aBuf[nBuf-4], "ance", 4);
241867 memcpy(&aBuf[nBuf-4], "ize", 3);
241876 memcpy(&aBuf[nBuf-4], "log", 3);
241885 memcpy(&aBuf[nBuf-3], "ble", 3);
241890 memcpy(&aBuf[nBuf-4], "al", 2);
241895 memcpy(&aBuf[nBuf-5], "ent", 3);
241900 memcpy(&aBuf[nBuf-3], "e", 1);
241905 memcpy(&aBuf[nBuf-5], "ous", 3);
241914 memcpy(&aBuf[nBuf-7], "ize", 3);
241919 memcpy(&aBuf[nBuf-5], "ate", 3);
241924 memcpy(&aBuf[nBuf-4], "ate", 3);
241933 memcpy(&aBuf[nBuf-5], "al", 2);
241938 memcpy(&aBuf[nBuf-7], "ive", 3);
241943 memcpy(&aBuf[nBuf-7], "ful", 3);
241948 memcpy(&aBuf[nBuf-7], "ous", 3);
241957 memcpy(&aBuf[nBuf-5], "al", 2);
241962 memcpy(&aBuf[nBuf-5], "ive", 3);
241967 memcpy(&aBuf[nBuf-6], "ble", 3);
241986 memcpy(&aBuf[nBuf-4], "ic", 2);
242003 memcpy(&aBuf[nBuf-5], "ic", 2);
242008 memcpy(&aBuf[nBuf-5], "ic", 2);
242033 memcpy(&aBuf[nBuf-5], "al", 2);
242052 memcpy(&aBuf[nBuf-3], "ee", 2);
242115 memcpy(aBuf, pToken, nBuf);
243679 memcpy(pRet->zFts5Tbl, zTab, nTab);
243680 memcpy(pRet->zFts5Db, zDb, nDb);
244110 memcpy(pCsr->zLeTerm, zCopy, pCsr->nLeTerm+1);
244492 memcpy(pNew->zSql, zSql, nSql);