Upgrade bundled libsqlite to 2.8.9

1 files changed, 206 insertions, 1244 deletions

diff --git a/ext/sqlite/libsqlite/src/vdbe.c b/ext/sqlite/libsqlite/src/vdbe.c
index 664b83c25e..bd080f37d3 100644
--- a/ext/sqlite/libsqlite/src/vdbe.c
+++ b/ext/sqlite/libsqlite/src/vdbe.c
@@ -9,7 +9,14 @@
 **    May you share freely, never taking more than you give.
 **
 *************************************************************************
-** The code in this file implements the Virtual Database Engine (VDBE)
+** The code in this file implements execution method of the 
+** Virtual Database Engine (VDBE).  A separate file ("vdbeaux.c")
+** handles housekeeping details such as creating and deleting
+** VDBE instances.  This file is solely interested in executing
+** the VDBE program.
+**
+** In the external interface, an "sqlite_vm*" is an opaque pointer
+** to a VDBE.
 **
 ** The SQL parser generates a program which is then executed by
 ** the VDBE to do the work of the SQL statement.  VDBE programs are 
@@ -39,15 +46,9 @@
 ** $Id$
 */
 #include "sqliteInt.h"
+#include "os.h"
 #include <ctype.h>
-
-/*
-** The makefile scans this source file and creates the following
-** array of string constants which are the names of all VDBE opcodes.
-** This array is defined in a separate source code file named opcode.c
-** which is automatically generated by the makefile.
-*/
-extern char *sqliteOpcodeNames[];
+#include "vdbeInt.h"
 
 /*
 ** The following global variable is incremented every time a cursor
@@ -58,700 +59,6 @@ extern char *sqliteOpcodeNames[];
 */
 int sqlite_search_count = 0;
 
