mirror of https://github.com/sqlite/sqlite
Change the Vdbe.aMem array so that it is zero-based instead of one-based.
FossilOrigin-Name: e07b0c47eb5a39623f5fe0e66b939bba0906691c
This commit is contained in:
parent
b6eb666264
commit
9f6168b6a3
21
manifest
21
manifest
|
@ -1,5 +1,5 @@
|
||||||
C Fix\sexclusive.test\sso\sthat\sit\sworks\swith\s-DSQLITE_TEMP_STORE=3.
|
C Change\sthe\sVdbe.aMem\sarray\sso\sthat\sit\sis\szero-based\sinstead\sof\sone-based.
|
||||||
D 2016-03-19T18:11:59.750
|
D 2016-03-19T23:32:59.000
|
||||||
F Makefile.in f53429fb2f313c099283659d0df6f20f932c861f
|
F Makefile.in f53429fb2f313c099283659d0df6f20f932c861f
|
||||||
F Makefile.linux-gcc 7bc79876b875010e8c8f9502eb935ca92aa3c434
|
F Makefile.linux-gcc 7bc79876b875010e8c8f9502eb935ca92aa3c434
|
||||||
F Makefile.msc df0bf9ff7f8b3f4dd9fb4cc43f92fe58f6ec5c66
|
F Makefile.msc df0bf9ff7f8b3f4dd9fb4cc43f92fe58f6ec5c66
|
||||||
|
@ -417,13 +417,13 @@ F src/update.c 56b3db7edff0110360a12b76af97c39ebe3ea8b8
|
||||||
F src/utf.c 699001c79f28e48e9bcdf8a463da029ea660540c
|
F src/utf.c 699001c79f28e48e9bcdf8a463da029ea660540c
|
||||||
F src/util.c 34ef7be420f82415ec48131404995ddb6ee7502f
|
F src/util.c 34ef7be420f82415ec48131404995ddb6ee7502f
|
||||||
F src/vacuum.c feb1eabb20987983d9350cad98299b21fa811f52
|
F src/vacuum.c feb1eabb20987983d9350cad98299b21fa811f52
|
||||||
F src/vdbe.c 8cf45bb8da77d39f55d108e759d15a57acd0255c
|
F src/vdbe.c 90d18d0a91284092a099e9a048982df38920190c
|
||||||
F src/vdbe.h 6f44193e7be52fd5f7c308175a936555b1e6b101
|
F src/vdbe.h 6f44193e7be52fd5f7c308175a936555b1e6b101
|
||||||
F src/vdbeInt.h f88d3115e9bde33b01d81f0dd26d8dd51f995991
|
F src/vdbeInt.h f88d3115e9bde33b01d81f0dd26d8dd51f995991
|
||||||
F src/vdbeapi.c 95b1f8e527240a18a9aea41a655b013bf07a7009
|
F src/vdbeapi.c 95b1f8e527240a18a9aea41a655b013bf07a7009
|
||||||
F src/vdbeaux.c a930f913d40e4ca6f6caaef6a7b5906a369fa2b1
|
F src/vdbeaux.c 4a38b9f9dab7350f670b9efff25f605933f81963
|
||||||
F src/vdbeblob.c 3b570b730109e8f653d9d2081649f6e7015113db
|
F src/vdbeblob.c 3b570b730109e8f653d9d2081649f6e7015113db
|
||||||
F src/vdbemem.c 9b0cb32cc267ef026515f15a3594d5ff91fe4dfc
|
F src/vdbemem.c fe76c1f866de362d9b8332e59d74aa44f6560d69
|
||||||
F src/vdbesort.c 307460bfa4de4d1c3901fcd42089159131e34062
|
F src/vdbesort.c 307460bfa4de4d1c3901fcd42089159131e34062
|
||||||
F src/vdbetrace.c f75c5455d8cf389ef86a8bfdfd3177e0e3692484
|
F src/vdbetrace.c f75c5455d8cf389ef86a8bfdfd3177e0e3692484
|
||||||
F src/vtab.c fd69fd398e23e57ea4ea377d8a44b6998fc569c7
|
F src/vtab.c fd69fd398e23e57ea4ea377d8a44b6998fc569c7
|
||||||
|
@ -1457,7 +1457,10 @@ F vsixtest/vsixtest.tcl 6a9a6ab600c25a91a7acc6293828957a386a8a93
|
||||||
F vsixtest/vsixtest.vcxproj.data 2ed517e100c66dc455b492e1a33350c1b20fbcdc
|
F vsixtest/vsixtest.vcxproj.data 2ed517e100c66dc455b492e1a33350c1b20fbcdc
|
||||||
F vsixtest/vsixtest.vcxproj.filters 37e51ffedcdb064aad6ff33b6148725226cd608e
|
F vsixtest/vsixtest.vcxproj.filters 37e51ffedcdb064aad6ff33b6148725226cd608e
|
||||||
F vsixtest/vsixtest_TemporaryKey.pfx e5b1b036facdb453873e7084e1cae9102ccc67a0
|
F vsixtest/vsixtest_TemporaryKey.pfx e5b1b036facdb453873e7084e1cae9102ccc67a0
|
||||||
P f095341471aa822e6d556cb65512ec081c3918da
|
P d7852c639683a1d305a1e731df3cccafa64b594b
|
||||||
R eda7e2fd58d6241fa97b2fe69addd6c1
|
R 4a4c5282463bb7b6f1f36414c3f19a6f
|
||||||
U dan
|
T *branch * zero-base-aMem
|
||||||
Z fdac7ca02eef2361aeb61c0eeeaed018
|
T *sym-zero-base-aMem *
|
||||||
|
T -sym-trunk *
|
||||||
|
U drh
|
||||||
|
Z 5ba539d03a989ddc8c4359f1a3ede74d
|
||||||
|
|
|
@ -1 +1 @@
|
||||||
d7852c639683a1d305a1e731df3cccafa64b594b
|
e07b0c47eb5a39623f5fe0e66b939bba0906691c
|
82
src/vdbe.c
82
src/vdbe.c
|
@ -192,11 +192,11 @@ static VdbeCursor *allocateCursor(
|
||||||
** be freed lazily via the sqlite3_release_memory() API. This
|
** be freed lazily via the sqlite3_release_memory() API. This
|
||||||
** minimizes the number of malloc calls made by the system.
|
** minimizes the number of malloc calls made by the system.
|
||||||
**
|
**
|
||||||
** Memory cells for cursors are allocated at the top of the address
|
** Memory cell for cursor 0 is Mem[0]. The rest are allocated from
|
||||||
** space. Memory cell (p->nMem) corresponds to cursor 0. Space for
|
** the top of the register space. Cursor 1 is at Mem[p->nMem-1].
|
||||||
** cursor 1 is managed by memory cell (p->nMem-1), etc.
|
** Cursor 2 is at Mem[p->nMem-2]. And so forth.
|
||||||
*/
|
*/
|
||||||
Mem *pMem = &p->aMem[p->nMem-iCur];
|
Mem *pMem = iCur>0 ? &p->aMem[p->nMem-iCur] : p->aMem;
|
||||||
|
|
||||||
int nByte;
|
int nByte;
|
||||||
VdbeCursor *pCx = 0;
|
VdbeCursor *pCx = 0;
|
||||||
|
@ -204,7 +204,7 @@ static VdbeCursor *allocateCursor(
|
||||||
ROUND8(sizeof(VdbeCursor)) + 2*sizeof(u32)*nField +
|
ROUND8(sizeof(VdbeCursor)) + 2*sizeof(u32)*nField +
|
||||||
(eCurType==CURTYPE_BTREE?sqlite3BtreeCursorSize():0);
|
(eCurType==CURTYPE_BTREE?sqlite3BtreeCursorSize():0);
|
||||||
|
|
||||||
assert( iCur<p->nCursor );
|
assert( iCur>=0 && iCur<p->nCursor );
|
||||||
if( p->apCsr[iCur] ){
|
if( p->apCsr[iCur] ){
|
||||||
sqlite3VdbeFreeCursor(p, p->apCsr[iCur]);
|
sqlite3VdbeFreeCursor(p, p->apCsr[iCur]);
|
||||||
p->apCsr[iCur] = 0;
|
p->apCsr[iCur] = 0;
|
||||||
|
@ -529,7 +529,7 @@ static SQLITE_NOINLINE Mem *out2PrereleaseWithClear(Mem *pOut){
|
||||||
static Mem *out2Prerelease(Vdbe *p, VdbeOp *pOp){
|
static Mem *out2Prerelease(Vdbe *p, VdbeOp *pOp){
|
||||||
Mem *pOut;
|
Mem *pOut;
|
||||||
assert( pOp->p2>0 );
|
assert( pOp->p2>0 );
|
||||||
assert( pOp->p2<=(p->nMem-p->nCursor) );
|
assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
|
||||||
pOut = &p->aMem[pOp->p2];
|
pOut = &p->aMem[pOp->p2];
|
||||||
memAboutToChange(p, pOut);
|
memAboutToChange(p, pOut);
|
||||||
if( VdbeMemDynamic(pOut) ){
|
if( VdbeMemDynamic(pOut) ){
|
||||||
|
@ -667,33 +667,33 @@ int sqlite3VdbeExec(
|
||||||
assert( pOp->opflags==sqlite3OpcodeProperty[pOp->opcode] );
|
assert( pOp->opflags==sqlite3OpcodeProperty[pOp->opcode] );
|
||||||
if( (pOp->opflags & OPFLG_IN1)!=0 ){
|
if( (pOp->opflags & OPFLG_IN1)!=0 ){
|
||||||
assert( pOp->p1>0 );
|
assert( pOp->p1>0 );
|
||||||
assert( pOp->p1<=(p->nMem-p->nCursor) );
|
assert( pOp->p1<=(p->nMem+1 - p->nCursor) );
|
||||||
assert( memIsValid(&aMem[pOp->p1]) );
|
assert( memIsValid(&aMem[pOp->p1]) );
|
||||||
assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p1]) );
|
assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p1]) );
|
||||||
REGISTER_TRACE(pOp->p1, &aMem[pOp->p1]);
|
REGISTER_TRACE(pOp->p1, &aMem[pOp->p1]);
|
||||||
}
|
}
|
||||||
if( (pOp->opflags & OPFLG_IN2)!=0 ){
|
if( (pOp->opflags & OPFLG_IN2)!=0 ){
|
||||||
assert( pOp->p2>0 );
|
assert( pOp->p2>0 );
|
||||||
assert( pOp->p2<=(p->nMem-p->nCursor) );
|
assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
|
||||||
assert( memIsValid(&aMem[pOp->p2]) );
|
assert( memIsValid(&aMem[pOp->p2]) );
|
||||||
assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p2]) );
|
assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p2]) );
|
||||||
REGISTER_TRACE(pOp->p2, &aMem[pOp->p2]);
|
REGISTER_TRACE(pOp->p2, &aMem[pOp->p2]);
|
||||||
}
|
}
|
||||||
if( (pOp->opflags & OPFLG_IN3)!=0 ){
|
if( (pOp->opflags & OPFLG_IN3)!=0 ){
|
||||||
assert( pOp->p3>0 );
|
assert( pOp->p3>0 );
|
||||||
assert( pOp->p3<=(p->nMem-p->nCursor) );
|
assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
|
||||||
assert( memIsValid(&aMem[pOp->p3]) );
|
assert( memIsValid(&aMem[pOp->p3]) );
|
||||||
assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p3]) );
|
assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p3]) );
|
||||||
REGISTER_TRACE(pOp->p3, &aMem[pOp->p3]);
|
REGISTER_TRACE(pOp->p3, &aMem[pOp->p3]);
|
||||||
}
|
}
|
||||||
if( (pOp->opflags & OPFLG_OUT2)!=0 ){
|
if( (pOp->opflags & OPFLG_OUT2)!=0 ){
|
||||||
assert( pOp->p2>0 );
|
assert( pOp->p2>0 );
|
||||||
assert( pOp->p2<=(p->nMem-p->nCursor) );
|
assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
|
||||||
memAboutToChange(p, &aMem[pOp->p2]);
|
memAboutToChange(p, &aMem[pOp->p2]);
|
||||||
}
|
}
|
||||||
if( (pOp->opflags & OPFLG_OUT3)!=0 ){
|
if( (pOp->opflags & OPFLG_OUT3)!=0 ){
|
||||||
assert( pOp->p3>0 );
|
assert( pOp->p3>0 );
|
||||||
assert( pOp->p3<=(p->nMem-p->nCursor) );
|
assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
|
||||||
memAboutToChange(p, &aMem[pOp->p3]);
|
memAboutToChange(p, &aMem[pOp->p3]);
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
@ -792,7 +792,7 @@ check_for_interrupt:
|
||||||
** and then jump to address P2.
|
** and then jump to address P2.
|
||||||
*/
|
*/
|
||||||
case OP_Gosub: { /* jump */
|
case OP_Gosub: { /* jump */
|
||||||
assert( pOp->p1>0 && pOp->p1<=(p->nMem-p->nCursor) );
|
assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
|
||||||
pIn1 = &aMem[pOp->p1];
|
pIn1 = &aMem[pOp->p1];
|
||||||
assert( VdbeMemDynamic(pIn1)==0 );
|
assert( VdbeMemDynamic(pIn1)==0 );
|
||||||
memAboutToChange(p, pIn1);
|
memAboutToChange(p, pIn1);
|
||||||
|
@ -832,7 +832,7 @@ case OP_Return: { /* in1 */
|
||||||
** See also: EndCoroutine
|
** See also: EndCoroutine
|
||||||
*/
|
*/
|
||||||
case OP_InitCoroutine: { /* jump */
|
case OP_InitCoroutine: { /* jump */
|
||||||
assert( pOp->p1>0 && pOp->p1<=(p->nMem-p->nCursor) );
|
assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
|
||||||
assert( pOp->p2>=0 && pOp->p2<p->nOp );
|
assert( pOp->p2>=0 && pOp->p2<p->nOp );
|
||||||
assert( pOp->p3>=0 && pOp->p3<p->nOp );
|
assert( pOp->p3>=0 && pOp->p3<p->nOp );
|
||||||
pOut = &aMem[pOp->p1];
|
pOut = &aMem[pOp->p1];
|
||||||
|
@ -1101,7 +1101,7 @@ case OP_String: { /* out2 */
|
||||||
#ifndef SQLITE_LIKE_DOESNT_MATCH_BLOBS
|
#ifndef SQLITE_LIKE_DOESNT_MATCH_BLOBS
|
||||||
if( pOp->p5 ){
|
if( pOp->p5 ){
|
||||||
assert( pOp->p3>0 );
|
assert( pOp->p3>0 );
|
||||||
assert( pOp->p3<=(p->nMem-p->nCursor) );
|
assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
|
||||||
pIn3 = &aMem[pOp->p3];
|
pIn3 = &aMem[pOp->p3];
|
||||||
assert( pIn3->flags & MEM_Int );
|
assert( pIn3->flags & MEM_Int );
|
||||||
if( pIn3->u.i ) pOut->flags = MEM_Blob|MEM_Static|MEM_Term;
|
if( pIn3->u.i ) pOut->flags = MEM_Blob|MEM_Static|MEM_Term;
|
||||||
|
@ -1127,7 +1127,7 @@ case OP_Null: { /* out2 */
|
||||||
u16 nullFlag;
|
u16 nullFlag;
|
||||||
pOut = out2Prerelease(p, pOp);
|
pOut = out2Prerelease(p, pOp);
|
||||||
cnt = pOp->p3-pOp->p2;
|
cnt = pOp->p3-pOp->p2;
|
||||||
assert( pOp->p3<=(p->nMem-p->nCursor) );
|
assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
|
||||||
pOut->flags = nullFlag = pOp->p1 ? (MEM_Null|MEM_Cleared) : MEM_Null;
|
pOut->flags = nullFlag = pOp->p1 ? (MEM_Null|MEM_Cleared) : MEM_Null;
|
||||||
while( cnt>0 ){
|
while( cnt>0 ){
|
||||||
pOut++;
|
pOut++;
|
||||||
|
@ -1148,7 +1148,7 @@ case OP_Null: { /* out2 */
|
||||||
** previously copied using OP_SCopy, the copies will continue to be valid.
|
** previously copied using OP_SCopy, the copies will continue to be valid.
|
||||||
*/
|
*/
|
||||||
case OP_SoftNull: {
|
case OP_SoftNull: {
|
||||||
assert( pOp->p1>0 && pOp->p1<=(p->nMem-p->nCursor) );
|
assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
|
||||||
pOut = &aMem[pOp->p1];
|
pOut = &aMem[pOp->p1];
|
||||||
pOut->flags = (pOut->flags|MEM_Null)&~MEM_Undefined;
|
pOut->flags = (pOut->flags|MEM_Null)&~MEM_Undefined;
|
||||||
break;
|
break;
|
||||||
|
@ -1215,8 +1215,8 @@ case OP_Move: {
|
||||||
pIn1 = &aMem[p1];
|
pIn1 = &aMem[p1];
|
||||||
pOut = &aMem[p2];
|
pOut = &aMem[p2];
|
||||||
do{
|
do{
|
||||||
assert( pOut<=&aMem[(p->nMem-p->nCursor)] );
|
assert( pOut<=&aMem[(p->nMem+1 - p->nCursor)] );
|
||||||
assert( pIn1<=&aMem[(p->nMem-p->nCursor)] );
|
assert( pIn1<=&aMem[(p->nMem+1 - p->nCursor)] );
|
||||||
assert( memIsValid(pIn1) );
|
assert( memIsValid(pIn1) );
|
||||||
memAboutToChange(p, pOut);
|
memAboutToChange(p, pOut);
|
||||||
sqlite3VdbeMemMove(pOut, pIn1);
|
sqlite3VdbeMemMove(pOut, pIn1);
|
||||||
|
@ -1316,7 +1316,7 @@ case OP_ResultRow: {
|
||||||
int i;
|
int i;
|
||||||
assert( p->nResColumn==pOp->p2 );
|
assert( p->nResColumn==pOp->p2 );
|
||||||
assert( pOp->p1>0 );
|
assert( pOp->p1>0 );
|
||||||
assert( pOp->p1+pOp->p2<=(p->nMem-p->nCursor)+1 );
|
assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 );
|
||||||
|
|
||||||
#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
|
#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
|
||||||
/* Run the progress counter just before returning.
|
/* Run the progress counter just before returning.
|
||||||
|
@ -1628,8 +1628,8 @@ case OP_Function0: {
|
||||||
|
|
||||||
assert( pOp->p4type==P4_FUNCDEF );
|
assert( pOp->p4type==P4_FUNCDEF );
|
||||||
n = pOp->p5;
|
n = pOp->p5;
|
||||||
assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
|
assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
|
||||||
assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem-p->nCursor)+1) );
|
assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem+1 - p->nCursor)+1) );
|
||||||
assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
|
assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
|
||||||
pCtx = sqlite3DbMallocRawNN(db, sizeof(*pCtx) + (n-1)*sizeof(sqlite3_value*));
|
pCtx = sqlite3DbMallocRawNN(db, sizeof(*pCtx) + (n-1)*sizeof(sqlite3_value*));
|
||||||
if( pCtx==0 ) goto no_mem;
|
if( pCtx==0 ) goto no_mem;
|
||||||
|
@ -2129,11 +2129,11 @@ case OP_Compare: {
|
||||||
if( aPermute ){
|
if( aPermute ){
|
||||||
int k, mx = 0;
|
int k, mx = 0;
|
||||||
for(k=0; k<n; k++) if( aPermute[k]>mx ) mx = aPermute[k];
|
for(k=0; k<n; k++) if( aPermute[k]>mx ) mx = aPermute[k];
|
||||||
assert( p1>0 && p1+mx<=(p->nMem-p->nCursor)+1 );
|
assert( p1>0 && p1+mx<=(p->nMem+1 - p->nCursor)+1 );
|
||||||
assert( p2>0 && p2+mx<=(p->nMem-p->nCursor)+1 );
|
assert( p2>0 && p2+mx<=(p->nMem+1 - p->nCursor)+1 );
|
||||||
}else{
|
}else{
|
||||||
assert( p1>0 && p1+n<=(p->nMem-p->nCursor)+1 );
|
assert( p1>0 && p1+n<=(p->nMem+1 - p->nCursor)+1 );
|
||||||
assert( p2>0 && p2+n<=(p->nMem-p->nCursor)+1 );
|
assert( p2>0 && p2+n<=(p->nMem+1 - p->nCursor)+1 );
|
||||||
}
|
}
|
||||||
#endif /* SQLITE_DEBUG */
|
#endif /* SQLITE_DEBUG */
|
||||||
for(i=0; i<n; i++){
|
for(i=0; i<n; i++){
|
||||||
|
@ -2395,7 +2395,7 @@ case OP_Column: {
|
||||||
/* If the cursor cache is stale, bring it up-to-date */
|
/* If the cursor cache is stale, bring it up-to-date */
|
||||||
rc = sqlite3VdbeCursorMoveto(&pC, &p2);
|
rc = sqlite3VdbeCursorMoveto(&pC, &p2);
|
||||||
|
|
||||||
assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
|
assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
|
||||||
pDest = &aMem[pOp->p3];
|
pDest = &aMem[pOp->p3];
|
||||||
memAboutToChange(p, pDest);
|
memAboutToChange(p, pDest);
|
||||||
assert( pOp->p1>=0 && pOp->p1<p->nCursor );
|
assert( pOp->p1>=0 && pOp->p1<p->nCursor );
|
||||||
|
@ -2638,7 +2638,7 @@ case OP_Affinity: {
|
||||||
assert( zAffinity[pOp->p2]==0 );
|
assert( zAffinity[pOp->p2]==0 );
|
||||||
pIn1 = &aMem[pOp->p1];
|
pIn1 = &aMem[pOp->p1];
|
||||||
while( (cAff = *(zAffinity++))!=0 ){
|
while( (cAff = *(zAffinity++))!=0 ){
|
||||||
assert( pIn1 <= &p->aMem[(p->nMem-p->nCursor)] );
|
assert( pIn1 <= &p->aMem[(p->nMem+1 - p->nCursor)] );
|
||||||
assert( memIsValid(pIn1) );
|
assert( memIsValid(pIn1) );
|
||||||
applyAffinity(pIn1, cAff, encoding);
|
applyAffinity(pIn1, cAff, encoding);
|
||||||
pIn1++;
|
pIn1++;
|
||||||
|
@ -2700,7 +2700,7 @@ case OP_MakeRecord: {
|
||||||
nZero = 0; /* Number of zero bytes at the end of the record */
|
nZero = 0; /* Number of zero bytes at the end of the record */
|
||||||
nField = pOp->p1;
|
nField = pOp->p1;
|
||||||
zAffinity = pOp->p4.z;
|
zAffinity = pOp->p4.z;
|
||||||
assert( nField>0 && pOp->p2>0 && pOp->p2+nField<=(p->nMem-p->nCursor)+1 );
|
assert( nField>0 && pOp->p2>0 && pOp->p2+nField<=(p->nMem+1 - p->nCursor)+1 );
|
||||||
pData0 = &aMem[nField];
|
pData0 = &aMem[nField];
|
||||||
nField = pOp->p2;
|
nField = pOp->p2;
|
||||||
pLast = &pData0[nField-1];
|
pLast = &pData0[nField-1];
|
||||||
|
@ -2790,7 +2790,7 @@ case OP_MakeRecord: {
|
||||||
assert( i==nHdr );
|
assert( i==nHdr );
|
||||||
assert( j==nByte );
|
assert( j==nByte );
|
||||||
|
|
||||||
assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
|
assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
|
||||||
pOut->n = (int)nByte;
|
pOut->n = (int)nByte;
|
||||||
pOut->flags = MEM_Blob;
|
pOut->flags = MEM_Blob;
|
||||||
if( nZero ){
|
if( nZero ){
|
||||||
|
@ -3376,7 +3376,7 @@ case OP_OpenWrite:
|
||||||
}
|
}
|
||||||
if( pOp->p5 & OPFLAG_P2ISREG ){
|
if( pOp->p5 & OPFLAG_P2ISREG ){
|
||||||
assert( p2>0 );
|
assert( p2>0 );
|
||||||
assert( p2<=(p->nMem-p->nCursor) );
|
assert( p2<=(p->nMem+1 - p->nCursor) );
|
||||||
pIn2 = &aMem[p2];
|
pIn2 = &aMem[p2];
|
||||||
assert( memIsValid(pIn2) );
|
assert( memIsValid(pIn2) );
|
||||||
assert( (pIn2->flags & MEM_Int)!=0 );
|
assert( (pIn2->flags & MEM_Int)!=0 );
|
||||||
|
@ -4171,7 +4171,7 @@ case OP_NewRowid: { /* out2 */
|
||||||
pMem = &pFrame->aMem[pOp->p3];
|
pMem = &pFrame->aMem[pOp->p3];
|
||||||
}else{
|
}else{
|
||||||
/* Assert that P3 is a valid memory cell. */
|
/* Assert that P3 is a valid memory cell. */
|
||||||
assert( pOp->p3<=(p->nMem-p->nCursor) );
|
assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
|
||||||
pMem = &aMem[pOp->p3];
|
pMem = &aMem[pOp->p3];
|
||||||
memAboutToChange(p, pMem);
|
memAboutToChange(p, pMem);
|
||||||
}
|
}
|
||||||
|
@ -4947,7 +4947,7 @@ case OP_IdxDelete: {
|
||||||
UnpackedRecord r;
|
UnpackedRecord r;
|
||||||
|
|
||||||
assert( pOp->p3>0 );
|
assert( pOp->p3>0 );
|
||||||
assert( pOp->p2>0 && pOp->p2+pOp->p3<=(p->nMem-p->nCursor)+1 );
|
assert( pOp->p2>0 && pOp->p2+pOp->p3<=(p->nMem+1 - p->nCursor)+1 );
|
||||||
assert( pOp->p1>=0 && pOp->p1<p->nCursor );
|
assert( pOp->p1>=0 && pOp->p1<p->nCursor );
|
||||||
pC = p->apCsr[pOp->p1];
|
pC = p->apCsr[pOp->p1];
|
||||||
assert( pC!=0 );
|
assert( pC!=0 );
|
||||||
|
@ -5453,7 +5453,7 @@ case OP_IntegrityCk: {
|
||||||
aRoot = pOp->p4.ai;
|
aRoot = pOp->p4.ai;
|
||||||
assert( nRoot>0 );
|
assert( nRoot>0 );
|
||||||
assert( aRoot[nRoot]==0 );
|
assert( aRoot[nRoot]==0 );
|
||||||
assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
|
assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
|
||||||
pnErr = &aMem[pOp->p3];
|
pnErr = &aMem[pOp->p3];
|
||||||
assert( (pnErr->flags & MEM_Int)!=0 );
|
assert( (pnErr->flags & MEM_Int)!=0 );
|
||||||
assert( (pnErr->flags & (MEM_Str|MEM_Blob))==0 );
|
assert( (pnErr->flags & (MEM_Str|MEM_Blob))==0 );
|
||||||
|
@ -5643,6 +5643,7 @@ case OP_Program: { /* jump */
|
||||||
** variable nMem (and later, VdbeFrame.nChildMem) to this value.
|
** variable nMem (and later, VdbeFrame.nChildMem) to this value.
|
||||||
*/
|
*/
|
||||||
nMem = pProgram->nMem + pProgram->nCsr;
|
nMem = pProgram->nMem + pProgram->nCsr;
|
||||||
|
if( pProgram->nCsr==0 && nMem>0 ) nMem++;
|
||||||
nByte = ROUND8(sizeof(VdbeFrame))
|
nByte = ROUND8(sizeof(VdbeFrame))
|
||||||
+ nMem * sizeof(Mem)
|
+ nMem * sizeof(Mem)
|
||||||
+ pProgram->nCsr * sizeof(VdbeCursor *)
|
+ pProgram->nCsr * sizeof(VdbeCursor *)
|
||||||
|
@ -5679,7 +5680,8 @@ case OP_Program: { /* jump */
|
||||||
}
|
}
|
||||||
}else{
|
}else{
|
||||||
pFrame = pRt->u.pFrame;
|
pFrame = pRt->u.pFrame;
|
||||||
assert( pProgram->nMem+pProgram->nCsr==pFrame->nChildMem );
|
assert( pProgram->nMem+pProgram->nCsr==pFrame->nChildMem
|
||||||
|
|| (pProgram->nCsr==0 && pProgram->nMem+1==pFrame->nChildMem) );
|
||||||
assert( pProgram->nCsr==pFrame->nChildCsr );
|
assert( pProgram->nCsr==pFrame->nChildCsr );
|
||||||
assert( (int)(pOp - aOp)==pFrame->pc );
|
assert( (int)(pOp - aOp)==pFrame->pc );
|
||||||
}
|
}
|
||||||
|
@ -5694,10 +5696,10 @@ case OP_Program: { /* jump */
|
||||||
p->pAuxData = 0;
|
p->pAuxData = 0;
|
||||||
p->nChange = 0;
|
p->nChange = 0;
|
||||||
p->pFrame = pFrame;
|
p->pFrame = pFrame;
|
||||||
p->aMem = aMem = &VdbeFrameMem(pFrame)[-1];
|
p->aMem = aMem = VdbeFrameMem(pFrame);
|
||||||
p->nMem = pFrame->nChildMem;
|
p->nMem = pFrame->nChildMem;
|
||||||
p->nCursor = (u16)pFrame->nChildCsr;
|
p->nCursor = (u16)pFrame->nChildCsr;
|
||||||
p->apCsr = (VdbeCursor **)&aMem[p->nMem+1];
|
p->apCsr = (VdbeCursor **)&aMem[p->nMem];
|
||||||
p->aOp = aOp = pProgram->aOp;
|
p->aOp = aOp = pProgram->aOp;
|
||||||
p->nOp = pProgram->nOp;
|
p->nOp = pProgram->nOp;
|
||||||
p->aOnceFlag = (u8 *)&p->apCsr[p->nCursor];
|
p->aOnceFlag = (u8 *)&p->apCsr[p->nCursor];
|
||||||
|
@ -5943,8 +5945,8 @@ case OP_AggStep0: {
|
||||||
|
|
||||||
assert( pOp->p4type==P4_FUNCDEF );
|
assert( pOp->p4type==P4_FUNCDEF );
|
||||||
n = pOp->p5;
|
n = pOp->p5;
|
||||||
assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
|
assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
|
||||||
assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem-p->nCursor)+1) );
|
assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem+1 - p->nCursor)+1) );
|
||||||
assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
|
assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
|
||||||
pCtx = sqlite3DbMallocRawNN(db, sizeof(*pCtx) + (n-1)*sizeof(sqlite3_value*));
|
pCtx = sqlite3DbMallocRawNN(db, sizeof(*pCtx) + (n-1)*sizeof(sqlite3_value*));
|
||||||
if( pCtx==0 ) goto no_mem;
|
if( pCtx==0 ) goto no_mem;
|
||||||
|
@ -6023,7 +6025,7 @@ case OP_AggStep: {
|
||||||
*/
|
*/
|
||||||
case OP_AggFinal: {
|
case OP_AggFinal: {
|
||||||
Mem *pMem;
|
Mem *pMem;
|
||||||
assert( pOp->p1>0 && pOp->p1<=(p->nMem-p->nCursor) );
|
assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
|
||||||
pMem = &aMem[pOp->p1];
|
pMem = &aMem[pOp->p1];
|
||||||
assert( (pMem->flags & ~(MEM_Null|MEM_Agg))==0 );
|
assert( (pMem->flags & ~(MEM_Null|MEM_Agg))==0 );
|
||||||
rc = sqlite3VdbeMemFinalize(pMem, pOp->p4.pFunc);
|
rc = sqlite3VdbeMemFinalize(pMem, pOp->p4.pFunc);
|
||||||
|
@ -6465,7 +6467,7 @@ case OP_VColumn: {
|
||||||
|
|
||||||
VdbeCursor *pCur = p->apCsr[pOp->p1];
|
VdbeCursor *pCur = p->apCsr[pOp->p1];
|
||||||
assert( pCur->eCurType==CURTYPE_VTAB );
|
assert( pCur->eCurType==CURTYPE_VTAB );
|
||||||
assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
|
assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
|
||||||
pDest = &aMem[pOp->p3];
|
pDest = &aMem[pOp->p3];
|
||||||
memAboutToChange(p, pDest);
|
memAboutToChange(p, pDest);
|
||||||
if( pCur->nullRow ){
|
if( pCur->nullRow ){
|
||||||
|
|
|
@ -1801,7 +1801,7 @@ void sqlite3VdbeRewind(Vdbe *p){
|
||||||
p->magic = VDBE_MAGIC_RUN;
|
p->magic = VDBE_MAGIC_RUN;
|
||||||
|
|
||||||
#ifdef SQLITE_DEBUG
|
#ifdef SQLITE_DEBUG
|
||||||
for(i=1; i<p->nMem; i++){
|
for(i=0; i<p->nMem; i++){
|
||||||
assert( p->aMem[i].db==p->db );
|
assert( p->aMem[i].db==p->db );
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
@ -1866,16 +1866,18 @@ void sqlite3VdbeMakeReady(
|
||||||
nOnce = pParse->nOnce;
|
nOnce = pParse->nOnce;
|
||||||
if( nOnce==0 ) nOnce = 1; /* Ensure at least one byte in p->aOnceFlag[] */
|
if( nOnce==0 ) nOnce = 1; /* Ensure at least one byte in p->aOnceFlag[] */
|
||||||
|
|
||||||
/* For each cursor required, also allocate a memory cell. Memory
|
/* For each cursor required, also allocate a memory cell. Memory
|
||||||
** cells (nMem+1-nCursor)..nMem, inclusive, will never be used by
|
** cells 0 and (nMem-nCursor)..nMem-1 inclusive will never be used by
|
||||||
** the vdbe program. Instead they are used to allocate memory for
|
** the vdbe program. Instead they are used to allocate memory for
|
||||||
** VdbeCursor/BtCursor structures. The blob of memory associated with
|
** VdbeCursor/BtCursor structures. The blob of memory associated with
|
||||||
** cursor 0 is stored in memory cell nMem. Memory cell (nMem-1)
|
** cursor 0 is stored in memory cell 0. Memory cell (nMem-1)
|
||||||
** stores the blob of memory associated with cursor 1, etc.
|
** stores the blob of memory associated with cursor 1. Memory cell
|
||||||
|
** (nMem-iCur) is used for cursor iCur.
|
||||||
**
|
**
|
||||||
** See also: allocateCursor().
|
** See also: allocateCursor().
|
||||||
*/
|
*/
|
||||||
nMem += nCursor;
|
nMem += nCursor;
|
||||||
|
if( nCursor==0 && nMem>0 ) nMem++; /* Space for aMem[0] even if not used */
|
||||||
|
|
||||||
/* Figure out how much reusable memory is available at the end of the
|
/* Figure out how much reusable memory is available at the end of the
|
||||||
** opcode array. This extra memory will be reallocated for other elements
|
** opcode array. This extra memory will be reallocated for other elements
|
||||||
|
@ -1937,9 +1939,8 @@ void sqlite3VdbeMakeReady(
|
||||||
pParse->nzVar = 0;
|
pParse->nzVar = 0;
|
||||||
pParse->azVar = 0;
|
pParse->azVar = 0;
|
||||||
if( p->aMem ){
|
if( p->aMem ){
|
||||||
p->aMem--; /* aMem[] goes from 1..nMem */
|
p->nMem = nMem;
|
||||||
p->nMem = nMem; /* not from 0..nMem-1 */
|
for(n=0; n<nMem; n++){
|
||||||
for(n=1; n<=nMem; n++){
|
|
||||||
p->aMem[n].flags = MEM_Undefined;
|
p->aMem[n].flags = MEM_Undefined;
|
||||||
p->aMem[n].db = db;
|
p->aMem[n].db = db;
|
||||||
}
|
}
|
||||||
|
@ -2049,7 +2050,7 @@ static void closeAllCursors(Vdbe *p){
|
||||||
assert( p->nFrame==0 );
|
assert( p->nFrame==0 );
|
||||||
closeCursorsInFrame(p);
|
closeCursorsInFrame(p);
|
||||||
if( p->aMem ){
|
if( p->aMem ){
|
||||||
releaseMemArray(&p->aMem[1], p->nMem);
|
releaseMemArray(p->aMem, p->nMem);
|
||||||
}
|
}
|
||||||
while( p->pDelFrame ){
|
while( p->pDelFrame ){
|
||||||
VdbeFrame *pDel = p->pDelFrame;
|
VdbeFrame *pDel = p->pDelFrame;
|
||||||
|
@ -2074,7 +2075,7 @@ static void Cleanup(Vdbe *p){
|
||||||
int i;
|
int i;
|
||||||
if( p->apCsr ) for(i=0; i<p->nCursor; i++) assert( p->apCsr[i]==0 );
|
if( p->apCsr ) for(i=0; i<p->nCursor; i++) assert( p->apCsr[i]==0 );
|
||||||
if( p->aMem ){
|
if( p->aMem ){
|
||||||
for(i=1; i<=p->nMem; i++) assert( p->aMem[i].flags==MEM_Undefined );
|
for(i=0; i<p->nMem; i++) assert( p->aMem[i].flags==MEM_Undefined );
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
|
|
@ -761,7 +761,7 @@ int sqlite3VdbeMemTooBig(Mem *p){
|
||||||
void sqlite3VdbeMemAboutToChange(Vdbe *pVdbe, Mem *pMem){
|
void sqlite3VdbeMemAboutToChange(Vdbe *pVdbe, Mem *pMem){
|
||||||
int i;
|
int i;
|
||||||
Mem *pX;
|
Mem *pX;
|
||||||
for(i=1, pX=&pVdbe->aMem[1]; i<=pVdbe->nMem; i++, pX++){
|
for(i=0, pX=pVdbe->aMem; i<pVdbe->nMem; i++, pX++){
|
||||||
if( pX->pScopyFrom==pMem ){
|
if( pX->pScopyFrom==pMem ){
|
||||||
pX->flags |= MEM_Undefined;
|
pX->flags |= MEM_Undefined;
|
||||||
pX->pScopyFrom = 0;
|
pX->pScopyFrom = 0;
|
||||||
|
|
Loading…
Reference in New Issue