database/sqlite
1
0
Fork 0
mirror of https://github.com/sqlite/sqlite.git synced 2025-08-08 14:02:16 +03:00
Code Activity

Code optimizations to help the library run faster. (CVS 808)

Browse Source 
FossilOrigin-Name: db745e87dc26cf1a35cdcec18f4b659742e14120
This commit is contained in:
drh
2003-01-02 14:43:55 +00:00
parent 7b39686749
commit 8c1238aebd
9 changed files with 110 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
manifest
View File

@@ -1,5 +1,5 @@
C If\scompiled\swith\sthe\s-DVDBE_PROFILE=1\soption,\sspecial\scode\sis\sinserted\sthat\nuses\sthe\spentium\sRDTSC\sinstruction\sto\scompute\svery\sprecise\sruntimes\son\sall\nVDBE\sopcodes.\s\s(This\sonly\sworks\son\si586\sprocessors,\sof\scourse.)\s\sThe\sresults\nare\swritten\sinto\sthe\svdbe_profile.out\sfile\sfor\sanalysis.\sHopefully,\sthis\nnew\sfeature\swill\sreveal\shot\sspots\sthat\scan\sbe\soptimized\sto\smake\sthe\sVDBE\srun\nfaster.\s(CVS\s807)
D 2003-01-01T23:06:21
C Code\soptimizations\sto\shelp\sthe\slibrary\srun\sfaster.\s(CVS\s808)
D 2003-01-02T14:43:56
F Makefile.in 868c17a1ae1c07603d491274cc8f86c04acf2a1e
F Makefile.linux-gcc b86a99c493a5bfb402d1d9178dcdc4bd4b32f906
F README f1de682fbbd94899d50aca13d387d1b3fd3be2dd
@@ -18,21 +18,21 @@ F main.mk 9d13839b9697af332d788fe6e801e68da027cc5c
F publish.sh e5b83867d14708ed58cec8cba0a4f201e969474d
F spec.template 238f7db425a78dc1bb7682e56e3834c7270a3f5e
F sqlite.1 83f4a9d37bdf2b7ef079a82d54eaf2e3509ee6ea
F src/btree.c 215d4b322c98fbff795095fa253d9ea108d4b9de
F src/btree.c 6a2a9bb701a60df4abe2fb7047b25787c90e1ffd
F src/btree.h 17710339f7a8f46e3c7d6d0d4648ef19c584ffda
F src/build.c 415dce8886aabb6d45851caed7014707056d668b
F src/build.c 8569ac014609add4b796260d3567a5090b90056d
F src/delete.c aad9d4051ab46e6f6391ea5f7b8994a7c05bdd15
F src/encode.c 6c9c87d5b7b2c0101d011ebc283a80abf672a4d1
F src/expr.c 9427b4d1d04ede1095994b8e042abe2e6fea7443
F src/func.c 90c583f0b91220f7cd411a2407deaf9327245d63
F src/hash.c 6a6236b89c8c060c65dabd300a1c8ce7c10edb72
F src/hash.c 4fc39feb7b7711f6495ee9f2159559bedb043e1f
F src/hash.h cd0433998bc1a3759d244e1637fe5a3c13b53bf8
F src/insert.c 764300a0bd8074a2174946c0bf8a550bd833397a
F src/main.c cee05c2ba23b5e78f9671f319dbd68e2130e0f68
F src/md5.c fe4f9c9c6f71dfc26af8da63e4d04489b1430565
F src/os.c 740022806209e44cab0abddfb1fee65c77702e21
F src/os.h 09fd96b4d733aae2f3b98b2ae9ceea40b8fd780d
F src/pager.c ebc73e7c314e7d8ff6c5728bb96831aaa9efb2e4
F src/pager.c 255c5d14ff489071021bf1374654836f2516abb3
F src/pager.h 540833e8cb826b80ce2e39aa917deee5e12db626
F src/parse.y 469c9636ff713e63c00234662209f11668671ae9
F src/printf.c 5c50fc1da75c8f5bf432b1ad17d91d6653acd167
@@ -41,7 +41,7 @@ F src/select.c cc8640e5d4e3ec1a8de58fde6b2fdd6f846b7263
F src/shell.c 53185af128613a2bac79d50128f4c17794f0f992
F src/shell.tcl 27ecbd63dd88396ad16d81ab44f73e6c0ea9d20e
F src/sqlite.h.in 98b1574b2362abe02c4a4c73b9dbf99bcd713ab3
F src/sqliteInt.h 4eb6290304c9225752ca9cc4fdda5bc480d14176
F src/sqliteInt.h 65dfa06bc49ebff83361bfb259ee4c675534808a
F src/table.c eed2098c9b577aa17f8abe89313a9c4413f57d63
F src/tclsqlite.c 9f2c00a92338c51171ded8943bd42d77f7e69e64
F src/test1.c a46e9f61915b32787c5d5a05a4b92e4dacc437d9
@@ -51,8 +51,8 @@ F src/threadtest.c d641a5219e718e18a1a80a50eb9bb549f451f42e
F src/tokenize.c 75e3bb37305b64e118e709752066f494c4f93c30
F src/trigger.c 5ba917fc226b96065108da28186c2efaec53e481
F src/update.c 881e4c8e7c786545da4fd2d95da19252b2e31137
F src/util.c 8f19c71e45d1a5a3ff2e9a3eef8f36296d87ea43
F src/vdbe.c 0baebb3f0c624e59bf6710cd9fc15db01c7fc31e
F src/util.c e2d108842e02810d3d3242cac0e024b09cdb3c4a
F src/vdbe.c 572ee028e01d2811dee1ad4d5161ce82e31e88d4
F src/vdbe.h 754eba497cfe0c3e352b9c101ab2f811f10d0a55
F src/where.c af235636b7bc7f7f42ee1c7162d1958ad0102cab
F test/all.test 873d30e25a41b3aa48fec5633a7ec1816e107029
@@ -152,7 +152,7 @@ F www/speed.tcl a20a792738475b68756ea7a19321600f23d1d803
F www/sqlite.tcl ae3dcfb077e53833b59d4fcc94d8a12c50a44098
F www/tclsqlite.tcl 1db15abeb446aad0caf0b95b8b9579720e4ea331
F www/vdbe.tcl 2013852c27a02a091d39a766bc87cff329f21218
P ee95eefe12c48f28412461125c231122e0d4277a
R c487959d68c24b3808f56b254c4d4b49
P a1c071ea18766932c90275c704e078134c67be68
R 007ca29b327fd24b8c788dde75e1f089
U drh
Z 2e2dd169d3dae32e223fb4d52d6a727e
Z 65610790d7e7e89a7d7be7a3a45c0c23