-/*
-** SQL is translated into a sequence of instructions to be
-** executed by a virtual machine.  Each instruction is an instance
-** of the following structure.
-*/
-typedef struct VdbeOp Op;
-
-/*
-** Boolean values
-*/
-typedef unsigned char Bool;
-
-/*
-** A cursor is a pointer into a single BTree within a database file.
-** The cursor can seek to a BTree entry with a particular key, or
-** loop over all entries of the Btree.  You can also insert new BTree
-** entries or retrieve the key or data from the entry that the cursor
-** is currently pointing to.
-** 
-** Every cursor that the virtual machine has open is represented by an
-** instance of the following structure.
-**
-** If the Cursor.isTriggerRow flag is set it means that this cursor is
-** really a single row that represents the NEW or OLD pseudo-table of
-** a row trigger.  The data for the row is stored in Cursor.pData and
-** the rowid is in Cursor.iKey.
-*/
-struct Cursor {
-  BtCursor *pCursor;    /* The cursor structure of the backend */
-  int lastRecno;        /* Last recno from a Next or NextIdx operation */
-  int nextRowid;        /* Next rowid returned by OP_NewRowid */
-  Bool recnoIsValid;    /* True if lastRecno is valid */
-  Bool keyAsData;       /* The OP_Column command works on key instead of data */
-  Bool atFirst;         /* True if pointing to first entry */
-  Bool useRandomRowid;  /* Generate new record numbers semi-randomly */
-  Bool nullRow;         /* True if pointing to a row with no data */
-  Bool nextRowidValid;  /* True if the nextRowid field is valid */
-  Bool pseudoTable;     /* This is a NEW or OLD pseudo-tables of a trigger */
-  Btree *pBt;           /* Separate file holding temporary table */
-  int nData;            /* Number of bytes in pData */
-  char *pData;          /* Data for a NEW or OLD pseudo-table */
-  int iKey;             /* Key for the NEW or OLD pseudo-table row */
-};
-typedef struct Cursor Cursor;
-
-/*
-** A sorter builds a list of elements to be sorted.  Each element of
-** the list is an instance of the following structure.
-*/
-typedef struct Sorter Sorter;
-struct Sorter {
-  int nKey;           /* Number of bytes in the key */
-  char *zKey;         /* The key by which we will sort */
-  int nData;          /* Number of bytes in the data */
-  char *pData;        /* The data associated with this key */
-  Sorter *pNext;      /* Next in the list */
-};
-
-/* 
-** Number of buckets used for merge-sort.  
-*/
-#define NSORT 30
-
-/*
-** Number of bytes of string storage space available to each stack
-** layer without having to malloc.  NBFS is short for Number of Bytes
-** For Strings.
-*/
-#define NBFS 32
-
-/*
-** A single level of the stack is an instance of the following
-** structure.  Except, string values are stored on a separate
-** list of of pointers to character.  The reason for storing
-** strings separately is so that they can be easily passed
-** to the callback function.
-*/
-struct Stack {
-  int i;         /* Integer value */
-  int n;         /* Number of characters in string value, including '\0' */
-  int flags;     /* Some combination of STK_Null, STK_Str, STK_Dyn, etc. */
-  double r;      /* Real value */
-  char z[NBFS];  /* Space for short strings */
-};
-typedef struct Stack Stack;
-
-/*
-** Memory cells use the same structure as the stack except that space
-** for an arbitrary string is added.
-*/
-struct Mem {
-  Stack s;       /* All values of the memory cell besides string */
-  char *z;       /* String value for this memory cell */
-};
-typedef struct Mem Mem;
-
-/*
-** Allowed values for Stack.flags
-*/
-#define STK_Null      0x0001   /* Value is NULL */
-#define STK_Str       0x0002   /* Value is a string */
-#define STK_Int       0x0004   /* Value is an integer */
-#define STK_Real      0x0008   /* Value is a real number */
-#define STK_Dyn       0x0010   /* Need to call sqliteFree() on zStack[] */
-#define STK_Static    0x0020   /* zStack[] points to a static string */
-#define STK_Ephem     0x0040   /* zStack[] points to an ephemeral string */
-
-/* The following STK_ value appears only in AggElem.aMem.s.flag fields.
-** It indicates that the corresponding AggElem.aMem.z points to a
-** aggregate function context that needs to be finalized.
-*/
-#define STK_AggCtx    0x0040   /* zStack[] points to an agg function context */
-
-/*
-** The "context" argument for a installable function.  A pointer to an
-** instance of this structure is the first argument to the routines used
-** implement the SQL functions.
-**
-** There is a typedef for this structure in sqlite.h.  So all routines,
-** even the public interface to SQLite, can use a pointer to this structure.
-** But this file is the only place where the internal details of this
-** structure are known.
-**
-** This structure is defined inside of vdbe.c because it uses substructures
-** (Stack) which are only defined there.
-*/
-struct sqlite_func {
-  FuncDef *pFunc;   /* Pointer to function information.  MUST BE FIRST */
-  Stack s;          /* Small strings, ints, and double values go here */
-  char *z;          /* Space for holding dynamic string results */
-  void *pAgg;       /* Aggregate context */
-  u8 isError;       /* Set to true for an error */
-  u8 isStep;        /* Current in the step function */
-  int cnt;          /* Number of times that the step function has been called */
-};
-
-/*
-** An Agg structure describes an Aggregator.  Each Agg consists of
-** zero or more Aggregator elements (AggElem).  Each AggElem contains
-** a key and one or more values.  The values are used in processing
-** aggregate functions in a SELECT.  The key is used to implement
-** the GROUP BY clause of a select.
-*/
-typedef struct Agg Agg;
-typedef struct AggElem AggElem;
-struct Agg {
-  int nMem;            /* Number of values stored in each AggElem */
-  AggElem *pCurrent;   /* The AggElem currently in focus */
-  HashElem *pSearch;   /* The hash element for pCurrent */
-  Hash hash;           /* Hash table of all aggregate elements */
-  FuncDef **apFunc;    /* Information about aggregate functions */
-};
-struct AggElem {
-  char *zKey;          /* The key to this AggElem */
-  int nKey;            /* Number of bytes in the key, including '\0' at end */
-  Mem aMem[1];         /* The values for this AggElem */
-};
-
-/*
-** A Set structure is used for quick testing to see if a value
-** is part of a small set.  Sets are used to implement code like
-** this:
-**            x.y IN ('hi','hoo','hum')
-*/
-typedef struct Set Set;
-struct Set {
-  Hash hash;             /* A set is just a hash table */
-  HashElem *prev;        /* Previously accessed hash elemen */
-};
-
-/*
-** A Keylist is a bunch of keys into a table.  The keylist can
-** grow without bound.  The keylist stores the ROWIDs of database
-** records that need to be deleted or updated.
-*/
-typedef struct Keylist Keylist;
-struct Keylist {
-  int nKey;         /* Number of slots in aKey[] */
-  int nUsed;        /* Next unwritten slot in aKey[] */
-  int nRead;        /* Next unread slot in aKey[] */
-  Keylist *pNext;   /* Next block of keys */
-  int aKey[1];      /* One or more keys.  Extra space allocated as needed */
-};
-
-/*
-** An instance of the virtual machine.  This structure contains the complete
-** state of the virtual machine.
-**
-** The "sqlite_vm" structure pointer that is returned by sqlite_compile()
-** is really a pointer to an instance of this structure.
-*/
-struct Vdbe {
-  sqlite *db;         /* The whole database */
-  Vdbe *pPrev,*pNext; /* Linked list of VDBEs with the same Vdbe.db */
-  FILE *trace;        /* Write an execution trace here, if not NULL */
-  int nOp;            /* Number of instructions in the program */
-  int nOpAlloc;       /* Number of slots allocated for aOp[] */
-  Op *aOp;            /* Space to hold the virtual machine's program */
-  int nLabel;         /* Number of labels used */
-  int nLabelAlloc;    /* Number of slots allocated in aLabel[] */
-  int *aLabel;        /* Space to hold the labels */
-  int tos;            /* Index of top of stack */
-  Stack *aStack;      /* The operand stack, except string values */
-  char **zStack;      /* Text or binary values of the stack */
-  char **azColName;   /* Becomes the 4th parameter to callbacks */
-  int nCursor;        /* Number of slots in aCsr[] */
-  Cursor *aCsr;       /* One element of this array for each open cursor */
-  Sorter *pSort;      /* A linked list of objects to be sorted */
-  FILE *pFile;        /* At most one open file handler */
-  int nField;         /* Number of file fields */
-  char **azField;     /* Data for each file field */
-  char *zLine;            /* A single line from the input file */
-  int magic;              /* Magic number for sanity checking */
-  int nLineAlloc;         /* Number of spaces allocated for zLine */
-  int nMem;               /* Number of memory locations currently allocated */
-  Mem *aMem;              /* The memory locations */
-  Agg agg;                /* Aggregate information */
-  int nSet;               /* Number of sets allocated */
-  Set *aSet;              /* An array of sets */
-  int nCallback;          /* Number of callbacks invoked so far */
-  Keylist *pList;         /* A list of ROWIDs */
-  int keylistStackDepth;  /* The size of the "keylist" stack */
-  Keylist **keylistStack; /* The stack used by opcodes ListPush & ListPop */
-  int pc;                 /* The program counter */
-  int rc;                 /* Value to return */
-  unsigned uniqueCnt;     /* Used by OP_MakeRecord when P2!=0 */
-  int errorAction;        /* Recovery action to do in case of an error */
-  int undoTransOnError;   /* If error, either ROLLBACK or COMMIT */
-  int inTempTrans;        /* True if temp database is transactioned */
-  int returnStack[100];   /* Return address stack for OP_Gosub & OP_Return */
-  int returnDepth;        /* Next unused element in returnStack[] */
-  int nResColumn;         /* Number of columns in one row of the result set */
-  char **azResColumn;                        /* Values for one row of result */ 
-  int (*xCallback)(void*,int,char**,char**); /* Callback for SELECT results */
-  void *pCbArg;                              /* First argument to xCallback() */
-  int popStack;           /* Pop the stack this much on entry to VdbeExec() */
-  char *zErrMsg;          /* Error message written here */
-  u8 explain;             /* True if EXPLAIN present on SQL command */
-};
-
-/*
-** The following are allowed values for Vdbe.magic
-*/
-#define VDBE_MAGIC_INIT     0x26bceaa5    /* Building a VDBE program */
-#define VDBE_MAGIC_RUN      0xbdf20da3    /* VDBE is ready to execute */
-#define VDBE_MAGIC_HALT     0x519c2973    /* VDBE has completed execution */
-#define VDBE_MAGIC_DEAD     0xb606c3c8    /* The VDBE has been deallocated */
-
-/*
-** When debugging the code generator in a symbolic debugger, one can
-** set the sqlite_vdbe_addop_trace to 1 and all opcodes will be printed
-** as they are added to the instruction stream.
-*/
-#ifndef NDEBUG
-int sqlite_vdbe_addop_trace = 0;
-static void vdbePrintOp(FILE*, int, Op*);
-#endif
-
-/*
-** Create a new virtual database engine.
-*/
-Vdbe *sqliteVdbeCreate(sqlite *db){
-  Vdbe *p;
-  p = sqliteMalloc( sizeof(Vdbe) );
-  if( p==0 ) return 0;
-  p->db = db;
-  if( db->pVdbe ){
-    db->pVdbe->pPrev = p;
-  }
-  p->pNext = db->pVdbe;
-  p->pPrev = 0;
-  db->pVdbe = p;
-  p->magic = VDBE_MAGIC_INIT;
-  return p;
-}
-
-/*
-** Turn tracing on or off
-*/
-void sqliteVdbeTrace(Vdbe *p, FILE *trace){
-  p->trace = trace;
-}
-
-/*
-** Add a new instruction to the list of instructions current in the
-** VDBE.  Return the address of the new instruction.
-**
-** Parameters:
-**
-**    p               Pointer to the VDBE
-**
-**    op              The opcode for this instruction
-**
-**    p1, p2          First two of the three possible operands.
-**
-** Use the sqliteVdbeResolveLabel() function to fix an address and
-** the sqliteVdbeChangeP3() function to change the value of the P3
-** operand.
-*/
-int sqliteVdbeAddOp(Vdbe *p, int op, int p1, int p2){
-  int i;
-
-  i = p->nOp;
-  p->nOp++;
-  assert( p->magic==VDBE_MAGIC_INIT );
-  if( i>=p->nOpAlloc ){
-    int oldSize = p->nOpAlloc;
-    Op *aNew;
-    p->nOpAlloc = p->nOpAlloc*2 + 100;
-    aNew = sqliteRealloc(p->aOp, p->nOpAlloc*sizeof(Op));
-    if( aNew==0 ){
-      p->nOpAlloc = oldSize;
-      return 0;
-    }
-    p->aOp = aNew;
-    memset(&p->aOp[oldSize], 0, (p->nOpAlloc-oldSize)*sizeof(Op));
-  }
-  p->aOp[i].opcode = op;
-  p->aOp[i].p1 = p1;
-  if( p2<0 && (-1-p2)<p->nLabel && p->aLabel[-1-p2]>=0 ){
-    p2 = p->aLabel[-1-p2];
-  }
-  p->aOp[i].p2 = p2;
-  p->aOp[i].p3 = 0;
-  p->aOp[i].p3type = P3_NOTUSED;
-#ifndef NDEBUG
-  if( sqlite_vdbe_addop_trace ) vdbePrintOp(0, i, &p->aOp[i]);
-#endif
-  return i;
-}
-
-/*
-** Create a new symbolic label for an instruction that has yet to be
-** coded.  The symbolic label is really just a negative number.  The
-** label can be used as the P2 value of an operation.  Later, when
-** the label is resolved to a specific address, the VDBE will scan
-** through its operation list and change all values of P2 which match
-** the label into the resolved address.
-**
-** The VDBE knows that a P2 value is a label because labels are
-** always negative and P2 values are suppose to be non-negative.
-** Hence, a negative P2 value is a label that has yet to be resolved.
-*/
-int sqliteVdbeMakeLabel(Vdbe *p){
-  int i;
-  i = p->nLabel++;
-  assert( p->magic==VDBE_MAGIC_INIT );
-  if( i>=p->nLabelAlloc ){
-    int *aNew;
-    p->nLabelAlloc = p->nLabelAlloc*2 + 10;
-    aNew = sqliteRealloc( p->aLabel, p->nLabelAlloc*sizeof(p->aLabel[0]));
-    if( aNew==0 ){
-      sqliteFree(p->aLabel);
-    }
-    p->aLabel = aNew;
-  }
-  if( p->aLabel==0 ){
-    p->nLabel = 0;
-    p->nLabelAlloc = 0;
-    return 0;
-  }
-  p->aLabel[i] = -1;
-  return -1-i;
-}
-
-/*
-** Resolve label "x" to be the address of the next instruction to
-** be inserted.  The parameter "x" must have been obtained from
-** a prior call to sqliteVdbeMakeLabel().
-*/
-void sqliteVdbeResolveLabel(Vdbe *p, int x){
-  int j;
-  assert( p->magic==VDBE_MAGIC_INIT );
-  if( x<0 && (-x)<=p->nLabel && p->aOp ){
-    if( p->aLabel[-1-x]==p->nOp ) return;
-    assert( p->aLabel[-1-x]<0 );
-    p->aLabel[-1-x] = p->nOp;
-    for(j=0; j<p->nOp; j++){
-      if( p->aOp[j].p2==x ) p->aOp[j].p2 = p->nOp;
-    }
-  }
-}
-
-/*
-** Return the address of the next instruction to be inserted.
-*/
-int sqliteVdbeCurrentAddr(Vdbe *p){
-  assert( p->magic==VDBE_MAGIC_INIT );
-  return p->nOp;
-}
-
-/*
-** Add a whole list of operations to the operation stack.  Return the
-** address of the first operation added.
-*/
-int sqliteVdbeAddOpList(Vdbe *p, int nOp, VdbeOp const *aOp){
-  int addr;
-  assert( p->magic==VDBE_MAGIC_INIT );
-  if( p->nOp + nOp >= p->nOpAlloc ){
-    int oldSize = p->nOpAlloc;
-    Op *aNew;
-    p->nOpAlloc = p->nOpAlloc*2 + nOp + 10;
-    aNew = sqliteRealloc(p->aOp, p->nOpAlloc*sizeof(Op));
-    if( aNew==0 ){
-      p->nOpAlloc = oldSize;
-      return 0;
-    }
-    p->aOp = aNew;
-    memset(&p->aOp[oldSize], 0, (p->nOpAlloc-oldSize)*sizeof(Op));
-  }
-  addr = p->nOp;
-  if( nOp>0 ){
-    int i;
-    for(i=0; i<nOp; i++){
-      int p2 = aOp[i].p2;
-      p->aOp[i+addr] = aOp[i];
-      if( p2<0 ) p->aOp[i+addr].p2 = addr + ADDR(p2);
-      p->aOp[i+addr].p3type = aOp[i].p3 ? P3_STATIC : P3_NOTUSED;
-#ifndef NDEBUG
-      if( sqlite_vdbe_addop_trace ) vdbePrintOp(0, i+addr, &p->aOp[i+addr]);
-#endif
-    }
-    p->nOp += nOp;
-  }
-  return addr;
-}
-
-#if 0 /* NOT USED */
-/*
-** Change the value of the P1 operand for a specific instruction.
-** This routine is useful when a large program is loaded from a
-** static array using sqliteVdbeAddOpList but we want to make a
-** few minor changes to the program.
-*/
-void sqliteVdbeChangeP1(Vdbe *p, int addr, int val){
-  assert( p->magic==VDBE_MAGIC_INIT );
-  if( p && addr>=0 && p->nOp>addr && p->aOp ){
-    p->aOp[addr].p1 = val;
-  }
-}
-#endif /* NOT USED */
-
-/*
-** Change the value of the P2 operand for a specific instruction.
-** This routine is useful for setting a jump destination.
-*/
-void sqliteVdbeChangeP2(Vdbe *p, int addr, int val){
-  assert( val>=0 );
-  assert( p->magic==VDBE_MAGIC_INIT );
-  if( p && addr>=0 && p->nOp>addr && p->aOp ){
-    p->aOp[addr].p2 = val;
-  }
-}
-
-/*
-** Change the value of the P3 operand for a specific instruction.
-** This routine is useful when a large program is loaded from a
-** static array using sqliteVdbeAddOpList but we want to make a
-** few minor changes to the program.
-**
-** If n>=0 then the P3 operand is dynamic, meaning that a copy of
-** the string is made into memory obtained from sqliteMalloc().
-** A value of n==0 means copy bytes of zP3 up to and including the
-** first null byte.  If n>0 then copy n+1 bytes of zP3.
-**
-** If n==P3_STATIC  it means that zP3 is a pointer to a constant static
-** string and we can just copy the pointer.  n==P3_POINTER means zP3 is
-** a pointer to some object other than a string.
-**
-** If addr<0 then change P3 on the most recently inserted instruction.
-*/
-void sqliteVdbeChangeP3(Vdbe *p, int addr, const char *zP3, int n){
-  Op *pOp;
-  assert( p->magic==VDBE_MAGIC_INIT );
-  if( p==0 || p->aOp==0 ) return;
-  if( addr<0 || addr>=p->nOp ){
-    addr = p->nOp - 1;
-    if( addr<0 ) return;
-  }
-  pOp = &p->aOp[addr];
-  if( pOp->p3 && pOp->p3type==P3_DYNAMIC ){
-    sqliteFree(pOp->p3);
-    pOp->p3 = 0;
-  }
-  if( zP3==0 ){
-    pOp->p3 = 0;
-    pOp->p3type = P3_NOTUSED;
-  }else if( n<0 ){
-    pOp->p3 = (char*)zP3;
-    pOp->p3type = n;
-  }else{
-    sqliteSetNString(&pOp->p3, zP3, n, 0);
-    pOp->p3type = P3_DYNAMIC;
-  }
-}
-
-/*
-** If the P3 operand to the specified instruction appears
-** to be a quoted string token, then this procedure removes 
-** the quotes.
-**
-** The quoting operator can be either a grave ascent (ASCII 0x27)
-** or a double quote character (ASCII 0x22).  Two quotes in a row
-** resolve to be a single actual quote character within the string.
-*/
-void sqliteVdbeDequoteP3(Vdbe *p, int addr){
-  Op *pOp;
-  assert( p->magic==VDBE_MAGIC_INIT );
-  if( p->aOp==0 || addr<0 || addr>=p->nOp ) return;
-  pOp = &p->aOp[addr];
-  if( pOp->p3==0 || pOp->p3[0]==0 ) return;
-  if( pOp->p3type==P3_POINTER ) return;
-  if( pOp->p3type!=P3_DYNAMIC ){
-    pOp->p3 = sqliteStrDup(pOp->p3);
-    pOp->p3type = P3_DYNAMIC;
-  }
-  sqliteDequote(pOp->p3);
-}
-
-/*
-** On the P3 argument of the given instruction, change all
-** strings of whitespace characters into a single space and
-** delete leading and trailing whitespace.
-*/
-void sqliteVdbeCompressSpace(Vdbe *p, int addr){
-  char *z;
-  int i, j;
-  Op *pOp;
-  assert( p->magic==VDBE_MAGIC_INIT );
-  if( p->aOp==0 || addr<0 || addr>=p->nOp ) return;
-  pOp = &p->aOp[addr];
-  if( pOp->p3type==P3_POINTER ){
-    return;
-  }
-  if( pOp->p3type!=P3_DYNAMIC ){
-    pOp->p3 = sqliteStrDup(pOp->p3);
-    pOp->p3type = P3_DYNAMIC;
-  }
-  z = pOp->p3;
-  if( z==0 ) return;
-  i = j = 0;
-  while( isspace(z[i]) ){ i++; }
-  while( z[i] ){
-    if( isspace(z[i]) ){
-      z[j++] = ' ';
-      while( isspace(z[++i]) ){}
-    }else{
-      z[j++] = z[i++];
-    }
-  }
-  while( j>0 && isspace(z[j-1]) ){ j--; }
-  z[j] = 0;
-}
-
-/*
-** Search for the current program for the given opcode and P2
-** value.  Return the address plus 1 if found and 0 if not found.
-*/
-int sqliteVdbeFindOp(Vdbe *p, int op, int p2){
-  int i;
-  assert( p->magic==VDBE_MAGIC_INIT );
-  for(i=0; i<p->nOp; i++){
-    if( p->aOp[i].opcode==op && p->aOp[i].p2==p2 ) return i+1;
-  }
-  return 0;
-}
-
-/*
-** Return the opcode for a given address.
-*/
-VdbeOp *sqliteVdbeGetOp(Vdbe *p, int addr){
-  assert( p->magic==VDBE_MAGIC_INIT );
-  assert( addr>=0 && addr<p->nOp );
-  return &p->aOp[addr];
-}
-
-/*
-** The following group or routines are employed by installable functions
-** to return their results.
-**
-** The sqlite_set_result_string() routine can be used to return a string
-** value or to return a NULL.  To return a NULL, pass in NULL for zResult.
-** A copy is made of the string before this routine returns so it is safe
-** to pass in an ephemeral string.
-**
-** sqlite_set_result_error() works like sqlite_set_result_string() except
-** that it signals a fatal error.  The string argument, if any, is the
-** error message.  If the argument is NULL a generic substitute error message
-** is used.
-**
-** The sqlite_set_result_int() and sqlite_set_result_double() set the return
-** value of the user function to an integer or a double.
-**
-** These routines are defined here in vdbe.c because they depend on knowing
-** the internals of the sqlite_func structure which is only defined in 
-** this source file.
-*/
-char *sqlite_set_result_string(sqlite_func *p, const char *zResult, int n){
-  assert( !p->isStep );
-  if( p->s.flags & STK_Dyn ){
-    sqliteFree(p->z);
-  }
-  if( zResult==0 ){
-    p->s.flags = STK_Null;
-    n = 0;
-    p->z = 0;
-    p->s.n = 0;
-  }else{
-    if( n<0 ) n = strlen(zResult);
-    if( n<NBFS-1 ){
-      memcpy(p->s.z, zResult, n);
-      p->s.z[n] = 0;
-      p->s.flags = STK_Str;
-      p->z = p->s.z;
-    }else{
-      p->z = sqliteMallocRaw( n+1 );
-      if( p->z ){
-        memcpy(p->z, zResult, n);
-        p->z[n] = 0;
-      }
-      p->s.flags = STK_Str | STK_Dyn;
-    }
-    p->s.n = n+1;
-  }
-  return p->z;
-}
-void sqlite_set_result_int(sqlite_func *p, int iResult){
-  assert( !p->isStep );
-  if( p->s.flags & STK_Dyn ){
-    sqliteFree(p->z);
-  }
-  p->s.i = iResult;
-  p->s.flags = STK_Int;
-}
-void sqlite_set_result_double(sqlite_func *p, double rResult){
-  assert( !p->isStep );
-  if( p->s.flags & STK_Dyn ){
-    sqliteFree(p->z);
-  }
-  p->s.r = rResult;
-  p->s.flags = STK_Real;
-}
-void sqlite_set_result_error(sqlite_func *p, const char *zMsg, int n){
-  assert( !p->isStep );
-  sqlite_set_result_string(p, zMsg, n);
-  p->isError = 1;
-}
-
-/*
-** Extract the user data from a sqlite_func structure and return a
-** pointer to it.
-**
-** This routine is defined here in vdbe.c because it depends on knowing
-** the internals of the sqlite_func structure which is only defined in 
-** this source file.
-*/
-void *sqlite_user_data(sqlite_func *p){
-  assert( p && p->pFunc );
-  return p->pFunc->pUserData;
-}
-
-/*
-** Allocate or return the aggregate context for a user function.  A new
-** context is allocated on the first call.  Subsequent calls return the
-** same context that was returned on prior calls.
-**
-** This routine is defined here in vdbe.c because it depends on knowing
-** the internals of the sqlite_func structure which is only defined in
-** this source file.
-*/
-void *sqlite_aggregate_context(sqlite_func *p, int nByte){
-  assert( p && p->pFunc && p->pFunc->xStep );
-  if( p->pAgg==0 ){
-    if( nByte<=NBFS ){
-      p->pAgg = (void*)p->z;
-    }else{
-      p->pAgg = sqliteMalloc( nByte );
-    }
-  }
-  return p->pAgg;
-}
-
-/*
-** Return the number of times the Step function of a aggregate has been 
-** called.
-**
-** This routine is defined here in vdbe.c because it depends on knowing
-** the internals of the sqlite_func structure which is only defined in
-** this source file.
-*/
-int sqlite_aggregate_count(sqlite_func *p){
-  assert( p && p->pFunc && p->pFunc->xStep );
-  return p->cnt;
-}
 
 /*
 ** Advance the virtual machine to the next output row.
@@ -811,16 +118,18 @@ int sqlite_step(
     rc = sqliteVdbeExec(p);
   }
   if( rc==SQLITE_DONE || rc==SQLITE_ROW ){
-    *pazColName = (const char**)p->azColName;
-    *pN = p->nResColumn;
+    if( pazColName ) *pazColName = (const char**)p->azColName;
+    if( pN ) *pN = p->nResColumn;
   }else{
-    *pN = 0;
-    *pazColName = 0;
+    if( pazColName) *pazColName = 0;
+    if( pN ) *pN = 0;
   }
-  if( rc==SQLITE_ROW ){
-    *pazValue = (const char**)p->azResColumn;
-  }else{
-    *pazValue = 0;
+  if( pazValue ){
+    if( rc==SQLITE_ROW ){
+      *pazValue = (const char**)p->azResColumn;
+    }else{
+      *pazValue = 0;
+    }
   }
   if( sqliteSafetyOff(db) ){
     return SQLITE_MISUSE;
@@ -829,50 +138,6 @@ int sqlite_step(
 }
 
 /*
-** Reset an Agg structure.  Delete all its contents. 
-**
-** For installable aggregate functions, if the step function has been
-** called, make sure the finalizer function has also been called.  The
-** finalizer might need to free memory that was allocated as part of its
-** private context.  If the finalizer has not been called yet, call it
-** now.
-*/
-static void AggReset(Agg *pAgg){
-  int i;
-  HashElem *p;
-  for(p = sqliteHashFirst(&pAgg->hash); p; p = sqliteHashNext(p)){
-    AggElem *pElem = sqliteHashData(p);
-    assert( pAgg->apFunc!=0 );
-    for(i=0; i<pAgg->nMem; i++){
-      Mem *pMem = &pElem->aMem[i];
-      if( pAgg->apFunc[i] && (pMem->s.flags & STK_AggCtx)!=0 ){
-        sqlite_func ctx;
-        ctx.pFunc = pAgg->apFunc[i];
-        ctx.s.flags = STK_Null;
-        ctx.z = 0;
-        ctx.pAgg = pMem->z;
-        ctx.cnt = pMem->s.i;
-        ctx.isStep = 0;
-        ctx.isError = 0;
-        (*pAgg->apFunc[i]->xFinalize)(&ctx);
-        if( pMem->z!=0 && pMem->z!=pMem->s.z ){
-          sqliteFree(pMem->z);
-        }
-      }else if( pMem->s.flags & STK_Dyn ){
-        sqliteFree(pMem->z);
-      }
-    }
-    sqliteFree(pElem);
-  }
-  sqliteHashClear(&pAgg->hash);
-  sqliteFree(pAgg->apFunc);
-  pAgg->apFunc = 0;
-  pAgg->pCurrent = 0;
-  pAgg->pSearch = 0;
-  pAgg->nMem = 0;
-}
-
-/*
 ** Insert a new aggregate element and make it the element that
 ** has focus.
 **
@@ -922,9 +187,9 @@ static int hardStringify(Vdbe *p, int i){
   Stack *pStack = &p->aStack[i];
   int fg = pStack->flags;
   if( fg & STK_Real ){
-    sprintf(pStack->z,"%.15g",pStack->r);
+    sqlite_snprintf(sizeof(pStack->z),pStack->z,"%.15g",pStack->r);
   }else if( fg & STK_Int ){
-    sprintf(pStack->z,"%d",pStack->i);
+    sqlite_snprintf(sizeof(pStack->z),pStack->z,"%d",pStack->i);
   }else{
     pStack->z[0] = 0;
   }
@@ -980,6 +245,8 @@ static int hardDeephem(Vdbe *p, int i){
   if( z==0 ) return 1;
   memcpy(z, *pzStack, pStack->n);
   *pzStack = z;
+  pStack->flags &= ~STK_Ephem;
+  pStack->flags |= STK_Dyn;
   return 0;
 }
 
@@ -994,8 +261,10 @@ static void hardRelease(Vdbe *p, int i){
 }
 
 /*
-** Return TRUE if zNum is an integer and write
-** the value of the integer into *pNum.
+** Return TRUE if zNum is a 32-bit signed integer and write
+** the value of the integer into *pNum.  If zNum is not an integer
+** or is an integer that is too large to be expressed with just 32
+** bits, then return false.
 **
 ** Under Linux (RedHat 7.2) this routine is much faster than atoi()
 ** for converting strings into integers.
@@ -1003,6 +272,7 @@ static void hardRelease(Vdbe *p, int i){
 static int toInt(const char *zNum, int *pNum){
   int v = 0;
   int neg;
+  int i, c;
   if( *zNum=='-' ){
     neg = 1;
     zNum++;
@@ -1012,13 +282,11 @@ static int toInt(const char *zNum, int *pNum){
   }else{
     neg = 0;
   }
-  if( *zNum==0 ) return 0;
-  while( isdigit(*zNum) ){
-    v = v*10 + *zNum - '0';
-    zNum++;
+  for(i=0; (c=zNum[i])>='0' && c<='9'; i++){
+    v = v*10 + c - '0';
   }
   *pNum = neg ? -v : v;
-  return *zNum==0;
+  return c==0 && i>0 && (i<10 || (i==10 && memcmp(zNum,"2147483647",10)<=0));
 }
 
 /*
@@ -1053,7 +321,7 @@ static void hardIntegerify(Vdbe *p, int i){
     if(((P)->aStack[(I)].flags&STK_Real)==0){ hardRealify(P,I); }
 static void hardRealify(Vdbe *p, int i){
   if( p->aStack[i].flags & STK_Str ){
-    p->aStack[i].r = atof(p->zStack[i]);
+    p->aStack[i].r = sqliteAtoF(p->zStack[i]);
   }else if( p->aStack[i].flags & STK_Int ){
     p->aStack[i].r = p->aStack[i].i;
   }else{
@@ -1063,246 +331,6 @@ static void hardRealify(Vdbe *p, int i){
 }
 
 /*
-** Pop the stack N times.  Free any memory associated with the
-** popped stack elements.
-*/
-static void PopStack(Vdbe *p, int N){
-  assert( N>=0 );
-  if( p->zStack==0 ) return;
-  assert( p->aStack || sqlite_malloc_failed );
-  if( p->aStack==0 ) return;
-  while( N-- > 0 ){
-    if( p->aStack[p->tos].flags & STK_Dyn ){
-      sqliteFree(p->zStack[p->tos]);
-    }
-    p->aStack[p->tos].flags = 0;
-    p->zStack[p->tos] = 0;
-    p->tos--;
-  }
-}
-
-/*
-** Here is a macro to handle the common case of popping the stack
-** once.  This macro only works from within the sqliteVdbeExec()
-** function.
-*/
-#define POPSTACK \
-  assert(p->tos>=0); \
-  if( aStack[p->tos].flags & STK_Dyn ) sqliteFree(zStack[p->tos]); \
-  p->tos--;
-
-/*
-** Delete a keylist
-*/
-static void KeylistFree(Keylist *p){
-  while( p ){
-    Keylist *pNext = p->pNext;
-    sqliteFree(p);
-    p = pNext;
-  }
-}
-
-/*
-** Close a cursor and release all the resources that cursor happens
-** to hold.
-*/
-static void cleanupCursor(Cursor *pCx){
-  if( pCx->pCursor ){
-    sqliteBtreeCloseCursor(pCx->pCursor);
-  }
-  if( pCx->pBt ){
-    sqliteBtreeClose(pCx->pBt);
-  }
-  sqliteFree(pCx->pData);
-  memset(pCx, 0, sizeof(Cursor));
-}
-
-/*
-** Close all cursors
-*/
-static void closeAllCursors(Vdbe *p){
-  int i;
-  for(i=0; i<p->nCursor; i++){
-    cleanupCursor(&p->aCsr[i]);
-  }
-  sqliteFree(p->aCsr);
-  p->aCsr = 0;
-  p->nCursor = 0;
-}
-
-/*
-** Remove any elements that remain on the sorter for the VDBE given.
-*/
-static void SorterReset(Vdbe *p){
-  while( p->pSort ){
-    Sorter *pSorter = p->pSort;
-    p->pSort = pSorter->pNext;
-    sqliteFree(pSorter->zKey);
-    sqliteFree(pSorter->pData);
-    sqliteFree(pSorter);
-  }
-}
-
-/*
-** Clean up the VM after execution.
-**
-** This routine will automatically close any cursors, lists, and/or
-** sorters that were left open.
-*/
-static void Cleanup(Vdbe *p){
-  int i;
-  PopStack(p, p->tos+1);
-  closeAllCursors(p);
-  if( p->aMem ){
-    for(i=0; i<p->nMem; i++){
-      if( p->aMem[i].s.flags & STK_Dyn ){
-        sqliteFree(p->aMem[i].z);
-      }
-    }
-  }
-  sqliteFree(p->aMem);
-  p->aMem = 0;
-  p->nMem = 0;
-  if( p->pList ){
-    KeylistFree(p->pList);
-    p->pList = 0;
-  }
-  SorterReset(p);
-  if( p->pFile ){
-    if( p->pFile!=stdin ) fclose(p->pFile);
-    p->pFile = 0;
-  }
-  if( p->azField ){
-    sqliteFree(p->azField);
-    p->azField = 0;
-  }
-  p->nField = 0;
-  if( p->zLine ){
-    sqliteFree(p->zLine);
-    p->zLine = 0;
-  }
-  p->nLineAlloc = 0;
-  AggReset(&p->agg);
-  if( p->aSet ){
-    for(i=0; i<p->nSet; i++){
-      sqliteHashClear(&p->aSet[i].hash);
-    }
-  }
-  sqliteFree(p->aSet);
-  p->aSet = 0;
-  p->nSet = 0;
-  if( p->keylistStack ){
-    int ii;
-    for(ii = 0; ii < p->keylistStackDepth; ii++){
-      KeylistFree(p->keylistStack[ii]);
-    }
-    sqliteFree(p->keylistStack);
-    p->keylistStackDepth = 0;
-    p->keylistStack = 0;
-  }
-  sqliteFree(p->zErrMsg);
-  p->zErrMsg = 0;
-  p->magic = VDBE_MAGIC_DEAD;
-}
-
-/*
-** Delete an entire VDBE.
-*/
-void sqliteVdbeDelete(Vdbe *p){
-  int i;
-  if( p==0 ) return;
-  Cleanup(p);
-  if( p->pPrev ){
-    p->pPrev->pNext = p->pNext;
-  }else{
-    assert( p->db->pVdbe==p );
-    p->db->pVdbe = p->pNext;
-  }
-  if( p->pNext ){
-    p->pNext->pPrev = p->pPrev;
-  }
-  p->pPrev = p->pNext = 0;
-  if( p->nOpAlloc==0 ){
-    p->aOp = 0;
-    p->nOp = 0;
-  }
-  for(i=0; i<p->nOp; i++){
-    if( p->aOp[i].p3type==P3_DYNAMIC ){
-      sqliteFree(p->aOp[i].p3);
-    }
-  }
-  sqliteFree(p->aOp);
-  sqliteFree(p->aLabel);
-  sqliteFree(p->aStack);
-  sqliteFree(p);
-}
-
-/*
-** Give a listing of the program in the virtual machine.
-**
-** The interface is the same as sqliteVdbeExec().  But instead of
-** running the code, it invokes the callback once for each instruction.
-** This feature is used to implement "EXPLAIN".
-*/
-int sqliteVdbeList(
-  Vdbe *p                   /* The VDBE */
-){
-  sqlite *db = p->db;
-  int i;
-  static char *azColumnNames[] = {
-     "addr", "opcode", "p1",  "p2",  "p3", 
-     "int",  "text",   "int", "int", "text",
-     0
-  };
-
-  assert( p->popStack==0 );
-  assert( p->explain );
-  p->azColName = azColumnNames;
-  p->azResColumn = p->zStack;
-  for(i=0; i<5; i++) p->zStack[i] = p->aStack[i].z;
-  p->rc = SQLITE_OK;
-  for(i=p->pc; p->rc==SQLITE_OK && i<p->nOp; i++){
-    if( db->flags & SQLITE_Interrupt ){
-      db->flags &= ~SQLITE_Interrupt;
-      if( db->magic!=SQLITE_MAGIC_BUSY ){
-        p->rc = SQLITE_MISUSE;
-      }else{
-        p->rc = SQLITE_INTERRUPT;
-      }
-      sqliteSetString(&p->zErrMsg, sqlite_error_string(p->rc), 0);
-      break;
-    }
-    sprintf(p->zStack[0],"%d",i);
-    sprintf(p->zStack[2],"%d", p->aOp[i].p1);
-    sprintf(p->zStack[3],"%d", p->aOp[i].p2);
-    if( p->aOp[i].p3type==P3_POINTER ){
-      sprintf(p->aStack[4].z, "ptr(%p)", p->aOp[i].p3);
-      p->zStack[4] = p->aStack[4].z;
-    }else{
-      p->zStack[4] = p->aOp[i].p3;
-    }
-    p->zStack[1] = sqliteOpcodeNames[p->aOp[i].opcode];
-    if( p->xCallback==0 ){
-      p->pc = i+1;
-      p->azResColumn = p->zStack;
-      p->nResColumn = 5;
-      return SQLITE_ROW;
-    }
-    if( sqliteSafetyOff(db) ){
-      p->rc = SQLITE_MISUSE;
-      break;
-    }
-    if( p->xCallback(p->pCbArg, 5, p->zStack, p->azColName) ){
-      p->rc = SQLITE_ABORT;
-    }
-    if( sqliteSafetyOn(db) ){
-      p->rc = SQLITE_MISUSE;
-    }
-  }
-  return p->rc==SQLITE_OK ? SQLITE_DONE : SQLITE_ERROR;
-}
-
-/*
 ** The parameters are pointers to the head of two sorted lists
 ** of Sorter structures.  Merge these two lists together and return
 ** a single sorted list.  This routine forms the core of the merge-sort
@@ -1407,26 +435,6 @@ static char *vdbe_fgets(char *zBuf, int nBuf, FILE *in){
   return i>0 ? zBuf : 0;
 }
 
-#if !defined(NDEBUG) || defined(VDBE_PROFILE)
-/*
-** Print a single opcode.  This routine is used for debugging only.
-*/
-static void vdbePrintOp(FILE *pOut, int pc, Op *pOp){
-  char *zP3;
-  char zPtr[40];
-  if( pOp->p3type==P3_POINTER ){
-    sprintf(zPtr, "ptr(%#x)", (int)pOp->p3);
-    zP3 = zPtr;
-  }else{
-    zP3 = pOp->p3;
-  }
-  if( pOut==0 ) pOut = stdout;
-  fprintf(pOut,"%4d %-12s %4d %4d %s\n",
-      pc, sqliteOpcodeNames[pOp->opcode], pOp->p1, pOp->p2, zP3 ? zP3 : "");
-  fflush(pOut);
-}
-#endif
-
 /*
 ** Make sure there is space in the Vdbe structure to hold at least
 ** mxCursor cursors.  If there is not currently enough space, then
@@ -1477,78 +485,6 @@ __inline__ unsigned long long int hwtime(void){
 
 
 /*
-** Prepare a virtual machine for execution.  This involves things such
-** as allocating stack space and initializing the program counter.
-** After the VDBE has be prepped, it can be executed by one or more
-** calls to sqliteVdbeExec().  
-**
-** The behavior of sqliteVdbeExec() is influenced by the parameters to
-** this routine.  If xCallback is NULL, then sqliteVdbeExec() will return
-** with SQLITE_ROW whenever there is a row of the result set ready
-** to be delivered.  p->azResColumn will point to the row and 
-** p->nResColumn gives the number of columns in the row.  If xCallback
-** is not NULL, then the xCallback() routine is invoked to process each
-** row in the result set.
-*/
-void sqliteVdbeMakeReady(
-  Vdbe *p,                       /* The VDBE */
-  sqlite_callback xCallback,     /* Result callback */
-  void *pCallbackArg,            /* 1st argument to xCallback() */
-  int isExplain                  /* True if the EXPLAIN keywords is present */
-){
-  int n;
-#ifdef MEMORY_DEBUG
-  extern int access(const char*,int);
-#endif
-
-  assert( p!=0 );
-  assert( p->aStack==0 );
-  assert( p->magic==VDBE_MAGIC_INIT );
-
-  /* Add a HALT instruction to the very end of the program.
-  */
-  sqliteVdbeAddOp(p, OP_Halt, 0, 0);
-
-  /* No instruction ever pushes more than a single element onto the
-  ** stack.  And the stack never grows on successive executions of the
-  ** same loop.  So the total number of instructions is an upper bound
-  ** on the maximum stack depth required.
-  **
-  ** Allocation all the stack space we will ever need.
-  */
-  n = isExplain ? 10 : p->nOp;
-  p->aStack = sqliteMalloc( n*(sizeof(p->aStack[0]) + 2*sizeof(char*)) );
-  p->zStack = (char**)&p->aStack[n];
-  p->azColName = (char**)&p->zStack[n];
-
-  sqliteHashInit(&p->agg.hash, SQLITE_HASH_BINARY, 0);
-  p->agg.pSearch = 0;
-#ifdef MEMORY_DEBUG
-  if( access("vdbe_trace",0)==0 ){
-    p->trace = stdout;
-  }
-#endif
-  p->tos = -1;
-  p->pc = 0;
-  p->rc = SQLITE_OK;
-  p->uniqueCnt = 0;
-  p->returnDepth = 0;
-  p->errorAction = OE_Abort;
-  p->undoTransOnError = 0;
-  p->xCallback = xCallback;
-  p->pCbArg = pCallbackArg;
-  p->popStack =  0;
-  p->explain = isExplain;
-  p->magic = VDBE_MAGIC_RUN;
-#ifdef VDBE_PROFILE
-  for(i=0; i<p->nOp; i++){
-    p->aOp[i].cnt = 0;
-    p->aOp[i].cycles = 0;
-  }
-#endif
-}
-
-/*
 ** Execute as much of a VDBE program as we can then return.
 **
 ** sqliteVdbeMakeReady() must be called before this routine in order to
@@ -1593,6 +529,9 @@ int sqliteVdbeExec(
   unsigned long long start;  /* CPU clock count at start of opcode */
   int origPc;                /* Program counter at start of opcode */
 #endif
