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

FossilOrigin-Name: db745e87dc26cf1a35cdcec18f4b659742e14120

diff --git a/manifest b/manifest
index 1ada763034fdd2604941109050a969a2171091c5..8a498266e02a7e872cd9431ffe1301ef5ec8a193 100644 (file)
--- a/manifest
+++ b/manifest
@@ -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

diff --git a/manifest.uuid b/manifest.uuid
index f7c88b97af37d396b089244dab5e36dd926261e0..8f8da665675a716821fe30a042bf02d59cb710f8 100644 (file)
--- a/manifest.uuid
+++ b/manifest.uuid
@@ -1 +1 @@
-a1c071ea18766932c90275c704e078134c67be68
\ No newline at end of file
+db745e87dc26cf1a35cdcec18f4b659742e14120
\ No newline at end of file

diff --git a/src/btree.c b/src/btree.c
index 193c224d663349f2beeb1bd5f3a7ddec8214b54a..f34e9726269a72bdda89ffbe8f2f892db44b9929 100644 (file)
--- a/src/btree.c
+++ b/src/btree.c
@@ -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;

diff --git a/src/build.c b/src/build.c
index 9ef20d86dd524eecc6e5bf90114a54bcff4659a3..405a5b0dc87484b9eca73b29d0d83216bab6a635 100644 (file)
--- a/src/build.c
+++ b/src/build.c
@@ -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];

diff --git a/src/hash.c b/src/hash.c
index 0ac54196cb39ebac28dcbed4c7ec74f77b155366..5b176be0dfa53dc84d4fc83eb21d0d7daeb3b284 100644 (file)
--- a/src/hash.c
+++ b/src/hash.c
@@ -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;

diff --git a/src/pager.c b/src/pager.c
index 9ce06b58fe4905f71b98f1fa2c3e3216013941b6..31b1d2815683938be1247aa40fecb8f7fd134737 100644 (file)
--- a/src/pager.c
+++ b/src/pager.c
@@ -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 ){

diff --git a/src/sqliteInt.h b/src/sqliteInt.h
index 10095a89af721e6f637db4ce3d96a6db86a63da6..77d78efbe2bce7734c174fc7d22a69ba9b6c13d1 100644 (file)
--- a/src/sqliteInt.h
+++ b/src/sqliteInt.h
@@ -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*);

diff --git a/src/util.c b/src/util.c
index 41f7ef1e199b3700bf9cbc29db204a73ed2503a2..3d47bbaf66a82ba2f557f57c98a438b59459fd9d 100644 (file)
--- a/src/util.c
+++ b/src/util.c
@@ -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 ){

diff --git a/src/vdbe.c b/src/vdbe.c
index 1da38c96cdaf6737b75683e1c4e81d88efb8419f..f95e7f92d61fcf1963d3ab3994eaaeea0d2ce979 100644 (file)
--- a/src/vdbe.c
+++ b/src/vdbe.c
@@ -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;