2
manifest.uuid
View File

@@ -1 +1 @@
a1c071ea18766932c90275c704e078134c67be68
db745e87dc26cf1a35cdcec18f4b659742e14120

90
src/btree.c
View File

@@ -9,7 +9,7 @@
** May you share freely, never taking more than you give.
**
*************************************************************************
** $Id: btree.c,v 1.75 2002/12/04 22:29:28 drh Exp $
** $Id: btree.c,v 1.76 2003/01/02 14:43:56 drh Exp $
**
** This file implements a external (disk-based) database using BTrees.
** For a detailed discussion of BTrees, refer to
@@ -1106,7 +1106,8 @@ int sqliteBtreeKeySize(BtCursor *pCur, int *pSize){
MemPage *pPage;
pPage = pCur->pPage;
if( pPage==0 || pCur->idx >= pPage->nCell ){
assert( pPage!=0 );
if( pCur->idx >= pPage->nCell ){
*pSize = 0;
}else{
pCell = pPage->apCell[pCur->idx];
@@ -1180,29 +1181,26 @@ static int getPayload(BtCursor *pCur, int offset, int amt, char *zBuf){
** Read part of the key associated with cursor pCur. A maximum
** of "amt" bytes will be transfered into zBuf[]. The transfer
** begins at "offset". The number of bytes actually read is
** returned. The amount returned will be smaller than the
** amount requested if there are not enough bytes in the key
** to satisfy the request.
** returned.
**
** Change: It used to be that the amount returned will be smaller
** than the amount requested if there are not enough bytes in the key
** to satisfy the request. But now, it must be the case that there
** is enough data available to satisfy the request. If not, an exception
** is raised. The change was made in an effort to boost performance
** by eliminating unneeded tests.
*/
int sqliteBtreeKey(BtCursor *pCur, int offset, int amt, char *zBuf){
Cell *pCell;
MemPage *pPage;
if( amt<0 ) return 0;
if( offset<0 ) return 0;
if( amt==0 ) return 0;
assert( amt>=0 );
assert( offset>=0 );
assert( pCur->pPage!=0 );
pPage = pCur->pPage;
if( pPage==0 ) return 0;
if( pCur->idx >= pPage->nCell ){
return 0;
}
pCell = pPage->apCell[pCur->idx];
if( amt+offset > NKEY(pCur->pBt, pCell->h) ){
amt = NKEY(pCur->pBt, pCell->h) - offset;
if( amt<=0 ){
return 0;
}
}
assert( amt+offset <= NKEY(pCur->pBt, pPage->apCell[pCur->idx]->h) );
getPayload(pCur, offset, amt, zBuf);
return amt;
}
@@ -1219,7 +1217,8 @@ int sqliteBtreeDataSize(BtCursor *pCur, int *pSize){
MemPage *pPage;
pPage = pCur->pPage;
if( pPage==0 || pCur->idx >= pPage->nCell ){
assert( pPage!=0 );
if( pCur->idx >= pPage->nCell ){
*pSize = 0;
}else{
pCell = pPage->apCell[pCur->idx];
@@ -1239,23 +1238,16 @@ int sqliteBtreeDataSize(BtCursor *pCur, int *pSize){
int sqliteBtreeData(BtCursor *pCur, int offset, int amt, char *zBuf){
Cell *pCell;
MemPage *pPage;
int nData;
if( amt<0 ) return 0;
if( offset<0 ) return 0;
if( amt==0 ) return 0;
assert( amt>=0 );
assert( offset>=0 );
assert( pCur->pPage!=0 );
pPage = pCur->pPage;
if( pPage==0 || pCur->idx >= pPage->nCell ){
if( pCur->idx >= pPage->nCell ){
return 0;
}
pCell = pPage->apCell[pCur->idx];
nData = NDATA(pCur->pBt, pCell->h);
if( amt+offset > nData ){
amt = nData - offset;
if( amt<=0 ){
return 0;
}
}
assert( amt+offset <= NDATA(pCur->pBt, pCell->h) );
getPayload(pCur, offset + NKEY(pCur->pBt, pCell->h), amt, zBuf);
return amt;
}
@@ -1552,26 +1544,28 @@ int sqliteBtreeMoveto(BtCursor *pCur, const void *pKey, int nKey, int *pRes){
/*
** Advance the cursor to the next entry in the database. If
** successful and pRes!=NULL then set *pRes=0. If the cursor
** successful then set *pRes=0. If the cursor
** was already pointing to the last entry in the database before
** this routine was called, then set *pRes=1 if pRes!=NULL.
** this routine was called, then set *pRes=1.
*/
int sqliteBtreeNext(BtCursor *pCur, int *pRes){
int rc;
assert( pRes!=0 );
/* assert( pCur->pPage!=0 ); */
if( pCur->pPage==0 ){
if( pRes ) *pRes = 1;
*pRes = 1;
return SQLITE_ABORT;
}
assert( pCur->pPage->isInit );
assert( pCur->eSkip!=SKIP_INVALID );
if( pCur->pPage->nCell==0 ){
if( pRes ) *pRes = 1;
*pRes = 1;
return SQLITE_OK;
}
assert( pCur->idx<pCur->pPage->nCell );
if( pCur->eSkip==SKIP_NEXT ){
pCur->eSkip = SKIP_NONE;
if( pRes ) *pRes = 0;
*pRes = 0;
return SQLITE_OK;
}
pCur->eSkip = SKIP_NONE;
@@ -1581,25 +1575,22 @@ int sqliteBtreeNext(BtCursor *pCur, int *pRes){
rc = moveToChild(pCur, SWAB32(pCur->pBt, pCur->pPage->u.hdr.rightChild));
if( rc ) return rc;
rc = moveToLeftmost(pCur);
if( rc ) return rc;
if( pRes ) *pRes = 0;
return SQLITE_OK;
*pRes = 0;
return rc;
}
do{
if( pCur->pPage->pParent==0 ){
if( pRes ) *pRes = 1;
*pRes = 1;
return SQLITE_OK;
}
rc = moveToParent(pCur);
if( rc ) return rc;
}while( pCur->idx>=pCur->pPage->nCell );
if( pRes ) *pRes = 0;
return SQLITE_OK;
}while( rc==SQLITE_OK && pCur->idx>=pCur->pPage->nCell );
*pRes = 0;
return rc;
}
rc = moveToLeftmost(pCur);
if( rc ) return rc;
if( pRes ) *pRes = 0;
return SQLITE_OK;
*pRes = 0;
return rc;
}
/*
@@ -2621,8 +2612,9 @@ int sqliteBtreeDelete(BtCursor *pCur){
BtCursor leafCur;
Cell *pNext;
int szNext;
int notUsed;
getTempCursor(pCur, &leafCur);
rc = sqliteBtreeNext(&leafCur, 0);
rc = sqliteBtreeNext(&leafCur, &notUsed);
if( rc!=SQLITE_OK ){
return SQLITE_CORRUPT;
}
@@ -3157,7 +3149,7 @@ static int checkTreePage(
/* Check that keys are in the right order
*/
cur.idx = i;
zKey2 = sqliteMalloc( nKey2+1 );
zKey2 = sqliteMallocRaw( nKey2+1 );
getPayload(&cur, 0, nKey2, zKey2);
if( zKey1 && keyCompare(zKey1, nKey1, zKey2, nKey2)>=0 ){
checkAppendMsg(pCheck, zContext, "Key is out of order");
@@ -3253,7 +3245,7 @@ char *sqliteBtreeIntegrityCheck(Btree *pBt, int *aRoot, int nRoot){
unlockBtreeIfUnused(pBt);
return 0;
}
sCheck.anRef = sqliteMalloc( (sCheck.nPage+1)*sizeof(sCheck.anRef[0]) );
sCheck.anRef = sqliteMallocRaw( (sCheck.nPage+1)*sizeof(sCheck.anRef[0]) );
sCheck.anRef[1] = 1;
for(i=2; i<=sCheck.nPage; i++){ sCheck.anRef[i] = 0; }
sCheck.zErrMsg = 0;

6
src/build.c
View File

@@ -25,7 +25,7 @@
** ROLLBACK
** PRAGMA
**
** $Id: build.c,v 1.117 2002/12/03 02:22:52 drh Exp $
** $Id: build.c,v 1.118 2003/01/02 14:43:56 drh Exp $
*/
#include "sqliteInt.h"
#include <ctype.h>
@@ -727,7 +727,7 @@ static char *createTableStmt(Table *p){
zEnd = "\n)";
}
n += 35 + 6*p->nCol;
zStmt = sqliteMalloc( n );
zStmt = sqliteMallocRaw( n );
if( zStmt==0 ) return 0;
strcpy(zStmt, p->isTemp ? "CREATE TEMP TABLE " : "CREATE TABLE ");
k = strlen(zStmt);
@@ -1164,7 +1164,7 @@ void sqliteAddIdxKeyType(Vdbe *v, Index *pIdx){
assert( pIdx!=0 && pIdx->pTable!=0 );
pTab = pIdx->pTable;
n = pIdx->nColumn;
zType = sqliteMalloc( n+1 );
zType = sqliteMallocRaw( n+1 );
if( zType==0 ) return;
for(i=0; i<n; i++){
int iCol = pIdx->aiColumn[i];

4
src/hash.c
View File

@@ -12,7 +12,7 @@
** This is the implementation of generic hash-tables
** used in SQLite.
**
** $Id: hash.c,v 1.8 2002/05/21 23:44:30 drh Exp $
** $Id: hash.c,v 1.9 2003/01/02 14:43:57 drh Exp $
*/
#include "sqliteInt.h"
#include <assert.h>
@@ -313,7 +313,7 @@ void *sqliteHashInsert(Hash *pH, const void *pKey, int nKey, void *data){
new_elem = (HashElem*)sqliteMalloc( sizeof(HashElem) );
if( new_elem==0 ) return data;
if( pH->copyKey && pKey!=0 ){
new_elem->pKey = sqliteMalloc( nKey );
new_elem->pKey = sqliteMallocRaw( nKey );
if( new_elem->pKey==0 ){
sqliteFree(new_elem);
return data;

5
src/pager.c
View File

@@ -18,7 +18,7 @@
** file simultaneously, or one process from reading the database while
** another is writing.
**
** @(#) $Id: pager.c,v 1.62 2002/12/28 01:06:30 drh Exp $
** @(#) $Id: pager.c,v 1.63 2003/01/02 14:43:57 drh Exp $
*/
#include "os.h" /* Must be first to enable large file support */
#include "sqliteInt.h"
@@ -962,13 +962,14 @@ int sqlitepager_get(Pager *pPager, Pgno pgno, void **ppPage){
pPager->nMiss++;
if( pPager->nPage<pPager->mxPage || pPager->pFirst==0 ){
/* Create a new page */
pPg = sqliteMalloc( sizeof(*pPg) + SQLITE_PAGE_SIZE + pPager->nExtra );
pPg = sqliteMallocRaw( sizeof(*pPg) + SQLITE_PAGE_SIZE + pPager->nExtra );
if( pPg==0 ){
*ppPage = 0;
pager_unwritelock(pPager);
pPager->errMask |= PAGER_ERR_MEM;
return SQLITE_NOMEM;
}
memset(pPg, 0, sizeof(*pPg));
pPg->pPager = pPager;
pPg->pNextAll = pPager->pAll;
if( pPager->pAll ){

8
src/sqliteInt.h
View File

@@ -11,7 +11,7 @@
*************************************************************************
** Internal interface definitions for SQLite.
**
** @(#) $Id: sqliteInt.h,v 1.150 2002/12/04 20:01:06 drh Exp $
** @(#) $Id: sqliteInt.h,v 1.151 2003/01/02 14:43:57 drh Exp $
*/
#include "config.h"
#include "sqlite.h"
@@ -119,7 +119,8 @@ typedef unsigned INTPTR_TYPE uptr; /* Big enough to hold a pointer */
** by an AWK script to determine if there are any leaks.
*/
#ifdef MEMORY_DEBUG
# define sqliteMalloc(X) sqliteMalloc_(X,__FILE__,__LINE__)
# define sqliteMalloc(X) sqliteMalloc_(X,1,__FILE__,__LINE__)
# define sqliteMallocRaw(X) sqliteMalloc_(X,0,__FILE__,__LINE__)
# define sqliteFree(X) sqliteFree_(X,__FILE__,__LINE__)
# define sqliteRealloc(X,Y) sqliteRealloc_(X,Y,__FILE__,__LINE__)
# define sqliteStrDup(X) sqliteStrDup_(X,__FILE__,__LINE__)
@@ -893,13 +894,14 @@ int sqliteCompare(const char *, const char *);
int sqliteSortCompare(const char *, const char *);
void sqliteRealToSortable(double r, char *);
#ifdef MEMORY_DEBUG
void *sqliteMalloc_(int,char*,int);
void *sqliteMalloc_(int,int,char*,int);
void sqliteFree_(void*,char*,int);
void *sqliteRealloc_(void*,int,char*,int);
char *sqliteStrDup_(const char*,char*,int);
char *sqliteStrNDup_(const char*, int,char*,int);
#else
void *sqliteMalloc(int);
void *sqliteMallocRaw(int);
void sqliteFree(void*);
void *sqliteRealloc(void*,int);
char *sqliteStrDup(const char*);

39
src/util.c
View File

@@ -14,7 +14,7 @@
** This file contains functions for allocating memory, comparing
** strings, and stuff like that.
**
** $Id: util.c,v 1.53 2002/12/17 13:05:26 drh Exp $
** $Id: util.c,v 1.54 2003/01/02 14:43:57 drh Exp $
*/
#include "sqliteInt.h"
#include <stdarg.h>
@@ -48,7 +48,7 @@ static int memcnt = 0;
** Allocate new memory and set it to zero. Return NULL if
** no memory is available.
*/
void *sqliteMalloc_(int n, char *zFile, int line){
void *sqliteMalloc_(int n, int bZero, char *zFile, int line){
void *p;
int *pi;
int k;
@@ -76,7 +76,7 @@ void *sqliteMalloc_(int n, char *zFile, int line){
pi[1] = n;
pi[k+2] = 0xdead3344;
p = &pi[2];
memset(p, 0, n);
memset(p, bZero==0, n);
#if MEMORY_DEBUG>1
fprintf(stderr,"%06d malloc %d bytes at 0x%x from %s:%d\n",
++memcnt, n, (int)p, zFile,line);
@@ -121,7 +121,7 @@ void *sqliteRealloc_(void *oldP, int n, char *zFile, int line){
int *oldPi, *pi, k, oldN, oldK;
void *p;
if( oldP==0 ){
return sqliteMalloc_(n,zFile,line);
return sqliteMalloc_(n,1,zFile,line);
}
if( n==0 ){
sqliteFree_(oldP,zFile,line);
@@ -153,7 +153,7 @@ void *sqliteRealloc_(void *oldP, int n, char *zFile, int line){
if( n>oldN ){
memset(&((char*)p)[oldN], 0, n-oldN);
}
memset(oldPi, 0, (oldK+3)*sizeof(int));
memset(oldPi, 0xab, (oldK+3)*sizeof(int));
free(oldPi);
#if MEMORY_DEBUG>1
fprintf(stderr,"%06d realloc %d to %d bytes at 0x%x to 0x%x at %s:%d\n",
@@ -190,14 +190,14 @@ void sqliteStrRealloc(char **pz){
char *sqliteStrDup_(const char *z, char *zFile, int line){
char *zNew;
if( z==0 ) return 0;
zNew = sqliteMalloc_(strlen(z)+1, zFile, line);
zNew = sqliteMalloc_(strlen(z)+1, 0, zFile, line);
if( zNew ) strcpy(zNew, z);
return zNew;
}
char *sqliteStrNDup_(const char *z, int n, char *zFile, int line){
char *zNew;
if( z==0 ) return 0;
zNew = sqliteMalloc_(n+1, zFile, line);
zNew = sqliteMalloc_(n+1, 0, zFile, line);
if( zNew ){
memcpy(zNew, z, n);
zNew[n] = 0;
@@ -214,7 +214,7 @@ char *sqliteStrNDup_(const char *z, int n, char *zFile, int line){
/*
** Allocate new memory and set it to zero. Return NULL if
** no memory is available.
** no memory is available. See also sqliteMallocRaw().
*/
void *sqliteMalloc(int n){
void *p;
@@ -228,6 +228,21 @@ void *sqliteMalloc(int n){
return p;
}
/*
** Allocate new memory but do not set it to zero. Return NULL if
** no memory is available. See also sqliteMalloc().
*/
void *sqliteMallocRaw(int n){
void *p;
if( n==0 ) return 0;
p = malloc(n);
if( p==0 ){
sqlite_malloc_failed++;
return 0;
}
return p;
}
/*
** Free memory previously obtained from sqliteMalloc()
*/
@@ -264,14 +279,14 @@ void *sqliteRealloc(void *p, int n){
char *sqliteStrDup(const char *z){
char *zNew;
if( z==0 ) return 0;
zNew = sqliteMalloc(strlen(z)+1);
zNew = sqliteMallocRaw(strlen(z)+1);
if( zNew ) strcpy(zNew, z);
return zNew;
}
char *sqliteStrNDup(const char *z, int n){
char *zNew;
if( z==0 ) return 0;
zNew = sqliteMalloc(n+1);
zNew = sqliteMallocRaw(n+1);
if( zNew ){
memcpy(zNew, z, n);
zNew[n] = 0;
@@ -300,7 +315,7 @@ void sqliteSetString(char **pz, const char *zFirst, ...){
}
va_end(ap);
sqliteFree(*pz);
*pz = zResult = sqliteMalloc( nByte );
*pz = zResult = sqliteMallocRaw( nByte );
if( zResult==0 ){
return;
}
@@ -341,7 +356,7 @@ void sqliteSetNString(char **pz, ...){
}
va_end(ap);
sqliteFree(*pz);
*pz = zResult = sqliteMalloc( nByte + 1 );
*pz = zResult = sqliteMallocRaw( nByte + 1 );
if( zResult==0 ) return;
va_start(ap, pz);
while( (z = va_arg(ap, const char*))!=0 ){

33
src/vdbe.c
View File

@@ -36,7 +36,7 @@
** in this file for details. If in doubt, do not deviate from existing
** commenting and indentation practices when changing or adding code.
**
** $Id: vdbe.c,v 1.188 2003/01/01 23:06:21 drh Exp $
** $Id: vdbe.c,v 1.189 2003/01/02 14:43:57 drh Exp $
*/
#include "sqliteInt.h"
#include <ctype.h>
@@ -609,7 +609,7 @@ char *sqlite_set_result_string(sqlite_func *p, const char *zResult, int n){
p->s.flags = STK_Str;
p->z = p->s.z;
}else{
p->z = sqliteMalloc( n+1 );
p->z = sqliteMallocRaw( n+1 );
if( p->z ){
memcpy(p->z, zResult, n);
p->z[n] = 0;
@@ -817,7 +817,7 @@ static int hardDeephem(Vdbe *p, int i){
char **pzStack = &p->zStack[i];
char *z;
assert( (pStack->flags & STK_Ephem)!=0 );
z = sqliteMalloc( pStack->n );
z = sqliteMallocRaw( pStack->n );
if( z==0 ) return 1;
memcpy(z, *pzStack, pStack->n);
*pzStack = z;
@@ -1662,7 +1662,7 @@ case OP_Dup: {
zStack[j] = aStack[j].z;
aStack[j].flags &= ~(STK_Static|STK_Dyn|STK_Ephem);
}else{
zStack[j] = sqliteMalloc( aStack[j].n );
zStack[j] = sqliteMallocRaw( aStack[j].n );
if( zStack[j]==0 ) goto no_mem;
memcpy(zStack[j], zStack[i], aStack[j].n);
aStack[j].flags &= ~(STK_Static|STK_Ephem);
@@ -1871,7 +1871,7 @@ case OP_Concat: {
zStack[p->tos] = 0;
break;
}
zNew = sqliteMalloc( nByte );
zNew = sqliteMallocRaw( nByte );
if( zNew==0 ) goto no_mem;
j = 0;
for(i=p->tos-nField+1; i<=p->tos; i++){
@@ -2782,7 +2782,7 @@ case OP_MakeRecord: {
rc = SQLITE_TOOBIG;
goto abort_due_to_error;
}
zNewRecord = sqliteMalloc( nByte );
zNewRecord = sqliteMallocRaw( nByte );
if( zNewRecord==0 ) goto no_mem;
j = 0;
addr = idxWidth*(nField+1) + addUnique*sizeof(uniqueCnt);
@@ -2936,7 +2936,7 @@ case OP_MakeKey: {
goto abort_due_to_error;
}
if( addRowid ) nByte += sizeof(u32);
zNewKey = sqliteMalloc( nByte );
zNewKey = sqliteMallocRaw( nByte );
if( zNewKey==0 ) goto no_mem;
j = 0;
for(i=p->tos-nField+1; i<=p->tos; i++){
@@ -3929,7 +3929,7 @@ case OP_Column: {
zStack[tos] = aStack[tos].z;
aStack[tos].n = amt;
}else{
char *z = sqliteMalloc( amt );
char *z = sqliteMallocRaw( amt );
if( z==0 ) goto no_mem;
aStack[tos].flags = STK_Str | STK_Dyn;
zStack[tos] = z;
@@ -4001,7 +4001,7 @@ case OP_FullKey: {
goto abort_due_to_error;
}
if( amt>NBFS ){
z = sqliteMalloc( amt );
z = sqliteMallocRaw( amt );
aStack[tos].flags = STK_Str | STK_Dyn;
}else{
z = aStack[tos].z;
@@ -4095,12 +4095,11 @@ case OP_Rewind: {
*/
case OP_Prev:
case OP_Next: {
int i = pOp->p1;
Cursor *pC;
BtCursor *pCrsr;
if( VERIFY( i>=0 && i<p->nCursor && )
(pCrsr = (pC = &p->aCsr[i])->pCursor)!=0 ){
if( VERIFY( pOp->p1>=0 && pOp->p1<p->nCursor && )
(pCrsr = (pC = &p->aCsr[pOp->p1])->pCursor)!=0 ){
int res;
if( pC->nullRow ){
res = 1;
@@ -4406,7 +4405,7 @@ case OP_ListWrite: {
VERIFY( if( p->tos<0 ) goto not_enough_stack; )
pKeylist = p->pList;
if( pKeylist==0 || pKeylist->nUsed>=pKeylist->nKey ){
pKeylist = sqliteMalloc( sizeof(Keylist)+999*sizeof(pKeylist->aKey[0]) );
pKeylist = sqliteMallocRaw( sizeof(Keylist)+999*sizeof(pKeylist->aKey[0]) );
if( pKeylist==0 ) goto no_mem;
pKeylist->nKey = 1000;
pKeylist->nRead = 0;
@@ -4516,7 +4515,7 @@ case OP_SortPut: {
Sorter *pSorter;
VERIFY( if( tos<1 ) goto not_enough_stack; )
if( Stringify(p, tos) || Stringify(p, nos) ) goto no_mem;
pSorter = sqliteMalloc( sizeof(Sorter) );
pSorter = sqliteMallocRaw( sizeof(Sorter) );
if( pSorter==0 ) goto no_mem;
pSorter->pNext = p->pSort;
p->pSort = pSorter;
@@ -4560,7 +4559,7 @@ case OP_SortMakeRec: {
}
}
nByte += sizeof(char*)*(nField+1);
azArg = sqliteMalloc( nByte );
azArg = sqliteMallocRaw( nByte );
if( azArg==0 ) goto no_mem;
z = (char*)&azArg[nField+1];
for(j=0, i=p->tos-nField+1; i<=p->tos; i++, j++){
@@ -4613,7 +4612,7 @@ case OP_SortMakeKey: {
nByte += aStack[i].n+2;
}
}
zNewKey = sqliteMalloc( nByte );
zNewKey = sqliteMallocRaw( nByte );
if( zNewKey==0 ) goto no_mem;
j = 0;
k = 0;
@@ -4942,7 +4941,7 @@ case OP_MemStore: {
if( (flags & STK_Static)!=0 || (pOp->p2 && (flags & STK_Dyn)!=0) ){
pMem->z = zStack[tos];
}else if( flags & STK_Str ){
pMem->z = sqliteMalloc( pMem->s.n );
pMem->z = sqliteMallocRaw( pMem->s.n );
if( pMem->z==0 ) goto no_mem;
memcpy(pMem->z, zStack[tos], pMem->s.n);
pMem->s.flags |= STK_Dyn;