+#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
+  int nProgressOps = 0;      /* Opcodes executed since progress callback. */
+#endif
 
   if( p->magic!=VDBE_MAGIC_RUN ) return SQLITE_MISUSE;
   assert( db->magic==SQLITE_MAGIC_BUSY );
@@ -1601,11 +540,12 @@ int sqliteVdbeExec(
   assert( p->explain==0 );
   if( sqlite_malloc_failed ) goto no_mem;
   if( p->popStack ){
-    PopStack(p, p->popStack);
+    sqliteVdbePopStack(p, p->popStack);
     p->popStack = 0;
   }
   for(pc=p->pc; rc==SQLITE_OK; pc++){
     assert( pc>=0 && pc<p->nOp );
+    assert( p->tos<=pc );
 #ifdef VDBE_PROFILE
     origPc = pc;
     start = hwtime();
@@ -1616,8 +556,25 @@ int sqliteVdbeExec(
     */
 #ifndef NDEBUG
     if( p->trace ){
-      vdbePrintOp(p->trace, pc, pOp);
+      sqliteVdbePrintOp(p->trace, pc, pOp);
+    }
+#endif
+
+#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
+    /* Call the progress callback if it is configured and the required number
+    ** of VDBE ops have been executed (either since this invocation of
+    ** sqliteVdbeExec() or since last time the progress callback was called).
+    ** If the progress callback returns non-zero, exit the virtual machine with
+    ** a return code SQLITE_ABORT.
+    */
+    if( db->xProgress && (db->nProgressOps==nProgressOps) ){
+      if( db->xProgress(db->pProgressArg)!=0 ){
+        rc = SQLITE_ABORT;
+        continue; /* skip to the next iteration of the for loop */
+      }
+      nProgressOps = 0;
     }
+    nProgressOps++;
 #endif
 
     switch( pOp->opcode ){
@@ -1675,7 +632,7 @@ case OP_Goto: {
 */
 case OP_Gosub: {
   if( p->returnDepth>=sizeof(p->returnStack)/sizeof(p->returnStack[0]) ){
-    sqliteSetString(&p->zErrMsg, "return address stack overflow", 0);
+    sqliteSetString(&p->zErrMsg, "return address stack overflow", (char*)0);
     p->rc = SQLITE_INTERNAL;
     return SQLITE_ERROR;
   }
@@ -1692,7 +649,7 @@ case OP_Gosub: {
 */
 case OP_Return: {
   if( p->returnDepth<=0 ){
-    sqliteSetString(&p->zErrMsg, "return address stack underflow", 0);
+    sqliteSetString(&p->zErrMsg, "return address stack underflow", (char*)0);
     p->rc = SQLITE_INTERNAL;
     return SQLITE_ERROR;
   }
@@ -1724,7 +681,7 @@ case OP_Halt: {
     p->rc = pOp->p1;
     p->errorAction = pOp->p2;
     if( pOp->p3 ){
-      sqliteSetString(&p->zErrMsg, pOp->p3, 0);
+      sqliteSetString(&p->zErrMsg, pOp->p3, (char*)0);
     }
     return SQLITE_ERROR;
   }else{
@@ -1771,13 +728,37 @@ case OP_String: {
   break;
 }
 
+/* Opcode: Variable P1 * *
+**
+** Push the value of variable P1 onto the stack.  A variable is
+** an unknown in the original SQL string as handed to sqlite_compile().
+** Any occurance of the '?' character in the original SQL is considered
+** a variable.  Variables in the SQL string are number from left to
+** right beginning with 1.  The values of variables are set using the
+** sqlite_bind() API.
+*/
+case OP_Variable: {
+  int i = ++p->tos;
+  int j = pOp->p1 - 1;
+  if( j>=0 && j<p->nVar && p->azVar[j]!=0 ){
+    zStack[i] = p->azVar[j];
+    aStack[i].n = p->anVar[j];
+    aStack[i].flags = STK_Str | STK_Static;
+  }else{
+    zStack[i] = 0;
+    aStack[i].n = 0;
+    aStack[i].flags = STK_Null;
+  }
+  break;
+}
+
 /* Opcode: Pop P1 * *
 **
 ** P1 elements are popped off of the top of stack and discarded.
 */
 case OP_Pop: {
   assert( p->tos+1>=pOp->p1 );
-  PopStack(p, pOp->p1);
+  sqliteVdbePopStack(p, pOp->p1);
   break;
 }
 
@@ -1839,11 +820,12 @@ case OP_Pull: {
   Stack ts;
   char *tz;
   VERIFY( if( from<0 ) goto not_enough_stack; )
+  Deephemeralize(p, from);
   ts = aStack[from];
   tz = zStack[from];
   Deephemeralize(p, to);
   for(i=from; i<to; i++){
-    Deephemeralize(p, i);
+    Deephemeralize(p, i+1);
     aStack[i] = aStack[i+1];
     assert( (aStack[i].flags & STK_Ephem)==0 );
     if( aStack[i].flags & (STK_Dyn|STK_Static) ){
@@ -1931,7 +913,7 @@ case OP_Callback: {
   }
   if( sqliteSafetyOn(db) ) goto abort_due_to_misuse;
   p->nCallback++;
-  PopStack(p, pOp->p1);
+  sqliteVdbePopStack(p, pOp->p1);
   if( sqlite_malloc_failed ) goto no_mem;
   break;
 }
@@ -2002,7 +984,7 @@ case OP_Concat: {
     }
   }
   if( nByte<0 ){
-    if( pOp->p2==0 ) PopStack(p, nField);
+    if( pOp->p2==0 ) sqliteVdbePopStack(p, nField);
     p->tos++;
     aStack[p->tos].flags = STK_Null;
     zStack[p->tos] = 0;
@@ -2022,7 +1004,7 @@ case OP_Concat: {
     }
   }
   zNew[j] = 0;
-  if( pOp->p2==0 ) PopStack(p, nField);
+  if( pOp->p2==0 ) sqliteVdbePopStack(p, nField);
   p->tos++;
   aStack[p->tos].n = nByte;
   aStack[p->tos].flags = STK_Str|STK_Dyn;
@@ -2142,7 +1124,7 @@ case OP_Remainder: {
   break;
 
 divide_by_zero:
-  PopStack(p, 2);
+  sqliteVdbePopStack(p, 2);
   p->tos = nos;
   aStack[nos].flags = STK_Null;
   break;
@@ -2176,7 +1158,7 @@ case OP_Function: {
   ctx.isError = 0;
   ctx.isStep = 0;
   (*ctx.pFunc->xFunc)(&ctx, n, (const char**)&zStack[p->tos-n+1]);
-  PopStack(p, n);
+  sqliteVdbePopStack(p, n);
   p->tos++;
   aStack[p->tos] = ctx.s;
   if( ctx.s.flags & STK_Dyn ){
@@ -2188,7 +1170,7 @@ case OP_Function: {
   }
   if( ctx.isError ){
     sqliteSetString(&p->zErrMsg, 
-       zStack[p->tos] ? zStack[p->tos] : "user function error", 0);
+       zStack[p->tos] ? zStack[p->tos] : "user function error", (char*)0);
     rc = SQLITE_ERROR;
   }
   break;
@@ -2269,6 +1251,30 @@ case OP_AddImm: {
   break;
 }
 
+/* Opcode: IsNumeric P1 P2 *
+**
+** Check the top of the stack to see if it is a numeric value.  A numeric
+** value is an integer, a real number, or a string that looks like an 
+** integer or a real number.  When P1==0, pop the stack and jump to P2
+** if the value is numeric.  Otherwise fall through and leave the stack
+** unchanged.  The sense of the test is inverted when P1==1.
+*/
+case OP_IsNumeric: {
+  int tos = p->tos;
+  int r;
+  VERIFY( if( tos<0 ) goto not_enough_stack; )
+  r = (aStack[tos].flags & (STK_Int|STK_Real))!=0 
+           || (zStack[tos] && sqliteIsNumber(zStack[tos]));
+  if( pOp->p1 ){
+    r = !r;
+  }
+  if( r ){
+    POPSTACK;
+    pc = pOp->p2 - 1;
+  }
+  break;
+}
+
 /* Opcode: MustBeInt P1 P2 *
 ** 
 ** Force the top of the stack to be an integer.  If the top of the
@@ -2295,14 +1301,24 @@ case OP_MustBeInt: {
   }else if( aStack[tos].flags & STK_Str ){
     int v;
     if( !toInt(zStack[tos], &v) ){
-      goto mismatch;
+      double r;
+      if( !sqliteIsNumber(zStack[tos]) ){
+        goto mismatch;
+      }
+      Realify(p, tos);
+      assert( (aStack[tos].flags & STK_Real)!=0 );
+      v = aStack[tos].r;
+      r = (double)v;
+      if( r!=aStack[tos].r ){
+        goto mismatch;
+      }
     }
-    p->aStack[tos].i = v;
+    aStack[tos].i = v;
   }else{
     goto mismatch;
   }
   Release(p, tos);
-  p->aStack[tos].flags = STK_Int;
+  aStack[tos].flags = STK_Int;
   break;
 
 mismatch:
@@ -2829,7 +1845,7 @@ case OP_IsNull: {
       break;
     }
   }
-  if( pOp->p1>0 ) PopStack(p, cnt);
+  if( pOp->p1>0 ) sqliteVdbePopStack(p, cnt);
   break;
 }
 
@@ -2958,7 +1974,7 @@ case OP_MakeRecord: {
       j += aStack[i].n;
     }
   }
-  PopStack(p, nField);
+  sqliteVdbePopStack(p, nField);
   p->tos++;
   aStack[p->tos].n = nByte;
   if( nByte<=NBFS ){
@@ -2989,9 +2005,17 @@ case OP_MakeRecord: {
 ** back in its place.
 **
 ** P3 is a string that is P1 characters long.  Each character is either
-** an 'n' or a 't' to indicates if the argument should be numeric or
-** text.  The first character corresponds to the lowest element on the
-** stack.  If P3 is NULL then all arguments are assumed to be numeric.
+** an 'n' or a 't' to indicates if the argument should be intepreted as
+** numeric or text type.  The first character of P3 corresponds to the
+** lowest element on the stack.  If P3 is NULL then all arguments are
+** assumed to be of the numeric type.
+**
+** The type makes a difference in that text-type fields may not be 
+** introduced by 'b' (as described in the next paragraph).  The
+** first character of a text-type field must be either 'a' (if it is NULL)
+** or 'c'.  Numeric fields will be introduced by 'b' if their content
+** looks like a well-formed number.  Otherwise the 'a' or 'c' will be
+** used.
 **
 ** The key is a concatenation of fields.  Each field is terminated by
 ** a single 0x00 character.  A NULL field is introduced by an 'a' and
@@ -3003,7 +2027,7 @@ case OP_MakeRecord: {
 ** sqliteRealToSortable() function.  A text field is introduced by a
 ** 'c' character and is followed by the exact text of the field.  The
 ** use of an 'a', 'b', or 'c' character at the beginning of each field
-** guarantees that NULL sort before numbers and that numbers sort
+** guarantees that NULLs sort before numbers and that numbers sort
 ** before text.  0x00 characters do not occur except as separators
 ** between fields.
 **
@@ -3067,7 +2091,7 @@ case OP_MakeKey: {
       if( (flags & (STK_Real|STK_Int))==STK_Int ){
         aStack[i].r = aStack[i].i;
       }else if( (flags & (STK_Real|STK_Int))==0 ){
-        aStack[i].r = atof(zStack[i]);
+        aStack[i].r = sqliteAtoF(zStack[i]);
       }
       Release(p, i);
       z = aStack[i].z;
@@ -3112,10 +2136,10 @@ case OP_MakeKey: {
     Integerify(p, p->tos-nField);
     iKey = intToKey(aStack[p->tos-nField].i);
     memcpy(&zNewKey[j], &iKey, sizeof(u32));
-    PopStack(p, nField+1);
+    sqliteVdbePopStack(p, nField+1);
     if( pOp->p2 && containsNull ) pc = pOp->p2 - 1;
   }else{
-    if( pOp->p2==0 ) PopStack(p, nField+addRowid);
+    if( pOp->p2==0 ) sqliteVdbePopStack(p, nField+addRowid);
   }
   p->tos++;
   aStack[p->tos].n = nByte;
@@ -3206,7 +2230,7 @@ case OP_Transaction: {
           p->rc = SQLITE_BUSY;
           return SQLITE_BUSY;
         }else if( (*db->xBusyCallback)(db->pBusyArg, "", busy++)==0 ){
-          sqliteSetString(&p->zErrMsg, sqlite_error_string(rc), 0);
+          sqliteSetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0);
           busy = 0;
         }
         break;
@@ -3344,7 +2368,7 @@ case OP_VerifyCookie: {
   assert( pOp->p1>=0 && pOp->p1<db->nDb );
   rc = sqliteBtreeGetMeta(db->aDb[pOp->p1].pBt, aMeta);
   if( rc==SQLITE_OK && aMeta[1]!=pOp->p2 ){
-    sqliteSetString(&p->zErrMsg, "database schema has changed", 0);
+    sqliteSetString(&p->zErrMsg, "database schema has changed", (char*)0);
     rc = SQLITE_SCHEMA;
   }
   break;
@@ -3418,14 +2442,14 @@ case OP_OpenWrite: {
     p2 = p->aStack[tos].i;
     POPSTACK;
     if( p2<2 ){
-      sqliteSetString(&p->zErrMsg, "root page number less than 2", 0);
+      sqliteSetString(&p->zErrMsg, "root page number less than 2", (char*)0);
       rc = SQLITE_INTERNAL;
       break;
     }
   }
   VERIFY( if( i<0 ) goto bad_instruction; )
   if( expandCursorArraySize(p, i) ) goto no_mem;
-  cleanupCursor(&p->aCsr[i]);
+  sqliteVdbeCleanupCursor(&p->aCsr[i]);
   memset(&p->aCsr[i], 0, sizeof(Cursor));
   p->aCsr[i].nullRow = 1;
   if( pX==0 ) break;
@@ -3438,7 +2462,7 @@ case OP_OpenWrite: {
           p->rc = SQLITE_BUSY;
           return SQLITE_BUSY;
         }else if( (*db->xBusyCallback)(db->pBusyArg, pOp->p3, ++busy)==0 ){
-          sqliteSetString(&p->zErrMsg, sqlite_error_string(rc), 0);
+          sqliteSetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0);
           busy = 0;
         }
         break;
@@ -3483,7 +2507,7 @@ case OP_OpenTemp: {
   VERIFY( if( i<0 ) goto bad_instruction; )
   if( expandCursorArraySize(p, i) ) goto no_mem;
   pCx = &p->aCsr[i];
-  cleanupCursor(pCx);
+  sqliteVdbeCleanupCursor(pCx);
   memset(pCx, 0, sizeof(*pCx));
   pCx->nullRow = 1;
   rc = sqliteBtreeFactory(db, 0, 1, TEMP_PAGES, &pCx->pBt);
@@ -3521,7 +2545,7 @@ case OP_OpenPseudo: {
   VERIFY( if( i<0 ) goto bad_instruction; )
   if( expandCursorArraySize(p, i) ) goto no_mem;
   pCx = &p->aCsr[i];
-  cleanupCursor(pCx);
+  sqliteVdbeCleanupCursor(pCx);
   memset(pCx, 0, sizeof(*pCx));
   pCx->nullRow = 1;
   pCx->pseudoTable = 1;
@@ -3536,7 +2560,7 @@ case OP_OpenPseudo: {
 case OP_Close: {
   int i = pOp->p1;
   if( i>=0 && i<p->nCursor ){
-    cleanupCursor(&p->aCsr[i]);
+    sqliteVdbeCleanupCursor(&p->aCsr[i]);
   }
   break;
 }
@@ -4215,11 +3239,11 @@ case OP_Recno: {
   assert( i>=0 && i<p->nCursor );
   if( (pC = &p->aCsr[i])->recnoIsValid ){
     v = pC->lastRecno;
-  }else if( pC->nullRow ){
-    aStack[tos].flags = STK_Null;
-    break;
   }else if( pC->pseudoTable ){
     v = keyToInt(pC->iKey);
+  }else if( pC->nullRow || pC->pCursor==0 ){
+    aStack[tos].flags = STK_Null;
+    break;
   }else{
     assert( pC->pCursor!=0 );
     sqliteBtreeKey(pC->pCursor, 0, sizeof(u32), (char*)&v);
@@ -4421,7 +3445,7 @@ case OP_IdxPut: {
         ){
           rc = SQLITE_CONSTRAINT;
           if( pOp->p3 && pOp->p3[0] ){
-            sqliteSetString(&p->zErrMsg, pOp->p3, 0);
+            sqliteSetString(&p->zErrMsg, pOp->p3, (char*)0);
           }
           goto abort_due_to_error;
         }
@@ -4629,7 +3653,9 @@ case OP_CreateTable: {
 ** If there are no errors, push a "ok" onto the stack.
 **
 ** P1 is the index of a set that contains the root page numbers
-** for all tables and indices in the main database file.
+** for all tables and indices in the main database file.  The set
+** is cleared by this opcode.  In other words, after this opcode
+** has executed, the set will be empty.
 **
 ** If P2 is not zero, the check is done on the auxiliary database
 ** file, not the main database file.
@@ -4655,6 +3681,8 @@ case OP_IntegrityCk: {
     toInt((char*)sqliteHashKey(i), &aRoot[j]);
   }
   aRoot[j] = 0;
+  sqliteHashClear(&pSet->hash);
+  pSet->prev = 0;
   z = sqliteBtreeIntegrityCheck(db->aDb[pOp->p2].pBt, aRoot, nRoot);
   if( z==0 || z[0]==0 ){
     if( z ) sqliteFree(z);
@@ -4740,7 +3768,7 @@ case OP_ListRead: {
 */
 case OP_ListReset: {
   if( p->pList ){
-    KeylistFree(p->pList);
+    sqliteVdbeKeylistFree(p->pList);
     p->pList = 0;
   }
   break;
@@ -4770,7 +3798,7 @@ case OP_ListPush: {
 case OP_ListPop: {
   assert(p->keylistStackDepth > 0);
   p->keylistStackDepth--;
-  KeylistFree(p->pList);
+  sqliteVdbeKeylistFree(p->pList);
   p->pList = p->keylistStack[p->keylistStackDepth];
   p->keylistStack[p->keylistStackDepth] = 0;
   if( p->keylistStackDepth == 0 ){
@@ -4848,7 +3876,7 @@ case OP_SortMakeRec: {
       z += aStack[i].n;
     }
   }
-  PopStack(p, nField);
+  sqliteVdbePopStack(p, nField);
   p->tos++;
   aStack[p->tos].n = nByte;
   zStack[p->tos] = (char*)azArg;
@@ -4906,7 +3934,7 @@ case OP_SortMakeKey: {
   }
   zNewKey[j] = 0;
   assert( j<nByte );
-  PopStack(p, nField);
+  sqliteVdbePopStack(p, nField);
   p->tos++;
   aStack[p->tos].n = nByte;
   aStack[p->tos].flags = STK_Str|STK_Dyn;
@@ -5009,7 +4037,7 @@ case OP_SortCallback: {
 ** Remove any elements that remain on the sorter.
 */
 case OP_SortReset: {
-  SorterReset(p);
+  sqliteVdbeSorterReset(p);
   break;
 }
 
@@ -5030,7 +4058,7 @@ case OP_FileOpen: {
     p->pFile = fopen(pOp->p3, "r");
   }
   if( p->pFile==0 ){
-    sqliteSetString(&p->zErrMsg,"unable to open file: ", pOp->p3, 0);
+    sqliteSetString(&p->zErrMsg,"unable to open file: ", pOp->p3, (char*)0);
     rc = SQLITE_ERROR;
   }
   break;
@@ -5118,7 +4146,17 @@ case OP_FileRead: {
     }
     while( z[from] ){
       if( z[from]=='\\' && z[from+1]!=0 ){
-        z[to++] = z[from+1];
+        int tx = z[from+1];
+        switch( tx ){
+          case 'b':  tx = '\b'; break;
+          case 'f':  tx = '\f'; break;
+          case 'n':  tx = '\n'; break;
+          case 'r':  tx = '\r'; break;
+          case 't':  tx = '\t'; break;
+          case 'v':  tx = '\v'; break;
+          default:   break;
+        }
+        z[to++] = tx;
         from += 2;
         continue;
       }
@@ -5289,7 +4327,7 @@ case OP_MemIncr: {
 ** Future aggregator elements will contain P2 values each.
 */
 case OP_AggReset: {
-  AggReset(&p->agg);
+  sqliteVdbeAggReset(&p->agg);
   p->agg.nMem = pOp->p2;
   p->agg.apFunc = sqliteMalloc( p->agg.nMem*sizeof(p->agg.apFunc[0]) );
   if( p->agg.apFunc==0 ) goto no_mem;
@@ -5348,7 +4386,7 @@ case OP_AggFunc: {
   (ctx.pFunc->xStep)(&ctx, n, (const char**)&zStack[p->tos-n]);
   pMem->z = ctx.pAgg;
   pMem->s.flags = STK_AggCtx;
-  PopStack(p, n+1);
+  sqliteVdbePopStack(p, n+1);
   if( ctx.isError ){
     rc = SQLITE_ERROR;
   }
@@ -5614,11 +4652,24 @@ case OP_SetNext: {
   break;
 }
 
+/* Opcode: Vacuum * * *
+**
+** Vacuum the entire database.  This opcode will cause other virtual
+** machines to be created and run.  It may not be called from within
+** a transaction.
+*/
+case OP_Vacuum: {
+  if( sqliteSafetyOff(db) ) goto abort_due_to_misuse; 
+  rc = sqliteRunVacuum(&p->zErrMsg, db);
+  if( sqliteSafetyOn(db) ) goto abort_due_to_misuse;
+  break;
+}
+
 /* An other opcode is illegal...
 */
 default: {
-  sprintf(zBuf,"%d",pOp->opcode);
-  sqliteSetString(&p->zErrMsg, "unknown opcode ", zBuf, 0);
+  sqlite_snprintf(sizeof(zBuf),zBuf,"%d",pOp->opcode);
+  sqliteSetString(&p->zErrMsg, "unknown opcode ", zBuf, (char*)0);
   rc = SQLITE_INTERNAL;
   break;
 }
@@ -5638,7 +4689,7 @@ default: {
       pOp->cnt++;
 #if 0
         fprintf(stdout, "%10lld ", elapse);
-        vdbePrintOp(stdout, origPc, &p->aOp[origPc]);
+        sqliteVdbePrintOp(stdout, origPc, &p->aOp[origPc]);
 #endif
     }
 #endif
@@ -5650,7 +4701,7 @@ default: {
     */
 #ifndef NDEBUG
     if( pc<-1 || pc>=p->nOp ){
-      sqliteSetString(&p->zErrMsg, "jump destination out of range", 0);
+      sqliteSetString(&p->zErrMsg, "jump destination out of range", (char*)0);
       rc = SQLITE_INTERNAL;
     }
     if( p->trace && p->tos>=0 ){
@@ -5721,7 +4772,7 @@ vdbe_halt:
   ** to fail on a modern VM computer, so this code is untested.
   */
 no_mem:
-  sqliteSetString(&p->zErrMsg, "out of memory", 0);
+  sqliteSetString(&p->zErrMsg, "out of memory", (char*)0);
   rc = SQLITE_NOMEM;
   goto vdbe_halt;
 
@@ -5736,7 +4787,7 @@ abort_due_to_misuse:
   */
 abort_due_to_error:
   if( p->zErrMsg==0 ){
-    sqliteSetString(&p->zErrMsg, sqlite_error_string(rc), 0);
+    sqliteSetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0);
   }
   goto vdbe_halt;
 
@@ -5751,15 +4802,15 @@ abort_due_to_interrupt:
   }else{
     rc = SQLITE_INTERRUPT;
   }
-  sqliteSetString(&p->zErrMsg, sqlite_error_string(rc), 0);
+  sqliteSetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0);
   goto vdbe_halt;
 
   /* Jump to here if a operator is encountered that requires more stack
   ** operands than are currently available on the stack.
   */
 not_enough_stack:
-  sprintf(zBuf,"%d",pc);
-  sqliteSetString(&p->zErrMsg, "too few operands on stack at ", zBuf, 0);
+  sqlite_snprintf(sizeof(zBuf),zBuf,"%d",pc);
+  sqliteSetString(&p->zErrMsg, "too few operands on stack at ", zBuf, (char*)0);
   rc = SQLITE_INTERNAL;
   goto vdbe_halt;
 
@@ -5767,98 +4818,9 @@ not_enough_stack:
   */
 VERIFY(
 bad_instruction:
-  sprintf(zBuf,"%d",pc);
-  sqliteSetString(&p->zErrMsg, "illegal operation at ", zBuf, 0);
+  sqlite_snprintf(sizeof(zBuf),zBuf,"%d",pc);
+  sqliteSetString(&p->zErrMsg, "illegal operation at ", zBuf, (char*)0);
   rc = SQLITE_INTERNAL;
   goto vdbe_halt;
 )
 }
-
-
-/*
-** Clean up the VDBE after execution.  Return an integer which is the
-** result code.
-*/
-int sqliteVdbeFinalize(Vdbe *p, char **pzErrMsg){
-  sqlite *db = p->db;
-  int i, rc;
-
-  if( p->magic!=VDBE_MAGIC_RUN && p->magic!=VDBE_MAGIC_HALT ){
-    sqliteSetString(pzErrMsg, sqlite_error_string(SQLITE_MISUSE), 0);
-    return SQLITE_MISUSE;
-  }
-  if( p->zErrMsg ){
-    if( pzErrMsg && *pzErrMsg==0 ){
-      *pzErrMsg = p->zErrMsg;
-    }else{
-      sqliteFree(p->zErrMsg);
-    }
-    p->zErrMsg = 0;
-  }
-  Cleanup(p);
-  if( p->rc!=SQLITE_OK ){
-    switch( p->errorAction ){
-      case OE_Abort: {
-        if( !p->undoTransOnError ){
-          for(i=0; i<db->nDb; i++){
-            if( db->aDb[i].pBt ){
-              sqliteBtreeRollbackCkpt(db->aDb[i].pBt);
-            }
-          }
-          break;
-        }
-        /* Fall through to ROLLBACK */
-      }
-      case OE_Rollback: {
-        sqliteRollbackAll(db);
-        db->flags &= ~SQLITE_InTrans;
-        db->onError = OE_Default;
-        break;
-      }
-      default: {
-        if( p->undoTransOnError ){
-          sqliteRollbackAll(db);
-          db->flags &= ~SQLITE_InTrans;
-          db->onError = OE_Default;
-        }
-        break;
-      }
-    }
-    sqliteRollbackInternalChanges(db);
-  }
-  for(i=0; i<db->nDb; i++){
-    if( db->aDb[i].pBt && db->aDb[i].inTrans==2 ){
-      sqliteBtreeCommitCkpt(db->aDb[i].pBt);
-      db->aDb[i].inTrans = 1;
-    }
-  }
-  assert( p->tos<p->pc || sqlite_malloc_failed==1 );
-#ifdef VDBE_PROFILE
-  {
-    FILE *out = fopen("vdbe_profile.out", "a");
-    if( out ){
-      int i;
-      fprintf(out, "---- ");
-      for(i=0; i<p->nOp; i++){
-        fprintf(out, "%02x", p->aOp[i].opcode);
-      }
-      fprintf(out, "\n");
-      for(i=0; i<p->nOp; i++){
-        fprintf(out, "%6d %10lld %8lld ",
-           p->aOp[i].cnt,
-           p->aOp[i].cycles,
-           p->aOp[i].cnt>0 ? p->aOp[i].cycles/p->aOp[i].cnt : 0
-        );
-        vdbePrintOp(out, i, &p->aOp[i]);
-      }
-      fclose(out);
-    }
-  }
-#endif
-  rc = p->rc;
-  sqliteVdbeDelete(p);
-  if( db->want_to_close && db->pVdbe==0 ){
-    sqlite_close(db);
-  }
-  return rc;
-}