CHECK_FOR_INTERRUPT
int sqliteVdbeExec(  Vdbe *p                    /* The VDBE */){  int pc;                    /* The program counter */  Op *pOp;                   /* Current operation */  int rc = SQLITE_OK;        /* Value to return */  sqlite *db = p->db;        /* The database */  Mem *pTos;                 /* Top entry in the operand stack */  char zBuf[100];            /* Space to sprintf() an integer */#ifdef VDBE_PROFILE  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 );  assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY );  p->rc = SQLITE_OK;  assert( p->explain==0 );  if( sqlite_malloc_failed ) goto no_mem;  pTos = p->pTos;  if( p->popStack ){    popStack(&pTos, p->popStack);    p->popStack = 0;  }  CHECK_FOR_INTERRUPT;  for(pc=p->pc; rc==SQLITE_OK; pc++){    assert( pc>=0 && pc<p->nOp );    assert( pTos<=&p->aStack[pc] );#ifdef VDBE_PROFILE    origPc = pc;    start = hwtime();#endif    pOp = &p->aOp[pc];    /* Only allow tracing if NDEBUG is not defined.    */#ifndef NDEBUG    if( p->trace ){      sqliteVdbePrintOp(p->trace, pc, pOp);    }#endif    /* Check to see if we need to simulate an interrupt.  This only happens    ** if we have a special test build.    */#ifdef SQLITE_TEST    if( sqlite_interrupt_count>0 ){      sqlite_interrupt_count--;      if( sqlite_interrupt_count==0 ){        sqlite_interrupt(db);      }    }#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 ){      if( 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 ){/******************************************************************************* What follows is a massive switch statement where each case implements a** separate instruction in the virtual machine.  If we follow the usual** indentation conventions, each case should be indented by 6 spaces.  But** that is a lot of wasted space on the left margin.  So the code within** the switch statement will break with convention and be flush-left. Another** big comment (similar to this one) will mark the point in the code where** we transition back to normal indentation.**** The formatting of each case is important.  The makefile for SQLite** generates two C files "opcodes.h" and "opcodes.c" by scanning this** file looking for lines that begin with "case OP_".  The opcodes.h files** will be filled with #defines that give unique integer values to each** opcode and the opcodes.c file is filled with an array of strings where** each string is the symbolic name for the corresponding opcode.**** Documentation about VDBE opcodes is generated by scanning this file** for lines of that contain "Opcode:".  That line and all subsequent** comment lines are used in the generation of the opcode.html documentation** file.**** SUMMARY:****     Formatting is important to scripts that scan this file.**     Do not deviate from the formatting style currently in use.*******************************************************************************//* Opcode:  Goto * P2 ***** An unconditional jump to address P2.** The next instruction executed will be ** the one at index P2 from the beginning of** the program.*/case OP_Goto: {  CHECK_FOR_INTERRUPT;  pc = pOp->p2 - 1;  break;}/* Opcode:  Gosub * P2 ***** Push the current address plus 1 onto the return address stack** and then jump to address P2.**** The return address stack is of limited depth.  If too many** OP_Gosub operations occur without intervening OP_Returns, then** the return address stack will fill up and processing will abort** with a fatal error.*/case OP_Gosub: {  if( p->returnDepth>=sizeof(p->returnStack)/sizeof(p->returnStack[0]) ){    sqliteSetString(&p->zErrMsg, "return address stack overflow", (char*)0);    p->rc = SQLITE_INTERNAL;    return SQLITE_ERROR;  }  p->returnStack[p->returnDepth++] = pc+1;  pc = pOp->p2 - 1;  break;}/* Opcode:  Return * * ***** Jump immediately to the next instruction after the last unreturned** OP_Gosub.  If an OP_Return has occurred for all OP_Gosubs, then** processing aborts with a fatal error.*/case OP_Return: {  if( p->returnDepth<=0 ){    sqliteSetString(&p->zErrMsg, "return address stack underflow", (char*)0);    p->rc = SQLITE_INTERNAL;    return SQLITE_ERROR;  }  p->returnDepth--;  pc = p->returnStack[p->returnDepth] - 1;  break;}/* Opcode:  Halt P1 P2 ***** Exit immediately.  All open cursors, Lists, Sorts, etc are closed** automatically.**** P1 is the result code returned by sqlite_exec().  For a normal** halt, this should be SQLITE_OK (0).  For errors, it can be some** other value.  If P1!=0 then P2 will determine whether or not to** rollback the current transaction.  Do not rollback if P2==OE_Fail.** Do the rollback if P2==OE_Rollback.  If P2==OE_Abort, then back** out all changes that have occurred during this execution of the** VDBE, but do not rollback the transaction. **** There is an implied "Halt 0 0 0" instruction inserted at the very end of** every program.  So a jump past the last instruction of the program** is the same as executing Halt.*/case OP_Halt: {  p->magic = VDBE_MAGIC_HALT;  p->pTos = pTos;  if( pOp->p1!=SQLITE_OK ){    p->rc = pOp->p1;    p->errorAction = pOp->p2;    if( pOp->p3 ){      sqliteSetString(&p->zErrMsg, pOp->p3, (char*)0);    }    return SQLITE_ERROR;  }else{    p->rc = SQLITE_OK;    return SQLITE_DONE;  }}/* Opcode: Integer P1 * P3**** The integer value P1 is pushed onto the stack.  If P3 is not zero** then it is assumed to be a string representation of the same integer.*/case OP_Integer: {  pTos++;  pTos->i = pOp->p1;  pTos->flags = MEM_Int;  if( pOp->p3 ){    pTos->z = pOp->p3;    pTos->flags |= MEM_Str | MEM_Static;    pTos->n = strlen(pOp->p3)+1;  }  break;}/* Opcode: String * * P3**** The string value P3 is pushed onto the stack.  If P3==0 then a** NULL is pushed onto the stack.*/case OP_String: {  char *z = pOp->p3;  pTos++;  if( z==0 ){    pTos->flags = MEM_Null;  }else{    pTos->z = z;    pTos->n = strlen(z) + 1;    pTos->flags = MEM_Str | MEM_Static;  }  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 j = pOp->p1 - 1;  pTos++;  if( j>=0 && j<p->nVar && p->azVar[j]!=0 ){    pTos->z = p->azVar[j];    pTos->n = p->anVar[j];    pTos->flags = MEM_Str | MEM_Static;  }else{    pTos->flags = MEM_Null;  }  break;}/* Opcode: Pop P1 * ***** P1 elements are popped off of the top of stack and discarded.*/case OP_Pop: {  assert( pOp->p1>=0 );  popStack(&pTos, pOp->p1);  assert( pTos>=&p->aStack[-1] );  break;}/* Opcode: Dup P1 P2 ***** A copy of the P1-th element of the stack ** is made and pushed onto the top of the stack.** The top of the stack is element 0.  So the** instruction "Dup 0 0 0" will make a copy of the** top of the stack.**** If the content of the P1-th element is a dynamically** allocated string, then a new copy of that string** is made if P2==0.  If P2!=0, then just a pointer** to the string is copied.**** Also see the Pull instruction.*/case OP_Dup: {  Mem *pFrom = &pTos[-pOp->p1];  assert( pFrom<=pTos && pFrom>=p->aStack );  pTos++;  memcpy(pTos, pFrom, sizeof(*pFrom)-NBFS);  if( pTos->flags & MEM_Str ){    if( pOp->p2 && (pTos->flags & (MEM_Dyn|MEM_Ephem)) ){      pTos->flags &= ~MEM_Dyn;      pTos->flags |= MEM_Ephem;    }else if( pTos->flags & MEM_Short ){      memcpy(pTos->zShort, pFrom->zShort, pTos->n);      pTos->z = pTos->zShort;    }else if( (pTos->flags & MEM_Static)==0 ){      pTos->z = sqliteMallocRaw(pFrom->n);      if( sqlite_malloc_failed ) goto no_mem;      memcpy(pTos->z, pFrom->z, pFrom->n);      pTos->flags &= ~(MEM_Static|MEM_Ephem|MEM_Short);      pTos->flags |= MEM_Dyn;    }  }  break;}/* Opcode: Pull P1 * ***** The P1-th element is removed from its current location on ** the stack and pushed back on top of the stack.  The** top of the stack is element 0, so "Pull 0 0 0" is** a no-op.  "Pull 1 0 0" swaps the top two elements of** the stack.**** See also the Dup instruction.*/case OP_Pull: {  Mem *pFrom = &pTos[-pOp->p1];  int i;  Mem ts;  ts = *pFrom;  Deephemeralize(pTos);  for(i=0; i<pOp->p1; i++, pFrom++){    Deephemeralize(&pFrom[1]);    *pFrom = pFrom[1];    assert( (pFrom->flags & MEM_Ephem)==0 );    if( pFrom->flags & MEM_Short ){      assert( pFrom->flags & MEM_Str );      assert( pFrom->z==pFrom[1].zShort );      pFrom->z = pFrom->zShort;    }  }  *pTos = ts;  if( pTos->flags & MEM_Short ){    assert( pTos->flags & MEM_Str );    assert( pTos->z==pTos[-pOp->p1].zShort );    pTos->z = pTos->zShort;  }  break;}/* Opcode: Push P1 * ***** Overwrite the value of the P1-th element down on the** stack (P1==0 is the top of the stack) with the value** of the top of the stack.  Then pop the top of the stack.*/case OP_Push: {  Mem *pTo = &pTos[-pOp->p1];  assert( pTo>=p->aStack );  Deephemeralize(pTos);  Release(pTo);  *pTo = *pTos;  if( pTo->flags & MEM_Short ){    assert( pTo->z==pTos->zShort );    pTo->z = pTo->zShort;  }  pTos--;  break;}/* Opcode: ColumnName P1 P2 P3**** P3 becomes the P1-th column name (first is 0).  An array of pointers** to all column names is passed as the 4th parameter to the callback.** If P2==1 then this is the last column in the result set and thus the** number of columns in the result set will be P1.  There must be at least** one OP_ColumnName with a P2==1 before invoking OP_Callback and the** number of columns specified in OP_Callback must one more than the P1** value of the OP_ColumnName that has P2==1.*/case OP_ColumnName: {  assert( pOp->p1>=0 && pOp->p1<p->nOp );  p->azColName[pOp->p1] = pOp->p3;  p->nCallback = 0;  if( pOp->p2 ) p->nResColumn = pOp->p1+1;  break;}/* Opcode: Callback P1 * ***** Pop P1 values off the stack and form them into an array.  Then** invoke the callback function using the newly formed array as the** 3rd parameter.*/case OP_Callback: {  int i;  char **azArgv = p->zArgv;  Mem *pCol;  pCol = &pTos[1-pOp->p1];  assert( pCol>=p->aStack );  for(i=0; i<pOp->p1; i++, pCol++){    if( pCol->flags & MEM_Null ){      azArgv[i] = 0;    }else{      Stringify(pCol);      azArgv[i] = pCol->z;    }  }  azArgv[i] = 0;  p->nCallback++;  p->azResColumn = azArgv;  assert( p->nResColumn==pOp->p1 );  p->popStack = pOp->p1;  p->pc = pc + 1;  p->pTos = pTos;  return SQLITE_ROW;}/* Opcode: Concat P1 P2 P3**** Look at the first P1 elements of the stack.  Append them all ** together with the lowest element first.  Use P3 as a separator.  ** Put the result on the top of the stack.  The original P1 elements** are popped from the stack if P2==0 and retained if P2==1.  If** any element of the stack is NULL, then the result is NULL.**** If P3 is NULL, then use no separator.  When P1==1, this routine** makes a copy of the top stack element into memory obtained** from sqliteMalloc().*/case OP_Concat: {  char *zNew;  int nByte;  int nField;  int i, j;  char *zSep;  int nSep;  Mem *pTerm;  nField = pOp->p1;  zSep = pOp->p3;  if( zSep==0 ) zSep = "";  nSep = strlen(zSep);  assert( &pTos[1-nField] >= p->aStack );  nByte = 1 - nSep;  pTerm = &pTos[1-nField];  for(i=0; i<nField; i++, pTerm++){    if( pTerm->flags & MEM_Null ){      nByte = -1;      break;    }else{      Stringify(pTerm);      nByte += pTerm->n - 1 + nSep;    }  }  if( nByte<0 ){    if( pOp->p2==0 ){      popStack(&pTos, nField);    }    pTos++;    pTos->flags = MEM_Null;    break;  }  zNew = sqliteMallocRaw( nByte );  if( zNew==0 ) goto no_mem;  j = 0;  pTerm = &pTos[1-nField];  for(i=j=0; i<nField; i++, pTerm++){    assert( pTerm->flags & MEM_Str );    memcpy(&zNew[j], pTerm->z, pTerm->n-1);    j += pTerm->n-1;    if( nSep>0 && i<nField-1 ){      memcpy(&zNew[j], zSep, nSep);      j += nSep;    }  }  zNew[j] = 0;  if( pOp->p2==0 ){    popStack(&pTos, nField);  }  pTos++;  pTos->n = nByte;  pTos->flags = MEM_Str|MEM_Dyn;  pTos->z = zNew;  break;}/* Opcode: Add * * ***** Pop the top two elements from the stack, add them together,** and push the result back onto the stack.  If either element** is a string then it is converted to a double using the atof()** function before the addition.** If either operand is NULL, the result is NULL.*//* Opcode: Multiply * * ***** Pop the top two elements from the stack, multiply them together,** and push the result back onto the stack.  If either element** is a string then it is converted to a double using the atof()** function before the multiplication.** If either operand is NULL, the result is NULL.*//* Opcode: Subtract * * ***** Pop the top two elements from the stack, subtract the** first (what was on top of the stack) from the second (the** next on stack)** and push the result back onto the stack.  If either element** is a string then it is converted to a double using the atof()** function before the subtraction.** If either operand is NULL, the result is NULL.*//* Opcode: Divide * * ***** Pop the top two elements from the stack, divide the** first (what was on top of the stack) from the second (the** next on stack)** and push the result back onto the stack.  If either element** is a string then it is converted to a double using the atof()** function before the division.  Division by zero returns NULL.** If either operand is NULL, the result is NULL.*//* Opcode: Remainder * * ***** Pop the top two elements from the stack, divide the** first (what was on top of the stack) from the second (the** next on stack)** and push the remainder after division onto the stack.  If either element** is a string then it is converted to a double using the atof()** function before the division.  Division by zero returns NULL.** If either operand is NULL, the result is NULL.*/case OP_Add:case OP_Subtract:case OP_Multiply:case OP_Divide:case OP_Remainder: {  Mem *pNos = &pTos[-1];  assert( pNos>=p->aStack );  if( ((pTos->flags | pNos->flags) & MEM_Null)!=0 ){    Release(pTos);    pTos--;    Release(pTos);    pTos->flags = MEM_Null;  }else if( (pTos->flags & pNos->flags & MEM_Int)==MEM_Int ){    int a, b;    a = pTos->i;    b = pNos->i;    switch( pOp->opcode ){      case OP_Add:         b += a;       break;      case OP_Subtract:    b -= a;       break;      case OP_Multiply:    b *= a;       break;      case OP_Divide: {        if( a==0 ) goto divide_by_zero;        b /= a;        break;      }      default: {        if( a==0 ) goto divide_by_zero;        b %= a;        break;      }    }    Release(pTos);    pTos--;    Release(pTos);    pTos->i = b;    pTos->flags = MEM_Int;  }else{    double a, b;    Realify(pTos);    Realify(pNos);    a = pTos->r;    b = pNos->r;    switch( pOp->opcode ){      case OP_Add:         b += a;       break;      case OP_Subtract:    b -= a;       break;      case OP_Multiply:    b *= a;       break;      case OP_Divide: {        if( a==0.0 ) goto divide_by_zero;        b /= a;        break;      }      default: {        int ia = (int)a;        int ib = (int)b;        if( ia==0.0 ) goto divide_by_zero;        b = ib % ia;        break;      }    }    Release(pTos);    pTos--;    Release(pTos);    pTos->r = b;    pTos->flags = MEM_Real;  }  break;divide_by_zero:  Release(pTos);  pTos--;  Release(pTos);  pTos->flags = MEM_Null;  break;}/* Opcode: Function P1 * P3**** Invoke a user function (P3 is a pointer to a Function structure that** defines the function) with P1 string arguments taken from the stack.** Pop all arguments from the stack and push back the result.**** See also: AggFunc*/case OP_Function: {  int n, i;  Mem *pArg;  char **azArgv;  sqlite_func ctx;  n = pOp->p1;  pArg = &pTos[1-n];  azArgv = p->zArgv;  for(i=0; i<n; i++, pArg++){    if( pArg->flags & MEM_Null ){      azArgv[i] = 0;    }else{      Stringify(pArg);      azArgv[i] = pArg->z;    }  }  ctx.pFunc = (FuncDef*)pOp->p3;  ctx.s.flags = MEM_Null;  ctx.s.z = 0;  ctx.isError = 0;  ctx.isStep = 0;  if( sqliteSafetyOff(db) ) goto abort_due_to_misuse;  (*ctx.pFunc->xFunc)(&ctx, n, (const char**)azArgv);  if( sqliteSafetyOn(db) ) goto abort_due_to_misuse;  popStack(&pTos, n);  pTos++;  *pTos = ctx.s;  if( pTos->flags & MEM_Short ){    pTos->z = pTos->zShort;  }  if( ctx.isError ){    sqliteSetString(&p->zErrMsg,        (pTos->flags & MEM_Str)!=0 ? pTos->z : "user function error", (char*)0);    rc = SQLITE_ERROR;  }  break;}/* Opcode: BitAnd * * ***** Pop the top two elements from the stack.  Convert both elements** to integers.  Push back onto the stack the bit-wise AND of the** two elements.** If either operand is NULL, the result is NULL.*//* Opcode: BitOr * * ***** Pop the top two elements from the stack.  Convert both elements** to integers.  Push back onto the stack the bit-wise OR of the** two elements.** If either operand is NULL, the result is NULL.*//* Opcode: ShiftLeft * * ***** Pop the top two elements from the stack.  Convert both elements** to integers.  Push back onto the stack the top element shifted** left by N bits where N is the second element on the stack.** If either operand is NULL, the result is NULL.*//* Opcode: ShiftRight * * ***** Pop the top two elements from the stack.  Convert both elements** to integers.  Push back onto the stack the top element shifted** right by N bits where N is the second element on the stack.** If either operand is NULL, the result is NULL.*/case OP_BitAnd:case OP_BitOr:case OP_ShiftLeft:case OP_ShiftRight: {  Mem *pNos = &pTos[-1];  int a, b;  assert( pNos>=p->aStack );  if( (pTos->flags | pNos->flags) & MEM_Null ){    popStack(&pTos, 2);    pTos++;    pTos->flags = MEM_Null;    break;  }  Integerify(pTos);  Integerify(pNos);  a = pTos->i;  b = pNos->i;  switch( pOp->opcode ){    case OP_BitAnd:      a &= b;     break;    case OP_BitOr:       a |= b;     break;    case OP_ShiftLeft:   a <<= b;    break;    case OP_ShiftRight:  a >>= b;    break;    default:   /* CANT HAPPEN */     break;  }  assert( (pTos->flags & MEM_Dyn)==0 );  assert( (pNos->flags & MEM_Dyn)==0 );  pTos--;  Release(pTos);  pTos->i = a;  pTos->flags = MEM_Int;  break;}/* Opcode: AddImm  P1 * *** ** Add the value P1 to whatever is on top of the stack.  The result** is always an integer.**** To force the top of the stack to be an integer, just add 0.*/case OP_AddImm: {  assert( pTos>=p->aStack );  Integerify(pTos);  pTos->i += pOp->p1;  break;}/* Opcode: ForceInt P1 P2 ***** Convert the top of the stack into an integer.  If the current top of** the stack is not numeric (meaning that is is a NULL or a string that** does not look like an integer or floating point number) then pop the** stack and jump to P2.  If the top of the stack is numeric then** convert it into the least integer that is greater than or equal to its** current value if P1==0, or to the least integer that is strictly** greater than its current value if P1==1.*/case OP_ForceInt: {  int v;  assert( pTos>=p->aStack );  if( (pTos->flags & (MEM_Int|MEM_Real))==0         && ((pTos->flags & MEM_Str)==0 || sqliteIsNumber(pTos->z)==0) ){    Release(pTos);    pTos--;    pc = pOp->p2 - 1;    break;  }  if( pTos->flags & MEM_Int ){    v = pTos->i + (pOp->p1!=0);  }else{    Realify(pTos);    v = (int)pTos->r;    if( pTos->r>(double)v ) v++;    if( pOp->p1 && pTos->r==(double)v ) v++;  }  Release(pTos);  pTos->i = v;  pTos->flags = MEM_Int;  break;}/* Opcode: MustBeInt P1 P2 *** ** Force the top of the stack to be an integer.  If the top of the** stack is not an integer and cannot be converted into an integer** with out data loss, then jump immediately to P2, or if P2==0** raise an SQLITE_MISMATCH exception.**** If the top of the stack is not an integer and P2 is not zero and** P1 is 1, then the stack is popped.  In all other cases, the depth** of the stack is unchanged.*/case OP_MustBeInt: {  assert( pTos>=p->aStack );  if( pTos->flags & MEM_Int ){    /* Do nothing */  }else if( pTos->flags & MEM_Real ){    int i = (int)pTos->r;    double r = (double)i;    if( r!=pTos->r ){      goto mismatch;    }    pTos->i = i;  }else if( pTos->flags & MEM_Str ){    int v;    if( !toInt(pTos->z, &v) ){      double r;      if( !sqliteIsNumber(pTos->z) ){        goto mismatch;      }      Realify(pTos);      v = (int)pTos->r;      r = (double)v;      if( r!=pTos->r ){        goto mismatch;      }    }    pTos->i = v;  }else{    goto mismatch;  }  Release(pTos);  pTos->flags = MEM_Int;  break;mismatch:  if( pOp->p2==0 ){    rc = SQLITE_MISMATCH;    goto abort_due_to_error;  }else{    if( pOp->p1 ) popStack(&pTos, 1);    pc = pOp->p2 - 1;  }  break;}/* Opcode: Eq P1 P2 ***** Pop the top two elements from the stack.  If they are equal, then** jump to instruction P2.  Otherwise, continue to the next instruction.**** If either operand is NULL (and thus if the result is unknown) then** take the jump if P1 is true.**** If both values are numeric, they are converted to doubles using atof()** and compared for equality that way.  Otherwise the strcmp() library** routine is used for the comparison.  For a pure text comparison** use OP_StrEq.**** If P2 is zero, do not jump.  Instead, push an integer 1 onto the** stack if the jump would have been taken, or a 0 if not.  Push a** NULL if either operand was NULL.*//* Opcode: Ne P1 P2 ***** Pop the top two elements from the stack.  If they are not equal, then** jump to instruction P2.  Otherwise, continue to the next instruction.**** If either operand is NULL (and thus if the result is unknown) then** take the jump if P1 is true.**** If both values are numeric, they are converted to doubles using atof()** and compared in that format.  Otherwise the strcmp() library** routine is used for the comparison.  For a pure text comparison** use OP_StrNe.**** If P2 is zero, do not jump.  Instead, push an integer 1 onto the** stack if the jump would have been taken, or a 0 if not.  Push a** NULL if either operand was NULL.*//* Opcode: Lt P1 P2 ***** Pop the top two elements from the stack.  If second element (the** next on stack) is less than the first (the top of stack), then** jump to instruction P2.  Otherwise, continue to the next instruction.** In other words, jump if NOS<TOS.**** If either operand is NULL (and thus if the result is unknown) then** take the jump if P1 is true.**** If both values are numeric, they are converted to doubles using atof()** and compared in that format.  Numeric values are always less than** non-numeric values.  If both operands are non-numeric, the strcmp() library** routine is used for the comparison.  For a pure text comparison** use OP_StrLt.**** If P2 is zero, do not jump.  Instead, push an integer 1 onto the** stack if the jump would have been taken, or a 0 if not.  Push a** NULL if either operand was NULL.*//* Opcode: Le P1 P2 ***** Pop the top two elements from the stack.  If second element (the** next on stack) is less than or equal to the first (the top of stack),** then jump to instruction P2. In other words, jump if NOS<=TOS.**** If either operand is NULL (and thus if the result is unknown) then** take the jump if P1 is true.**** If both values are numeric, they are converted to doubles using atof()** and compared in that format.  Numeric values are always less than** non-numeric values.  If both operands are non-numeric, the strcmp() library** routine is used for the comparison.  For a pure text comparison** use OP_StrLe.**** If P2 is zero, do not jump.  Instead, push an integer 1 onto the** stack if the jump would have been taken, or a 0 if not.  Push a** NULL if either operand was NULL.*//* Opcode: Gt P1 P2 ***** Pop the top two elements from the stack.  If second element (the** next on stack) is greater than the first (the top of stack),** then jump to instruction P2. In other words, jump if NOS>TOS.**** If either operand is NULL (and thus if the result is unknown) then** take the jump if P1 is true.**** If both values are numeric, they are converted to doubles using atof()** and compared in that format.  Numeric values are always less than** non-numeric values.  If both operands are non-numeric, the strcmp() library** routine is used for the comparison.  For a pure text comparison** use OP_StrGt.**** If P2 is zero, do not jump.  Instead, push an integer 1 onto the** stack if the jump would have been taken, or a 0 if not.  Push a** NULL if either operand was NULL.*//* Opcode: Ge P1 P2 ***** Pop the top two elements from the stack.  If second element (the next** on stack) is greater than or equal to the first (the top of stack),** then jump to instruction P2. In other words, jump if NOS>=TOS.**** If either operand is NULL (and thus if the result is unknown) then** take the jump if P1 is true.**** If both values are numeric, they are converted to doubles using atof()** and compared in that format.  Numeric values are always less than** non-numeric values.  If both operands are non-numeric, the strcmp() library** routine is used for the comparison.  For a pure text comparison** use OP_StrGe.**** If P2 is zero, do not jump.  Instead, push an integer 1 onto the** stack if the jump would have been taken, or a 0 if not.  Push a** NULL if either operand was NULL.*/case OP_Eq:case OP_Ne:case OP_Lt:case OP_Le:case OP_Gt:case OP_Ge: {  Mem *pNos = &pTos[-1];  int c, v;  int ft, fn;  assert( pNos>=p->aStack );  ft = pTos->flags;  fn = pNos->flags;  if( (ft | fn) & MEM_Null ){    popStack(&pTos, 2);    if( pOp->p2 ){      if( pOp->p1 ) pc = pOp->p2-1;    }else{      pTos++;      pTos->flags = MEM_Null;    }    break;  }else if( (ft & fn & MEM_Int)==MEM_Int ){    c = pNos->i - pTos->i;  }else if( (ft & MEM_Int)!=0 && (fn & MEM_Str)!=0 && toInt(pNos->z,&v) ){    c = v - pTos->i;  }else if( (fn & MEM_Int)!=0 && (ft & MEM_Str)!=0 && toInt(pTos->z,&v) ){    c = pNos->i - v;  }else{    Stringify(pTos);    Stringify(pNos);    c = sqliteCompare(pNos->z, pTos->z);  }  switch( pOp->opcode ){    case OP_Eq:    c = c==0;     break;    case OP_Ne:    c = c!=0;     break;    case OP_Lt:    c = c<0;      break;    case OP_Le:    c = c<=0;     break;    case OP_Gt:    c = c>0;      break;    default:       c = c>=0;     break;  }  popStack(&pTos, 2);  if( pOp->p2 ){    if( c ) pc = pOp->p2-1;  }else{    pTos++;    pTos->i = c;    pTos->flags = MEM_Int;  }  break;}/* INSERT NO CODE HERE!**** The opcode numbers are extracted from this source file by doing****    grep '^case OP_' vdbe.c | ... >opcodes.h**** The opcodes are numbered in the order that they appear in this file.** But in order for the expression generating code to work right, the** string comparison operators that follow must be numbered exactly 6** greater than the numeric comparison opcodes above.  So no other** cases can appear between the two.*//* Opcode: StrEq P1 P2 ***** Pop the top two elements from the stack.  If they are equal, then** jump to instruction P2.  Otherwise, continue to the next instruction.**** If either operand is NULL (and thus if the result is unknown) then** take the jump if P1 is true.**** The strcmp() library routine is used for the comparison.  For a** numeric comparison, use OP_Eq.**** If P2 is zero, do not jump.  Instead, push an integer 1 onto the** stack if the jump would have been taken, or a 0 if not.  Push a** NULL if either operand was NULL.*//* Opcode: StrNe P1 P2 ***** Pop the top two elements from the stack.  If they are not equal, then** jump to instruction P2.  Otherwise, continue to the next instruction.**** If either operand is NULL (and thus if the result is unknown) then** take the jump if P1 is true.**** The strcmp() library routine is used for the comparison.  For a** numeric comparison, use OP_Ne.**** If P2 is zero, do not jump.  Instead, push an integer 1 onto the** stack if the jump would have been taken, or a 0 if not.  Push a** NULL if either operand was NULL.*//* Opcode: StrLt P1 P2 ***** Pop the top two elements from the stack.  If second element (the** next on stack) is less than the first (the top of stack), then** jump to instruction P2.  Otherwise, continue to the next instruction.** In other words, jump if NOS<TOS.**** If either operand is NULL (and thus if the result is unknown) then** take the jump if P1 is true.**** The strcmp() library routine is used for the comparison.  For a** numeric comparison, use OP_Lt.**** If P2 is zero, do not jump.  Instead, push an integer 1 onto the** stack if the jump would have been taken, or a 0 if not.  Push a** NULL if either operand was NULL.*//* Opcode: StrLe P1 P2 ***** Pop the top two elements from the stack.  If second element (the** next on stack) is less than or equal to the first (the top of stack),** then jump to instruction P2. In other words, jump if NOS<=TOS.**** If either operand is NULL (and thus if the result is unknown) then** take the jump if P1 is true.**** The strcmp() library routine is used for the comparison.  For a** numeric comparison, use OP_Le.**** If P2 is zero, do not jump.  Instead, push an integer 1 onto the** stack if the jump would have been taken, or a 0 if not.  Push a** NULL if either operand was NULL.*//* Opcode: StrGt P1 P2 ***** Pop the top two elements from the stack.  If second element (the** next on stack) is greater than the first (the top of stack),** then jump to instruction P2. In other words, jump if NOS>TOS.**** If either operand is NULL (and thus if the result is unknown) then** take the jump if P1 is true.**** The strcmp() library routine is used for the comparison.  For a** numeric comparison, use OP_Gt.**** If P2 is zero, do not jump.  Instead, push an integer 1 onto the** stack if the jump would have been taken, or a 0 if not.  Push a** NULL if either operand was NULL.*//* Opcode: StrGe P1 P2 ***** Pop the top two elements from the stack.  If second element (the next** on stack) is greater than or equal to the first (the top of stack),** then jump to instruction P2. In other words, jump if NOS>=TOS.**** If either operand is NULL (and thus if the result is unknown) then** take the jump if P1 is true.**** The strcmp() library routine is used for the comparison.  For a** numeric comparison, use OP_Ge.**** If P2 is zero, do not jump.  Instead, push an integer 1 onto the** stack if the jump would have been taken, or a 0 if not.  Push a** NULL if either operand was NULL.*/case OP_StrEq:case OP_StrNe:case OP_StrLt:case OP_StrLe:case OP_StrGt:case OP_StrGe: {  Mem *pNos = &pTos[-1];  int c;  assert( pNos>=p->aStack );  if( (pNos->flags | pTos->flags) & MEM_Null ){    popStack(&pTos, 2);    if( pOp->p2 ){      if( pOp->p1 ) pc = pOp->p2-1;    }else{      pTos++;      pTos->flags = MEM_Null;    }    break;  }else{    Stringify(pTos);    Stringify(pNos);    c = strcmp(pNos->z, pTos->z);  }  /* The asserts on each case of the following switch are there to verify  ** that string comparison opcodes are always exactly 6 greater than the  ** corresponding numeric comparison opcodes.  The code generator depends  ** on this fact.  */  switch( pOp->opcode ){    case OP_StrEq:    c = c==0;    assert( pOp->opcode-6==OP_Eq );   break;    case OP_StrNe:    c = c!=0;    assert( pOp->opcode-6==OP_Ne );   break;    case OP_StrLt:    c = c<0;     assert( pOp->opcode-6==OP_Lt );   break;    case OP_StrLe:    c = c<=0;    assert( pOp->opcode-6==OP_Le );   break;    case OP_StrGt:    c = c>0;     assert( pOp->opcode-6==OP_Gt );   break;    default:          c = c>=0;    assert( pOp->opcode-6==OP_Ge );   break;  }  popStack(&pTos, 2);  if( pOp->p2 ){    if( c ) pc = pOp->p2-1;  }else{    pTos++;    pTos->flags = MEM_Int;    pTos->i = c;  }  break;}/* Opcode: And * * ***** Pop two values off the stack.  Take the logical AND of the** two values and push the resulting boolean value back onto the** stack. *//* Opcode: Or * * ***** Pop two values off the stack.  Take the logical OR of the** two values and push the resulting boolean value back onto the** stack. */case OP_And:case OP_Or: {  Mem *pNos = &pTos[-1];  int v1, v2;    /* 0==TRUE, 1==FALSE, 2==UNKNOWN or NULL */  assert( pNos>=p->aStack );  if( pTos->flags & MEM_Null ){    v1 = 2;  }else{    Integerify(pTos);    v1 = pTos->i==0;  }  if( pNos->flags & MEM_Null ){    v2 = 2;  }else{    Integerify(pNos);    v2 = pNos->i==0;  }  if( pOp->opcode==OP_And ){    static const unsigned char and_logic[] = { 0, 1, 2, 1, 1, 1, 2, 1, 2 };    v1 = and_logic[v1*3+v2];  }else{    static const unsigned char or_logic[] = { 0, 0, 0, 0, 1, 2, 0, 2, 2 };    v1 = or_logic[v1*3+v2];  }  popStack(&pTos, 2);  pTos++;  if( v1==2 ){    pTos->flags = MEM_Null;  }else{    pTos->i = v1==0;    pTos->flags = MEM_Int;  }  break;}/* Opcode: Negative * * ***** Treat the top of the stack as a numeric quantity.  Replace it** with its additive inverse.  If the top of the stack is NULL** its value is unchanged.*//* Opcode: AbsValue * * ***** Treat the top of the stack as a numeric quantity.  Replace it** with its absolute value. If the top of the stack is NULL** its value is unchanged.*/case OP_Negative:case OP_AbsValue: {  assert( pTos>=p->aStack );  if( pTos->flags & MEM_Real ){    Release(pTos);    if( pOp->opcode==OP_Negative || pTos->r<0.0 ){      pTos->r = -pTos->r;    }    pTos->flags = MEM_Real;  }else if( pTos->flags & MEM_Int ){    Release(pTos);    if( pOp->opcode==OP_Negative || pTos->i<0 ){      pTos->i = -pTos->i;    }    pTos->flags = MEM_Int;  }else if( pTos->flags & MEM_Null ){    /* Do nothing */  }else{    Realify(pTos);    Release(pTos);    if( pOp->opcode==OP_Negative || pTos->r<0.0 ){      pTos->r = -pTos->r;    }    pTos->flags = MEM_Real;  }  break;}/* Opcode: Not * * ***** Interpret the top of the stack as a boolean value.  Replace it** with its complement.  If the top of the stack is NULL its value** is unchanged.*/case OP_Not: {  assert( pTos>=p->aStack );  if( pTos->flags & MEM_Null ) break;  /* Do nothing to NULLs */  Integerify(pTos);  Release(pTos);  pTos->i = !pTos->i;  pTos->flags = MEM_Int;  break;}/* Opcode: BitNot * * ***** Interpret the top of the stack as an value.  Replace it** with its ones-complement.  If the top of the stack is NULL its** value is unchanged.*/case OP_BitNot: {  assert( pTos>=p->aStack );  if( pTos->flags & MEM_Null ) break;  /* Do nothing to NULLs */  Integerify(pTos);  Release(pTos);  pTos->i = ~pTos->i;  pTos->flags = MEM_Int;  break;}/* Opcode: Noop * * ***** Do nothing.  This instruction is often useful as a jump** destination.*/case OP_Noop: {  break;}/* Opcode: If P1 P2 ***** Pop a single boolean from the stack.  If the boolean popped is** true, then jump to p2.  Otherwise continue to the next instruction.** An integer is false if zero and true otherwise.  A string is** false if it has zero length and true otherwise.**** If the value popped of the stack is NULL, then take the jump if P1** is true and fall through if P1 is false.*//* Opcode: IfNot P1 P2 ***** Pop a single boolean from the stack.  If the boolean popped is** false, then jump to p2.  Otherwise continue to the next instruction.** An integer is false if zero and true otherwise.  A string is** false if it has zero length and true otherwise.**** If the value popped of the stack is NULL, then take the jump if P1** is true and fall through if P1 is false.*/case OP_If:case OP_IfNot: {  int c;  assert( pTos>=p->aStack );  if( pTos->flags & MEM_Null ){    c = pOp->p1;  }else{    Integerify(pTos);    c = pTos->i;    if( pOp->opcode==OP_IfNot ) c = !c;  }  assert( (pTos->flags & MEM_Dyn)==0 );  pTos--;  if( c ) pc = pOp->p2-1;  break;}/* Opcode: IsNull P1 P2 ***** If any of the top abs(P1) values on the stack are NULL, then jump** to P2.  Pop the stack P1 times if P1>0.   If P1<0 leave the stack** unchanged.*/case OP_IsNull: {  int i, cnt;  Mem *pTerm;  cnt = pOp->p1;  if( cnt<0 ) cnt = -cnt;  pTerm = &pTos[1-cnt];  assert( pTerm>=p->aStack );  for(i=0; i<cnt; i++, pTerm++){    if( pTerm->flags & MEM_Null ){      pc = pOp->p2-1;      break;    }  }  if( pOp->p1>0 ) popStack(&pTos, cnt);  break;}/* Opcode: NotNull P1 P2 ***** Jump to P2 if the top P1 values on the stack are all not NULL.  Pop the** stack if P1 times if P1 is greater than zero.  If P1 is less than** zero then leave the stack unchanged.*/case OP_NotNull: {  int i, cnt;  cnt = pOp->p1;  if( cnt<0 ) cnt = -cnt;  assert( &pTos[1-cnt] >= p->aStack );  for(i=0; i<cnt && (pTos[1+i-cnt].flags & MEM_Null)==0; i++){}  if( i>=cnt ) pc = pOp->p2-1;  if( pOp->p1>0 ) popStack(&pTos, cnt);  break;}/* Opcode: MakeRecord P1 P2 ***** Convert the top P1 entries of the stack into a single entry** suitable for use as a data record in a database table.  The** details of the format are irrelavant as long as the OP_Column** opcode can decode the record later.  Refer to source code** comments for the details of the record format.**** If P2 is true (non-zero) and one or more of the P1 entries** that go into building the record is NULL, then add some extra** bytes to the record to make it distinct for other entries created** during the same run of the VDBE.  The extra bytes added are a** counter that is reset with each run of the VDBE, so records** created this way will not necessarily be distinct across runs.** But they should be distinct for transient tables (created using** OP_OpenTemp) which is what they are intended for.**** (Later:) The P2==1 option was intended to make NULLs distinct** for the UNION operator.  But I have since discovered that NULLs** are indistinct for UNION.  So this option is never used.*/case OP_MakeRecord: {  char *zNewRecord;  int nByte;  int nField;  int i, j;  int idxWidth;  u32 addr;  Mem *pRec;  int addUnique = 0;   /* True to cause bytes to be added to make the                       ** generated record distinct */  char zTemp[NBFS];    /* Temp space for small records */  /* Assuming the record contains N fields, the record format looks  ** like this:  **  **   -------------------------------------------------------------------  **   | idx0 | idx1 | ... | idx(N-1) | idx(N) | data0 | ... | data(N-1) |  **   -------------------------------------------------------------------  **  ** All data fields are converted to strings before being stored and  ** are stored with their null terminators.  NULL entries omit the  ** null terminator.  Thus an empty string uses 1 byte and a NULL uses  ** zero bytes.  Data(0) is taken from the lowest element of the stack  ** and data(N-1) is the top of the stack.  **  ** Each of the idx() entries is either 1, 2, or 3 bytes depending on  ** how big the total record is.  Idx(0) contains the offset to the start  ** of data(0).  Idx(k) contains the offset to the start of data(k).  ** Idx(N) contains the total number of bytes in the record.  */  nField = pOp->p1;  pRec = &pTos[1-nField];  assert( pRec>=p->aStack );  nByte = 0;  for(i=0; i<nField; i++, pRec++){    if( pRec->flags & MEM_Null ){      addUnique = pOp->p2;    }else{      Stringify(pRec);      nByte += pRec->n;    }  }  if( addUnique ) nByte += sizeof(p->uniqueCnt);  if( nByte + nField + 1 < 256 ){    idxWidth = 1;  }else if( nByte + 2*nField + 2 < 65536 ){    idxWidth = 2;  }else{    idxWidth = 3;  }  nByte += idxWidth*(nField + 1);  if( nByte>MAX_BYTES_PER_ROW ){    rc = SQLITE_TOOBIG;    goto abort_due_to_error;  }  if( nByte<=NBFS ){    zNewRecord = zTemp;  }else{    zNewRecord = sqliteMallocRaw( nByte );    if( zNewRecord==0 ) goto no_mem;  }  j = 0;  addr = idxWidth*(nField+1) + addUnique*sizeof(p->uniqueCnt);  for(i=0, pRec=&pTos[1-nField]; i<nField; i++, pRec++){    zNewRecord[j++] = addr & 0xff;    if( idxWidth>1 ){      zNewRecord[j++] = (addr>>8)&0xff;      if( idxWidth>2 ){        zNewRecord[j++] = (addr>>16)&0xff;      }    }    if( (pRec->flags & MEM_Null)==0 ){      addr += pRec->n;    }  }  zNewRecord[j++] = addr & 0xff;  if( idxWidth>1 ){    zNewRecord[j++] = (addr>>8)&0xff;    if( idxWidth>2 ){      zNewRecord[j++] = (addr>>16)&0xff;    }  }  if( addUnique ){    memcpy(&zNewRecord[j], &p->uniqueCnt, sizeof(p->uniqueCnt));    p->uniqueCnt++;    j += sizeof(p->uniqueCnt);  }  for(i=0, pRec=&pTos[1-nField]; i<nField; i++, pRec++){    if( (pRec->flags & MEM_Null)==0 ){      memcpy(&zNewRecord[j], pRec->z, pRec->n);      j += pRec->n;    }  }  popStack(&pTos, nField);  pTos++;  pTos->n = nByte;  if( nByte<=NBFS ){    assert( zNewRecord==zTemp );    memcpy(pTos->zShort, zTemp, nByte);    pTos->z = pTos->zShort;    pTos->flags = MEM_Str | MEM_Short;  }else{    assert( zNewRecord!=zTemp );    pTos->z = zNewRecord;    pTos->flags = MEM_Str | MEM_Dyn;  }  break;}/* Opcode: MakeKey P1 P2 P3**** Convert the top P1 entries of the stack into a single entry suitable** for use as the key in an index.  The top P1 records are** converted to strings and merged.  The null-terminators ** are retained and used as separators.** The lowest entry in the stack is the first field and the top of the** stack becomes the last.**** If P2 is not zero, then the original entries remain on the stack** and the new key is pushed on top.  If P2 is zero, the original** data is popped off the stack first then the new key is pushed** 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 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** is followed immediately by its 0x00 terminator.  A numeric field is** introduced by a single character 'b' and is followed by a sequence** of characters that represent the number such that a comparison of** the character string using memcpy() sorts the numbers in numerical** order.  The character strings for numbers are generated using the** 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 NULLs sort before numbers and that numbers sort** before text.  0x00 characters do not occur except as separators** between fields.**** See also: MakeIdxKey, SortMakeKey*//* Opcode: MakeIdxKey P1 P2 P3**** Convert the top P1 entries of the stack into a single entry suitable** for use as the key in an index.  In addition, take one additional integer** off of the stack, treat that integer as a four-byte record number, and** append the four bytes to the key.  Thus a total of P1+1 entries are** popped from the stack for this instruction and a single entry is pushed** back.  The first P1 entries that are popped are strings and the last** entry (the lowest on the stack) is an integer record number.**** The converstion of the first P1 string entries occurs just like in** MakeKey.  Each entry is separated from the others by a null.** The entire concatenation is null-terminated.  The lowest entry** in the stack is the first field and the top of the stack becomes the** last.**** If P2 is not zero and one or more of the P1 entries that go into the** generated key is NULL, then jump to P2 after the new key has been** pushed on the stack.  In other words, jump to P2 if the key is** guaranteed to be unique.  This jump can be used to skip a subsequent** uniqueness test.**** 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.**** See also:  MakeKey, SortMakeKey*/case OP_MakeIdxKey:case OP_MakeKey: {  char *zNewKey;  int nByte;  int nField;  int addRowid;  int i, j;  int containsNull = 0;  Mem *pRec;  char zTemp[NBFS];  addRowid = pOp->opcode==OP_MakeIdxKey;  nField = pOp->p1;  pRec = &pTos[1-nField];  assert( pRec>=p->aStack );  nByte = 0;  for(j=0, i=0; i<nField; i++, j++, pRec++){    int flags = pRec->flags;    int len;    char *z;    if( flags & MEM_Null ){      nByte += 2;      containsNull = 1;    }else if( pOp->p3 && pOp->p3[j]=='t' ){      Stringify(pRec);      pRec->flags &= ~(MEM_Int|MEM_Real);      nByte += pRec->n+1;    }else if( (flags & (MEM_Real|MEM_Int))!=0 || sqliteIsNumber(pRec->z) ){      if( (flags & (MEM_Real|MEM_Int))==MEM_Int ){        pRec->r = pRec->i;      }else if( (flags & (MEM_Real|MEM_Int))==0 ){        pRec->r = sqliteAtoF(pRec->z, 0);      }      Release(pRec);      z = pRec->zShort;      sqliteRealToSortable(pRec->r, z);      len = strlen(z);      pRec->z = 0;      pRec->flags = MEM_Real;      pRec->n = len+1;      nByte += pRec->n+1;    }else{      nByte += pRec->n+1;    }  }  if( nByte+sizeof(u32)>MAX_BYTES_PER_ROW ){    rc = SQLITE_TOOBIG;    goto abort_due_to_error;  }  if( addRowid ) nByte += sizeof(u32);  if( nByte<=NBFS ){    zNewKey = zTemp;  }else{    zNewKey = sqliteMallocRaw( nByte );    if( zNewKey==0 ) goto no_mem;  }  j = 0;  pRec = &pTos[1-nField];  for(i=0; i<nField; i++, pRec++){    if( pRec->flags & MEM_Null ){      zNewKey[j++] = 'a';      zNewKey[j++] = 0;    }else if( pRec->flags==MEM_Real ){      zNewKey[j++] = 'b';      memcpy(&zNewKey[j], pRec->zShort, pRec->n);      j += pRec->n;    }else{      assert( pRec->flags & MEM_Str );      zNewKey[j++] = 'c';      memcpy(&zNewKey[j], pRec->z, pRec->n);      j += pRec->n;    }  }  if( addRowid ){    u32 iKey;    pRec = &pTos[-nField];    assert( pRec>=p->aStack );    Integerify(pRec);    iKey = intToKey(pRec->i);    memcpy(&zNewKey[j], &iKey, sizeof(u32));    popStack(&pTos, nField+1);    if( pOp->p2 && containsNull ) pc = pOp->p2 - 1;  }else{    if( pOp->p2==0 ) popStack(&pTos, nField);  }  pTos++;  pTos->n = nByte;  if( nByte<=NBFS ){    assert( zNewKey==zTemp );    pTos->z = pTos->zShort;    memcpy(pTos->zShort, zTemp, nByte);    pTos->flags = MEM_Str | MEM_Short;  }else{    pTos->z = zNewKey;    pTos->flags = MEM_Str | MEM_Dyn;  }  break;}/* Opcode: IncrKey * * ***** The top of the stack should contain an index key generated by** The MakeKey opcode.  This routine increases the least significant** byte of that key by one.  This is used so that the MoveTo opcode** will move to the first entry greater than the key rather than to** the key itself.*/case OP_IncrKey: {  assert( pTos>=p->aStack );  /* The IncrKey opcode is only applied to keys generated by  ** MakeKey or MakeIdxKey and the results of those operands  ** are always dynamic strings or zShort[] strings.  So we  ** are always free to modify the string in place.  */  assert( pTos->flags & (MEM_Dyn|MEM_Short) );  pTos->z[pTos->n-1]++;  break;}/* Opcode: Checkpoint P1 * ***** Begin a checkpoint.  A checkpoint is the beginning of a operation that** is part of a larger transaction but which might need to be rolled back** itself without effecting the containing transaction.  A checkpoint will** be automatically committed or rollback when the VDBE halts.**** The checkpoint is begun on the database file with index P1.  The main** database file has an index of 0 and the file used for temporary tables** has an index of 1.*/case OP_Checkpoint: {  int i = pOp->p1;  if( i>=0 && i<db->nDb && db->aDb[i].pBt && db->aDb[i].inTrans==1 ){    rc = sqliteBtreeBeginCkpt(db->aDb[i].pBt);    if( rc==SQLITE_OK ) db->aDb[i].inTrans = 2;  }  break;}/* Opcode: Transaction P1 * ***** Begin a transaction.  The transaction ends when a Commit or Rollback** opcode is encountered.  Depending on the ON CONFLICT setting, the** transaction might also be rolled back if an error is encountered.**** P1 is the index of the database file on which the transaction is** started.  Index 0 is the main database file and index 1 is the** file used for temporary tables.**** A write lock is obtained on the database file when a transaction is** started.  No other process can read or write the file while the** transaction is underway.  Starting a transaction also creates a** rollback journal.  A transaction must be started before any changes** can be made to the database.*/case OP_Transaction: {  int busy = 1;  int i = pOp->p1;  assert( i>=0 && i<db->nDb );  if( db->aDb[i].inTrans ) break;  while( db->aDb[i].pBt!=0 && busy ){    rc = sqliteBtreeBeginTrans(db->aDb[i].pBt);    switch( rc ){      case SQLITE_BUSY: {        if( db->xBusyCallback==0 ){          p->pc = pc;          p->undoTransOnError = 1;          p->rc = SQLITE_BUSY;          p->pTos = pTos;          return SQLITE_BUSY;        }else if( (*db->xBusyCallback)(db->pBusyArg, "", busy++)==0 ){          sqliteSetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0);          busy = 0;        }        break;      }      case SQLITE_READONLY: {        rc = SQLITE_OK;        /* Fall thru into the next case */      }      case SQLITE_OK: {        p->inTempTrans = 0;        busy = 0;        break;      }      default: {        goto abort_due_to_error;      }    }  }  db->aDb[i].inTrans = 1;  p->undoTransOnError = 1;  break;}/* Opcode: Commit * * ***** Cause all modifications to the database that have been made since the** last Transaction to actually take effect.  No additional modifications** are allowed until another transaction is started.  The Commit instruction** deletes the journal file and releases the write lock on the database.** A read lock continues to be held if there are still cursors open.*/case OP_Commit: {  int i;  if( db->xCommitCallback!=0 ){    if( sqliteSafetyOff(db) ) goto abort_due_to_misuse;     if( db->xCommitCallback(db->pCommitArg)!=0 ){      rc = SQLITE_CONSTRAINT;    }    if( sqliteSafetyOn(db) ) goto abort_due_to_misuse;  }  for(i=0; rc==SQLITE_OK && i<db->nDb; i++){    if( db->aDb[i].inTrans ){      rc = sqliteBtreeCommit(db->aDb[i].pBt);      db->aDb[i].inTrans = 0;    }  }  if( rc==SQLITE_OK ){    sqliteCommitInternalChanges(db);  }else{    sqliteRollbackAll(db);  }  break;}/* Opcode: Rollback P1 * ***** Cause all modifications to the database that have been made since the** last Transaction to be undone. The database is restored to its state** before the Transaction opcode was executed.  No additional modifications** are allowed until another transaction is started.**** P1 is the index of the database file that is committed.  An index of 0** is used for the main database and an index of 1 is used for the file used** to hold temporary tables.**** This instruction automatically closes all cursors and releases both** the read and write locks on the indicated database.*/case OP_Rollback: {  sqliteRollbackAll(db);  break;}/* Opcode: ReadCookie P1 P2 ***** Read cookie number P2 from database P1 and push it onto the stack.** P2==0 is the schema version.  P2==1 is the database format.** P2==2 is the recommended pager cache size, and so forth.  P1==0 is** the main database file and P1==1 is the database file used to store** temporary tables.**** There must be a read-lock on the database (either a transaction** must be started or there must be an open cursor) before** executing this instruction.*/case OP_ReadCookie: {  int aMeta[SQLITE_N_BTREE_META];  assert( pOp->p2<SQLITE_N_BTREE_META );  assert( pOp->p1>=0 && pOp->p1<db->nDb );  assert( db->aDb[pOp->p1].pBt!=0 );  rc = sqliteBtreeGetMeta(db->aDb[pOp->p1].pBt, aMeta);  pTos++;  pTos->i = aMeta[1+pOp->p2];  pTos->flags = MEM_Int;  break;}/* Opcode: SetCookie P1 P2 ***** Write the top of the stack into cookie number P2 of database P1.** P2==0 is the schema version.  P2==1 is the database format.** P2==2 is the recommended pager cache size, and so forth.  P1==0 is** the main database file and P1==1 is the database file used to store** temporary tables.**** A transaction must be started before executing this opcode.*/case OP_SetCookie: {  int aMeta[SQLITE_N_BTREE_META];  assert( pOp->p2<SQLITE_N_BTREE_META );  assert( pOp->p1>=0 && pOp->p1<db->nDb );  assert( db->aDb[pOp->p1].pBt!=0 );  assert( pTos>=p->aStack );  Integerify(pTos)  rc = sqliteBtreeGetMeta(db->aDb[pOp->p1].pBt, aMeta);  if( rc==SQLITE_OK ){    aMeta[1+pOp->p2] = pTos->i;    rc = sqliteBtreeUpdateMeta(db->aDb[pOp->p1].pBt, aMeta);  }  Release(pTos);  pTos--;  break;}/* Opcode: VerifyCookie P1 P2 ***** Check the value of global database parameter number 0 (the** schema version) and make sure it is equal to P2.  ** P1 is the database number which is 0 for the main database file** and 1 for the file holding temporary tables and some higher number** for auxiliary databases.**** The cookie changes its value whenever the database schema changes.** This operation is used to detect when that the cookie has changed** and that the current process needs to reread the schema.**** Either a transaction needs to have been started or an OP_Open needs** to be executed (to establish a read lock) before this opcode is** invoked.*/case OP_VerifyCookie: {  int aMeta[SQLITE_N_BTREE_META];  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", (char*)0);    rc = SQLITE_SCHEMA;  }  break;}/* Opcode: OpenRead P1 P2 P3**** Open a read-only cursor for the database table whose root page is** P2 in a database file.  The database file is determined by an ** integer from the top of the stack.  0 means the main database and** 1 means the database used for temporary tables.  Give the new ** cursor an identifier of P1.  The P1 values need not be contiguous** but all P1 values should be small integers.  It is an error for** P1 to be negative.**** If P2==0 then take the root page number from the next of the stack.**** There will be a read lock on the database whenever there is an** open cursor.  If the database was unlocked prior to this instruction** then a read lock is acquired as part of this instruction.  A read** lock allows other processes to read the database but prohibits** any other process from modifying the database.  The read lock is** released when all cursors are closed.  If this instruction attempts** to get a read lock but fails, the script terminates with an** SQLITE_BUSY error code.**** The P3 value is the name of the table or index being opened.** The P3 value is not actually used by this opcode and may be** omitted.  But the code generator usually inserts the index or** table name into P3 to make the code easier to read.**** See also OpenWrite.*//* Opcode: OpenWrite P1 P2 P3**** Open a read/write cursor named P1 on the table or index whose root** page is P2.  If P2==0 then take the root page number from the stack.**** The P3 value is the name of the table or index being opened.** The P3 value is not actually used by this opcode and may be** omitted.  But the code generator usually inserts the index or** table name into P3 to make the code easier to read.**** This instruction works just like OpenRead except that it opens the cursor** in read/write mode.  For a given table, there can be one or more read-only** cursors or a single read/write cursor but not both.**** See also OpenRead.*/case OP_OpenRead:case OP_OpenWrite: {  int busy = 0;  int i = pOp->p1;  int p2 = pOp->p2;  int wrFlag;  Btree *pX;  int iDb;    assert( pTos>=p->aStack );  Integerify(pTos);  iDb = pTos->i;  pTos--;  assert( iDb>=0 && iDb<db->nDb );  pX = db->aDb[iDb].pBt;  assert( pX!=0 );  wrFlag = pOp->opcode==OP_OpenWrite;  if( p2<=0 ){    assert( pTos>=p->aStack );    Integerify(pTos);    p2 = pTos->i;    pTos--;    if( p2<2 ){      sqliteSetString(&p->zErrMsg, "root page number less than 2", (char*)0);      rc = SQLITE_INTERNAL;      break;    }  }  assert( i>=0 );  if( expandCursorArraySize(p, i) ) goto no_mem;  sqliteVdbeCleanupCursor(&p->aCsr[i]);  memset(&p->aCsr[i], 0, sizeof(Cursor));  p->aCsr[i].nullRow = 1;  if( pX==0 ) break;  do{    rc = sqliteBtreeCursor(pX, p2, wrFlag, &p->aCsr[i].pCursor);    switch( rc ){      case SQLITE_BUSY: {        if( db->xBusyCallback==0 ){          p->pc = pc;          p->rc = SQLITE_BUSY;          p->pTos = &pTos[1 + (pOp->p2<=0)]; /* Operands must remain on stack */          return SQLITE_BUSY;        }else if( (*db->xBusyCallback)(db->pBusyArg, pOp->p3, ++busy)==0 ){          sqliteSetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0);          busy = 0;        }        break;      }      case SQLITE_OK: {        busy = 0;        break;      }      default: {        goto abort_due_to_error;      }    }  }while( busy );  break;}/* Opcode: OpenTemp P1 P2 ***** Open a new cursor to a transient table.** The transient cursor is always opened read/write even if ** the main database is read-only.  The transient table is deleted** automatically when the cursor is closed.**** The cursor points to a BTree table if P2==0 and to a BTree index** if P2==1.  A BTree table must have an integer key and can have arbitrary** data.  A BTree index has no data but can have an arbitrary key.**** This opcode is used for tables that exist for the duration of a single** SQL statement only.  Tables created using CREATE TEMPORARY TABLE** are opened using OP_OpenRead or OP_OpenWrite.  "Temporary" in the** context of this opcode means for the duration of a single SQL statement** whereas "Temporary" in the context of CREATE TABLE means for the duration** of the connection to the database.  Same word; different meanings.*/case OP_OpenTemp: {  int i = pOp->p1;  Cursor *pCx;  assert( i>=0 );  if( expandCursorArraySize(p, i) ) goto no_mem;  pCx = &p->aCsr[i];  sqliteVdbeCleanupCursor(pCx);  memset(pCx, 0, sizeof(*pCx));  pCx->nullRow = 1;  rc = sqliteBtreeFactory(db, 0, 1, TEMP_PAGES, &pCx->pBt);  if( rc==SQLITE_OK ){    rc = sqliteBtreeBeginTrans(pCx->pBt);  }  if( rc==SQLITE_OK ){    if( pOp->p2 ){      int pgno;      rc = sqliteBtreeCreateIndex(pCx->pBt, &pgno);      if( rc==SQLITE_OK ){        rc = sqliteBtreeCursor(pCx->pBt, pgno, 1, &pCx->pCursor);      }    }else{      rc = sqliteBtreeCursor(pCx->pBt, 2, 1, &pCx->pCursor);    }  }  break;}/* Opcode: OpenPseudo P1 * ***** Open a new cursor that points to a fake table that contains a single** row of data.  Any attempt to write a second row of data causes the** first row to be deleted.  All data is deleted when the cursor is** closed.**** A pseudo-table created by this opcode is useful for holding the** NEW or OLD tables in a trigger.*/case OP_OpenPseudo: {  int i = pOp->p1;  Cursor *pCx;  assert( i>=0 );  if( expandCursorArraySize(p, i) ) goto no_mem;  pCx = &p->aCsr[i];  sqliteVdbeCleanupCursor(pCx);  memset(pCx, 0, sizeof(*pCx));  pCx->nullRow = 1;  pCx->pseudoTable = 1;  break;}/* Opcode: Close P1 * ***** Close a cursor previously opened as P1.  If P1 is not** currently open, this instruction is a no-op.*/case OP_Close: {  int i = pOp->p1;  if( i>=0 && i<p->nCursor ){    sqliteVdbeCleanupCursor(&p->aCsr[i]);  }  break;}/* Opcode: MoveTo P1 P2 ***** Pop the top of the stack and use its value as a key.  Reposition** cursor P1 so that it points to an entry with a matching key.  If** the table contains no record with a matching key, then the cursor** is left pointing at the first record that is greater than the key.** If there are no records greater than the key and P2 is not zero,** then an immediate jump to P2 is made.**** See also: Found, NotFound, Distinct, MoveLt*//* Opcode: MoveLt P1 P2 ***** Pop the top of the stack and use its value as a key.  Reposition** cursor P1 so that it points to the entry with the largest key that is** less than the key popped from the stack.** If there are no records less than than the key and P2** is not zero then an immediate jump to P2 is made.**** See also: MoveTo*/case OP_MoveLt:case OP_MoveTo: {  int i = pOp->p1;  Cursor *pC;  assert( pTos>=p->aStack );  assert( i>=0 && i<p->nCursor );  pC = &p->aCsr[i];  if( pC->pCursor!=0 ){    int res, oc;    pC->nullRow = 0;    if( pTos->flags & MEM_Int ){      int iKey = intToKey(pTos->i);      if( pOp->p2==0 && pOp->opcode==OP_MoveTo ){        pC->movetoTarget = iKey;        pC->deferredMoveto = 1;        Release(pTos);        pTos--;        break;      }      sqliteBtreeMoveto(pC->pCursor, (char*)&iKey, sizeof(int), &res);      pC->lastRecno = pTos->i;      pC->recnoIsValid = res==0;    }else{      Stringify(pTos);      sqliteBtreeMoveto(pC->pCursor, pTos->z, pTos->n, &res);      pC->recnoIsValid = 0;    }    pC->deferredMoveto = 0;    sqlite_search_count++;    oc = pOp->opcode;    if( oc==OP_MoveTo && res<0 ){      sqliteBtreeNext(pC->pCursor, &res);      pC->recnoIsValid = 0;      if( res && pOp->p2>0 ){        pc = pOp->p2 - 1;      }    }else if( oc==OP_MoveLt ){      if( res>=0 ){        sqliteBtreePrevious(pC->pCursor, &res);        pC->recnoIsValid = 0;      }else{        /* res might be negative because the table is empty.  Check to        ** see if this is the case.        */        int keysize;        res = sqliteBtreeKeySize(pC->pCursor,&keysize)!=0 || keysize==0;      }      if( res && pOp->p2>0 ){        pc = pOp->p2 - 1;      }    }  }  Release(pTos);  pTos--;  break;}/* Opcode: Distinct P1 P2 ***** Use the top of the stack as a string key.  If a record with that key does** not exist in the table of cursor P1, then jump to P2.  If the record** does already exist, then fall thru.  The cursor is left pointing** at the record if it exists. The key is not popped from the stack.**** This operation is similar to NotFound except that this operation** does not pop the key from the stack.**** See also: Found, NotFound, MoveTo, IsUnique, NotExists*//* Opcode: Found P1 P2 ***** Use the top of the stack as a string key.  If a record with that key** does exist in table of P1, then jump to P2.  If the record** does not exist, then fall thru.  The cursor is left pointing** to the record if it exists.  The key is popped from the stack.**** See also: Distinct, NotFound, MoveTo, IsUnique, NotExists*//* Opcode: NotFound P1 P2 ***** Use the top of the stack as a string key.  If a record with that key** does not exist in table of P1, then jump to P2.  If the record** does exist, then fall thru.  The cursor is left pointing to the** record if it exists.  The key is popped from the stack.**** The difference between this operation and Distinct is that** Distinct does not pop the key from the stack.**** See also: Distinct, Found, MoveTo, NotExists, IsUnique*/case OP_Distinct:case OP_NotFound:case OP_Found: {  int i = pOp->p1;  int alreadyExists = 0;  Cursor *pC;  assert( pTos>=p->aStack );  assert( i>=0 && i<p->nCursor );  if( (pC = &p->aCsr[i])->pCursor!=0 ){    int res, rx;    Stringify(pTos);    rx = sqliteBtreeMoveto(pC->pCursor, pTos->z, pTos->n, &res);    alreadyExists = rx==SQLITE_OK && res==0;    pC->deferredMoveto = 0;  }  if( pOp->opcode==OP_Found ){    if( alreadyExists ) pc = pOp->p2 - 1;  }else{    if( !alreadyExists ) pc = pOp->p2 - 1;  }  if( pOp->opcode!=OP_Distinct ){    Release(pTos);    pTos--;  }  break;}/* Opcode: IsUnique P1 P2 ***** The top of the stack is an integer record number.  Call this** record number R.  The next on the stack is an index key created** using MakeIdxKey.  Call it K.  This instruction pops R from the** stack but it leaves K unchanged.**** P1 is an index.  So all but the last four bytes of K are an** index string.  The last four bytes of K are a record number.**** This instruction asks if there is an entry in P1 where the** index string matches K but the record number is different** from R.  If there is no such entry, then there is an immediate** jump to P2.  If any entry does exist where the index string** matches K but the record number is not R, then the record** number for that entry is pushed onto the stack and control** falls through to the next instruction.**** See also: Distinct, NotFound, NotExists, Found*/case OP_IsUnique: {  int i = pOp->p1;  Mem *pNos = &pTos[-1];  BtCursor *pCrsr;  int R;  /* Pop the value R off the top of the stack  */  assert( pNos>=p->aStack );  Integerify(pTos);  R = pTos->i;  pTos--;  assert( i>=0 && i<=p->nCursor );  if( (pCrsr = p->aCsr[i].pCursor)!=0 ){    int res, rc;    int v;         /* The record number on the P1 entry that matches K */    char *zKey;    /* The value of K */    int nKey;      /* Number of bytes in K */    /* Make sure K is a string and make zKey point to K    */    Stringify(pNos);    zKey = pNos->z;    nKey = pNos->n;    assert( nKey >= 4 );    /* Search for an entry in P1 where all but the last four bytes match K.    ** If there is no such entry, jump immediately to P2.    */    assert( p->aCsr[i].deferredMoveto==0 );    rc = sqliteBtreeMoveto(pCrsr, zKey, nKey-4, &res);    if( rc!=SQLITE_OK ) goto abort_due_to_error;    if( res<0 ){      rc = sqliteBtreeNext(pCrsr, &res);      if( res ){        pc = pOp->p2 - 1;        break;      }    }    rc = sqliteBtreeKeyCompare(pCrsr, zKey, nKey-4, 4, &res);    if( rc!=SQLITE_OK ) goto abort_due_to_error;    if( res>0 ){      pc = pOp->p2 - 1;      break;    }    /* At this point, pCrsr is pointing to an entry in P1 where all but    ** the last for bytes of the key match K.  Check to see if the last    ** four bytes of the key are different from R.  If the last four    ** bytes equal R then jump immediately to P2.    */    sqliteBtreeKey(pCrsr, nKey - 4, 4, (char*)&v);    v = keyToInt(v);    if( v==R ){      pc = pOp->p2 - 1;      break;    }    /* The last four bytes of the key are different from R.  Convert the    ** last four bytes of the key into an integer and push it onto the    ** stack.  (These bytes are the record number of an entry that    ** violates a UNIQUE constraint.)    */    pTos++;    pTos->i = v;    pTos->flags = MEM_Int;  }  break;}/* Opcode: NotExists P1 P2 ***** Use the top of the stack as a integer key.  If a record with that key** does not exist in table of P1, then jump to P2.  If the record** does exist, then fall thru.  The cursor is left pointing to the** record if it exists.  The integer key is popped from the stack.**** The difference between this operation and NotFound is that this** operation assumes the key is an integer and NotFound assumes it** is a string.**** See also: Distinct, Found, MoveTo, NotFound, IsUnique*/case OP_NotExists: {  int i = pOp->p1;  BtCursor *pCrsr;  assert( pTos>=p->aStack );  assert( i>=0 && i<p->nCursor );  if( (pCrsr = p->aCsr[i].pCursor)!=0 ){    int res, rx, iKey;    assert( pTos->flags & MEM_Int );    iKey = intToKey(pTos->i);    rx = sqliteBtreeMoveto(pCrsr, (char*)&iKey, sizeof(int), &res);    p->aCsr[i].lastRecno = pTos->i;    p->aCsr[i].recnoIsValid = res==0;    p->aCsr[i].nullRow = 0;    if( rx!=SQLITE_OK || res!=0 ){      pc = pOp->p2 - 1;      p->aCsr[i].recnoIsValid = 0;    }  }  Release(pTos);  pTos--;  break;}/* Opcode: NewRecno P1 * ***** Get a new integer record number used as the key to a table.** The record number is not previously used as a key in the database** table that cursor P1 points to.  The new record number is pushed ** onto the stack.*/case OP_NewRecno: {  int i = pOp->p1;  int v = 0;  Cursor *pC;  assert( i>=0 && i<p->nCursor );  if( (pC = &p->aCsr[i])->pCursor==0 ){    v = 0;  }else{    /* The next rowid or record number (different terms for the same    ** thing) is obtained in a two-step algorithm.    **    ** First we attempt to find the largest existing rowid and add one    ** to that.  But if the largest existing rowid is already the maximum    ** positive integer, we have to fall through to the second    ** probabilistic algorithm    **    ** The second algorithm is to select a rowid at random and see if    ** it already exists in the table.  If it does not exist, we have    ** succeeded.  If the random rowid does exist, we select a new one    ** and try again, up to 1000 times.    **    ** For a table with less than 2 billion entries, the probability    ** of not finding a unused rowid is about 1.0e-300.  This is a     ** non-zero probability, but it is still vanishingly small and should    ** never cause a problem.  You are much, much more likely to have a    ** hardware failure than for this algorithm to fail.    **    ** The analysis in the previous paragraph assumes that you have a good    ** source of random numbers.  Is a library function like lrand48()    ** good enough?  Maybe. Maybe not. It's hard to know whether there    ** might be subtle bugs is some implementations of lrand48() that    ** could cause problems. To avoid uncertainty, SQLite uses its own     ** random number generator based on the RC4 algorithm.    **    ** To promote locality of reference for repetitive inserts, the    ** first few attempts at chosing a random rowid pick values just a little    ** larger than the previous rowid.  This has been shown experimentally    ** to double the speed of the COPY operation.    */    int res, rx, cnt, x;    cnt = 0;    if( !pC->useRandomRowid ){      if( pC->nextRowidValid ){        v = pC->nextRowid;      }else{        rx = sqliteBtreeLast(pC->pCursor, &res);        if( res ){          v = 1;        }else{          sqliteBtreeKey(pC->pCursor, 0, sizeof(v), (void*)&v);          v = keyToInt(v);          if( v==0x7fffffff ){            pC->useRandomRowid = 1;          }else{            v++;          }        }      }      if( v<0x7fffffff ){        pC->nextRowidValid = 1;        pC->nextRowid = v+1;      }else{        pC->nextRowidValid = 0;      }    }    if( pC->useRandomRowid ){      v = db->priorNewRowid;      cnt = 0;      do{        if( v==0 || cnt>2 ){          sqliteRandomness(sizeof(v), &v);          if( cnt<5 ) v &= 0xffffff;        }else{          unsigned char r;          sqliteRandomness(1, &r);          v += r + 1;        }        if( v==0 ) continue;        x = intToKey(v);        rx = sqliteBtreeMoveto(pC->pCursor, &x, sizeof(int), &res);        cnt++;      }while( cnt<1000 && rx==SQLITE_OK && res==0 );      db->priorNewRowid = v;      if( rx==SQLITE_OK && res==0 ){        rc = SQLITE_FULL;        goto abort_due_to_error;      }    }    pC->recnoIsValid = 0;    pC->deferredMoveto = 0;  }  pTos++;  pTos->i = v;  pTos->flags = MEM_Int;  break;}/* Opcode: PutIntKey P1 P2 ***** Write an entry into the table of cursor P1.  A new entry is** created if it doesn't already exist or the data for an existing** entry is overwritten.  The data is the value on the top of the** stack.  The key is the next value down on the stack.  The key must** be an integer.  The stack is popped twice by this instruction.**** If the OPFLAG_NCHANGE flag of P2 is set, then the row change count is** incremented (otherwise not).  If the OPFLAG_CSCHANGE flag is set,** then the current statement change count is incremented (otherwise not).** If the OPFLAG_LASTROWID flag of P2 is set, then rowid is** stored for subsequent return by the sqlite_last_insert_rowid() function** (otherwise it's unmodified).*//* Opcode: PutStrKey P1 * ***** Write an entry into the table of cursor P1.  A new entry is** created if it doesn't already exist or the data for an existing** entry is overwritten.  The data is the value on the top of the** stack.  The key is the next value down on the stack.  The key must** be a string.  The stack is popped twice by this instruction.**** P1 may not be a pseudo-table opened using the OpenPseudo opcode.*/case OP_PutIntKey:case OP_PutStrKey: {  Mem *pNos = &pTos[-1];  int i = pOp->p1;  Cursor *pC;  assert( pNos>=p->aStack );  assert( i>=0 && i<p->nCursor );  if( ((pC = &p->aCsr[i])->pCursor!=0 || pC->pseudoTable) ){    char *zKey;    int nKey, iKey;    if( pOp->opcode==OP_PutStrKey ){      Stringify(pNos);      nKey = pNos->n;      zKey = pNos->z;    }else{      assert( pNos->flags & MEM_Int );      nKey = sizeof(int);      iKey = intToKey(pNos->i);      zKey = (char*)&iKey;      if( pOp->p2 & OPFLAG_NCHANGE ) db->nChange++;      if( pOp->p2 & OPFLAG_LASTROWID ) db->lastRowid = pNos->i;      if( pOp->p2 & OPFLAG_CSCHANGE ) db->csChange++;      if( pC->nextRowidValid && pTos->i>=pC->nextRowid ){        pC->nextRowidValid = 0;      }    }    if( pTos->flags & MEM_Null ){      pTos->z = 0;      pTos->n = 0;    }else{      assert( pTos->flags & MEM_Str );    }    if( pC->pseudoTable ){      /* PutStrKey does not work for pseudo-tables.      ** The following assert makes sure we are not trying to use      ** PutStrKey on a pseudo-table      */      assert( pOp->opcode==OP_PutIntKey );      sqliteFree(pC->pData);      pC->iKey = iKey;      pC->nData = pTos->n;      if( pTos->flags & MEM_Dyn ){        pC->pData = pTos->z;        pTos->flags = MEM_Null;      }else{        pC->pData = sqliteMallocRaw( pC->nData );        if( pC->pData ){          memcpy(pC->pData, pTos->z, pC->nData);        }      }      pC->nullRow = 0;    }else{      rc = sqliteBtreeInsert(pC->pCursor, zKey, nKey, pTos->z, pTos->n);    }    pC->recnoIsValid = 0;    pC->deferredMoveto = 0;  }  popStack(&pTos, 2);  break;}/* Opcode: Delete P1 P2 ***** Delete the record at which the P1 cursor is currently pointing.**** The cursor will be left pointing at either the next or the previous** record in the table. If it is left pointing at the next record, then** the next Next instruction will be a no-op.  Hence it is OK to delete** a record from within an Next loop.**** If the OPFLAG_NCHANGE flag of P2 is set, then the row change count is** incremented (otherwise not).  If OPFLAG_CSCHANGE flag is set,** then the current statement change count is incremented (otherwise not).**** If P1 is a pseudo-table, then this instruction is a no-op.*/case OP_Delete: {  int i = pOp->p1;  Cursor *pC;  assert( i>=0 && i<p->nCursor );  pC = &p->aCsr[i];  if( pC->pCursor!=0 ){    sqliteVdbeCursorMoveto(pC);    rc = sqliteBtreeDelete(pC->pCursor);    pC->nextRowidValid = 0;  }  if( pOp->p2 & OPFLAG_NCHANGE ) db->nChange++;  if( pOp->p2 & OPFLAG_CSCHANGE ) db->csChange++;  break;}/* Opcode: SetCounts * * ***** Called at end of statement.  Updates lsChange (last statement change count)** and resets csChange (current statement change count) to 0.*/case OP_SetCounts: {  db->lsChange=db->csChange;  db->csChange=0;  break;}/* Opcode: KeyAsData P1 P2 ***** Turn the key-as-data mode for cursor P1 either on (if P2==1) or** off (if P2==0).  In key-as-data mode, the OP_Column opcode pulls** data off of the key rather than the data.  This is used for** processing compound selects.*/case OP_KeyAsData: {  int i = pOp->p1;  assert( i>=0 && i<p->nCursor );  p->aCsr[i].keyAsData = pOp->p2;  break;}/* Opcode: RowData P1 * ***** Push onto the stack the complete row data for cursor P1.** There is no interpretation of the data.  It is just copied** onto the stack exactly as it is found in the database file.**** If the cursor is not pointing to a valid row, a NULL is pushed** onto the stack.*//* Opcode: RowKey P1 * ***** Push onto the stack the complete row key for cursor P1.** There is no interpretation of the key.  It is just copied** onto the stack exactly as it is found in the database file.**** If the cursor is not pointing to a valid row, a NULL is pushed** onto the stack.*/case OP_RowKey:case OP_RowData: {  int i = pOp->p1;  Cursor *pC;  int n;  pTos++;  assert( i>=0 && i<p->nCursor );  pC = &p->aCsr[i];  if( pC->nullRow ){    pTos->flags = MEM_Null;  }else if( pC->pCursor!=0 ){    BtCursor *pCrsr = pC->pCursor;    sqliteVdbeCursorMoveto(pC);    if( pC->nullRow ){      pTos->flags = MEM_Null;      break;    }else if( pC->keyAsData || pOp->opcode==OP_RowKey ){      sqliteBtreeKeySize(pCrsr, &n);    }else{      sqliteBtreeDataSize(pCrsr, &n);    }    pTos->n = n;    if( n<=NBFS ){      pTos->flags = MEM_Str | MEM_Short;      pTos->z = pTos->zShort;    }else{      char *z = sqliteMallocRaw( n );      if( z==0 ) goto no_mem;      pTos->flags = MEM_Str | MEM_Dyn;      pTos->z = z;    }    if( pC->keyAsData || pOp->opcode==OP_RowKey ){      sqliteBtreeKey(pCrsr, 0, n, pTos->z);    }else{      sqliteBtreeData(pCrsr, 0, n, pTos->z);    }  }else if( pC->pseudoTable ){    pTos->n = pC->nData;    pTos->z = pC->pData;    pTos->flags = MEM_Str|MEM_Ephem;  }else{    pTos->flags = MEM_Null;  }  break;}/* Opcode: Column P1 P2 ***** Interpret the data that cursor P1 points to as** a structure built using the MakeRecord instruction.** (See the MakeRecord opcode for additional information about** the format of the data.)** Push onto the stack the value of the P2-th column contained** in the data.**** If the KeyAsData opcode has previously executed on this cursor,** then the field might be extracted from the key rather than the** data.**** If P1 is negative, then the record is stored on the stack rather** than in a table.  For P1==-1, the top of the stack is used.** For P1==-2, the next on the stack is used.  And so forth.  The** value pushed is always just a pointer into the record which is** stored further down on the stack.  The column value is not copied.*/case OP_Column: {  int amt, offset, end, payloadSize;  int i = pOp->p1;  int p2 = pOp->p2;  Cursor *pC;  char *zRec;  BtCursor *pCrsr;  int idxWidth;  unsigned char aHdr[10];  assert( i<p->nCursor );  pTos++;  if( i<0 ){    assert( &pTos[i]>=p->aStack );    assert( pTos[i].flags & MEM_Str );    zRec = pTos[i].z;    payloadSize = pTos[i].n;  }else if( (pC = &p->aCsr[i])->pCursor!=0 ){    sqliteVdbeCursorMoveto(pC);    zRec = 0;    pCrsr = pC->pCursor;    if( pC->nullRow ){      payloadSize = 0;    }else if( pC->keyAsData ){      sqliteBtreeKeySize(pCrsr, &payloadSize);    }else{      sqliteBtreeDataSize(pCrsr, &payloadSize);    }  }else if( pC->pseudoTable ){    payloadSize = pC->nData;    zRec = pC->pData;    assert( payloadSize==0 || zRec!=0 );  }else{    payloadSize = 0;  }  /* Figure out how many bytes in the column data and where the column  ** data begins.  */  if( payloadSize==0 ){    pTos->flags = MEM_Null;    break;  }else if( payloadSize<256 ){    idxWidth = 1;  }else if( payloadSize<65536 ){    idxWidth = 2;  }else{    idxWidth = 3;  }  /* Figure out where the requested column is stored and how big it is.  */  if( payloadSize < idxWidth*(p2+1) ){    rc = SQLITE_CORRUPT;    goto abort_due_to_error;  }  if( zRec ){    memcpy(aHdr, &zRec[idxWidth*p2], idxWidth*2);  }else if( pC->keyAsData ){    sqliteBtreeKey(pCrsr, idxWidth*p2, idxWidth*2, (char*)aHdr);  }else{    sqliteBtreeData(pCrsr, idxWidth*p2, idxWidth*2, (char*)aHdr);  }  offset = aHdr[0];  end = aHdr[idxWidth];  if( idxWidth>1 ){    offset |= aHdr[1]<<8;    end |= aHdr[idxWidth+1]<<8;    if( idxWidth>2 ){      offset |= aHdr[2]<<16;      end |= aHdr[idxWidth+2]<<16;    }  }  amt = end - offset;  if( amt<0 || offset<0 || end>payloadSize ){    rc = SQLITE_CORRUPT;    goto abort_due_to_error;  }  /* amt and offset now hold the offset to the start of data and the  ** amount of data.  Go get the data and put it on the stack.  */  pTos->n = amt;  if( amt==0 ){    pTos->flags = MEM_Null;  }else if( zRec ){    pTos->flags = MEM_Str | MEM_Ephem;    pTos->z = &zRec[offset];  }else{    if( amt<=NBFS ){      pTos->flags = MEM_Str | MEM_Short;      pTos->z = pTos->zShort;    }else{      char *z = sqliteMallocRaw( amt );      if( z==0 ) goto no_mem;      pTos->flags = MEM_Str | MEM_Dyn;      pTos->z = z;    }    if( pC->keyAsData ){      sqliteBtreeKey(pCrsr, offset, amt, pTos->z);    }else{      sqliteBtreeData(pCrsr, offset, amt, pTos->z);    }  }  break;}/* Opcode: Recno P1 * ***** Push onto the stack an integer which is the first 4 bytes of the** the key to the current entry in a sequential scan of the database** file P1.  The sequential scan should have been started using the ** Next opcode.*/case OP_Recno: {  int i = pOp->p1;  Cursor *pC;  int v;  assert( i>=0 && i<p->nCursor );  pC = &p->aCsr[i];  sqliteVdbeCursorMoveto(pC);  pTos++;  if( pC->recnoIsValid ){    v = pC->lastRecno;  }else if( pC->pseudoTable ){    v = keyToInt(pC->iKey);  }else if( pC->nullRow || pC->pCursor==0 ){    pTos->flags = MEM_Null;    break;  }else{    assert( pC->pCursor!=0 );    sqliteBtreeKey(pC->pCursor, 0, sizeof(u32), (char*)&v);    v = keyToInt(v);  }  pTos->i = v;  pTos->flags = MEM_Int;  break;}/* Opcode: FullKey P1 * ***** Extract the complete key from the record that cursor P1 is currently** pointing to and push the key onto the stack as a string.**** Compare this opcode to Recno.  The Recno opcode extracts the first** 4 bytes of the key and pushes those bytes onto the stack as an** integer.  This instruction pushes the entire key as a string.**** This opcode may not be used on a pseudo-table.*/case OP_FullKey: {  int i = pOp->p1;  BtCursor *pCrsr;  assert( p->aCsr[i].keyAsData );  assert( !p->aCsr[i].pseudoTable );  assert( i>=0 && i<p->nCursor );  pTos++;  if( (pCrsr = p->aCsr[i].pCursor)!=0 ){    int amt;    char *z;    sqliteVdbeCursorMoveto(&p->aCsr[i]);    sqliteBtreeKeySize(pCrsr, &amt);    if( amt<=0 ){      rc = SQLITE_CORRUPT;      goto abort_due_to_error;    }    if( amt>NBFS ){      z = sqliteMallocRaw( amt );      if( z==0 ) goto no_mem;      pTos->flags = MEM_Str | MEM_Dyn;    }else{      z = pTos->zShort;      pTos->flags = MEM_Str | MEM_Short;    }    sqliteBtreeKey(pCrsr, 0, amt, z);    pTos->z = z;    pTos->n = amt;  }  break;}/* Opcode: NullRow P1 * ***** Move the cursor P1 to a null row.  Any OP_Column operations** that occur while the cursor is on the null row will always push ** a NULL onto the stack.*/case OP_NullRow: {  int i = pOp->p1;  assert( i>=0 && i<p->nCursor );  p->aCsr[i].nullRow = 1;  p->aCsr[i].recnoIsValid = 0;  break;}/* Opcode: Last P1 P2 ***** The next use of the Recno or Column or Next instruction for P1 ** will refer to the last entry in the database table or index.** If the table or index is empty and P2>0, then jump immediately to P2.** If P2 is 0 or if the table or index is not empty, fall through** to the following instruction.*/case OP_Last: {  int i = pOp->p1;  Cursor *pC;  BtCursor *pCrsr;  assert( i>=0 && i<p->nCursor );  pC = &p->aCsr[i];  if( (pCrsr = pC->pCursor)!=0 ){    int res;    rc = sqliteBtreeLast(pCrsr, &res);    pC->nullRow = res;    pC->deferredMoveto = 0;    if( res && pOp->p2>0 ){      pc = pOp->p2 - 1;    }  }else{    pC->nullRow = 0;  }  break;}/* Opcode: Rewind P1 P2 ***** The next use of the Recno or Column or Next instruction for P1 ** will refer to the first entry in the database table or index.** If the table or index is empty and P2>0, then jump immediately to P2.** If P2 is 0 or if the table or index is not empty, fall through** to the following instruction.*/case OP_Rewind: {  int i = pOp->p1;  Cursor *pC;  BtCursor *pCrsr;  assert( i>=0 && i<p->nCursor );  pC = &p->aCsr[i];  if( (pCrsr = pC->pCursor)!=0 ){    int res;    rc = sqliteBtreeFirst(pCrsr, &res);    pC->atFirst = res==0;    pC->nullRow = res;    pC->deferredMoveto = 0;    if( res && pOp->p2>0 ){      pc = pOp->p2 - 1;    }  }else{    pC->nullRow = 0;  }  break;}/* Opcode: Next P1 P2 ***** Advance cursor P1 so that it points to the next key/data pair in its** table or index.  If there are no more key/value pairs then fall through** to the following instruction.  But if the cursor advance was successful,** jump immediately to P2.**** See also: Prev*//* Opcode: Prev P1 P2 ***** Back up cursor P1 so that it points to the previous key/data pair in its** table or index.  If there is no previous key/value pairs then fall through** to the following instruction.  But if the cursor backup was successful,** jump immediately to P2.*/case OP_Prev:case OP_Next: {  Cursor *pC;  BtCursor *pCrsr;  CHECK_FOR_INTERRUPT;  assert( pOp->p1>=0 && pOp->p1<p->nCursor );  pC = &p->aCsr[pOp->p1];  if( (pCrsr = pC->pCursor)!=0 ){    int res;    if( pC->nullRow ){      res = 1;    }else{      assert( pC->deferredMoveto==0 );      rc = pOp->opcode==OP_Next ? sqliteBtreeNext(pCrsr, &res) :                                  sqliteBtreePrevious(pCrsr, &res);      pC->nullRow = res;    }    if( res==0 ){      pc = pOp->p2 - 1;      sqlite_search_count++;    }  }else{    pC->nullRow = 1;  }  pC->recnoIsValid = 0;  break;}/* Opcode: IdxPut P1 P2 P3**** The top of the stack holds a SQL index key made using the** MakeIdxKey instruction.  This opcode writes that key into the** index P1.  Data for the entry is nil.**** If P2==1, then the key must be unique.  If the key is not unique,** the program aborts with a SQLITE_CONSTRAINT error and the database** is rolled back.  If P3 is not null, then it becomes part of the** error message returned with the SQLITE_CONSTRAINT.*/case OP_IdxPut: {  int i = pOp->p1;  BtCursor *pCrsr;  assert( pTos>=p->aStack );  assert( i>=0 && i<p->nCursor );  assert( pTos->flags & MEM_Str );  if( (pCrsr = p->aCsr[i].pCursor)!=0 ){    int nKey = pTos->n;    const char *zKey = pTos->z;    if( pOp->p2 ){      int res, n;      assert( nKey >= 4 );      rc = sqliteBtreeMoveto(pCrsr, zKey, nKey-4, &res);      if( rc!=SQLITE_OK ) goto abort_due_to_error;      while( res!=0 ){        int c;        sqliteBtreeKeySize(pCrsr, &n);        if( n==nKey           && sqliteBtreeKeyCompare(pCrsr, zKey, nKey-4, 4, &c)==SQLITE_OK           && c==0        ){          rc = SQLITE_CONSTRAINT;          if( pOp->p3 && pOp->p3[0] ){            sqliteSetString(&p->zErrMsg, pOp->p3, (char*)0);          }          goto abort_due_to_error;        }        if( res<0 ){          sqliteBtreeNext(pCrsr, &res);          res = +1;        }else{          break;        }      }    }    rc = sqliteBtreeInsert(pCrsr, zKey, nKey, "", 0);    assert( p->aCsr[i].deferredMoveto==0 );  }  Release(pTos);  pTos--;  break;}/* Opcode: IdxDelete P1 * ***** The top of the stack is an index key built using the MakeIdxKey opcode.** This opcode removes that entry from the index.*/case OP_IdxDelete: {  int i = pOp->p1;  BtCursor *pCrsr;  assert( pTos>=p->aStack );  assert( pTos->flags & MEM_Str );  assert( i>=0 && i<p->nCursor );  if( (pCrsr = p->aCsr[i].pCursor)!=0 ){    int rx, res;    rx = sqliteBtreeMoveto(pCrsr, pTos->z, pTos->n, &res);    if( rx==SQLITE_OK && res==0 ){      rc = sqliteBtreeDelete(pCrsr);    }    assert( p->aCsr[i].deferredMoveto==0 );  }  Release(pTos);  pTos--;  break;}/* Opcode: IdxRecno P1 * ***** Push onto the stack an integer which is the last 4 bytes of the** the key to the current entry in index P1.  These 4 bytes should** be the record number of the table entry to which this index entry** points.**** See also: Recno, MakeIdxKey.*/case OP_IdxRecno: {  int i = pOp->p1;  BtCursor *pCrsr;  assert( i>=0 && i<p->nCursor );  pTos++;  if( (pCrsr = p->aCsr[i].pCursor)!=0 ){    int v;    int sz;    assert( p->aCsr[i].deferredMoveto==0 );    sqliteBtreeKeySize(pCrsr, &sz);    if( sz<sizeof(u32) ){      pTos->flags = MEM_Null;    }else{      sqliteBtreeKey(pCrsr, sz - sizeof(u32), sizeof(u32), (char*)&v);      v = keyToInt(v);      pTos->i = v;      pTos->flags = MEM_Int;    }  }else{    pTos->flags = MEM_Null;  }  break;}/* Opcode: IdxGT P1 P2 ***** Compare the top of the stack against the key on the index entry that** cursor P1 is currently pointing to.  Ignore the last 4 bytes of the** index entry.  If the index entry is greater than the top of the stack** then jump to P2.  Otherwise fall through to the next instruction.** In either case, the stack is popped once.*//* Opcode: IdxGE P1 P2 ***** Compare the top of the stack against the key on the index entry that** cursor P1 is currently pointing to.  Ignore the last 4 bytes of the** index entry.  If the index entry is greater than or equal to ** the top of the stack** then jump to P2.  Otherwise fall through to the next instruction.** In either case, the stack is popped once.*//* Opcode: IdxLT P1 P2 ***** Compare the top of the stack against the key on the index entry that** cursor P1 is currently pointing to.  Ignore the last 4 bytes of the** index entry.  If the index entry is less than the top of the stack** then jump to P2.  Otherwise fall through to the next instruction.** In either case, the stack is popped once.*/case OP_IdxLT:case OP_IdxGT:case OP_IdxGE: {  int i= pOp->p1;  BtCursor *pCrsr;  assert( i>=0 && i<p->nCursor );  assert( pTos>=p->aStack );  if( (pCrsr = p->aCsr[i].pCursor)!=0 ){    int res, rc;     Stringify(pTos);    assert( p->aCsr[i].deferredMoveto==0 );    rc = sqliteBtreeKeyCompare(pCrsr, pTos->z, pTos->n, 4, &res);    if( rc!=SQLITE_OK ){      break;    }    if( pOp->opcode==OP_IdxLT ){      res = -res;    }else if( pOp->opcode==OP_IdxGE ){      res++;    }    if( res>0 ){      pc = pOp->p2 - 1 ;    }  }  Release(pTos);  pTos--;  break;}/* Opcode: IdxIsNull P1 P2 ***** The top of the stack contains an index entry such as might be generated** by the MakeIdxKey opcode.  This routine looks at the first P1 fields of** that key.  If any of the first P1 fields are NULL, then a jump is made** to address P2.  Otherwise we fall straight through.**** The index entry is always popped from the stack.*/case OP_IdxIsNull: {  int i = pOp->p1;  int k, n;  const char *z;  assert( pTos>=p->aStack );  assert( pTos->flags & MEM_Str );  z = pTos->z;  n = pTos->n;  for(k=0; k<n && i>0; i--){    if( z[k]=='a' ){      pc = pOp->p2-1;      break;    }    while( k<n && z[k] ){ k++; }    k++;  }  Release(pTos);  pTos--;  break;}/* Opcode: Destroy P1 P2 ***** Delete an entire database table or index whose root page in the database** file is given by P1.**** The table being destroyed is in the main database file if P2==0.  If** P2==1 then the table to be clear is in the auxiliary database file** that is used to store tables create using CREATE TEMPORARY TABLE.**** See also: Clear*/case OP_Destroy: {  rc = sqliteBtreeDropTable(db->aDb[pOp->p2].pBt, pOp->p1);  break;}/* Opcode: Clear P1 P2 ***** Delete all contents of the database table or index whose root page** in the database file is given by P1.  But, unlike Destroy, do not** remove the table or index from the database file.**** The table being clear is in the main database file if P2==0.  If** P2==1 then the table to be clear is in the auxiliary database file** that is used to store tables create using CREATE TEMPORARY TABLE.**** See also: Destroy*/case OP_Clear: {  rc = sqliteBtreeClearTable(db->aDb[pOp->p2].pBt, pOp->p1);  break;}/* Opcode: CreateTable * P2 P3**** Allocate a new table in the main database file if P2==0 or in the** auxiliary database file if P2==1.  Push the page number** for the root page of the new table onto the stack.**** The root page number is also written to a memory location that P3** points to.  This is the mechanism is used to write the root page** number into the parser's internal data structures that describe the** new table.**** The difference between a table and an index is this:  A table must** have a 4-byte integer key and can have arbitrary data.  An index** has an arbitrary key but no data.**** See also: CreateIndex*//* Opcode: CreateIndex * P2 P3**** Allocate a new index in the main database file if P2==0 or in the** auxiliary database file if P2==1.  Push the page number of the** root page of the new index onto the stack.**** See documentation on OP_CreateTable for additional information.*/case OP_CreateIndex:case OP_CreateTable: {  int pgno;  assert( pOp->p3!=0 && pOp->p3type==P3_POINTER );  assert( pOp->p2>=0 && pOp->p2<db->nDb );  assert( db->aDb[pOp->p2].pBt!=0 );  if( pOp->opcode==OP_CreateTable ){    rc = sqliteBtreeCreateTable(db->aDb[pOp->p2].pBt, &pgno);  }else{    rc = sqliteBtreeCreateIndex(db->aDb[pOp->p2].pBt, &pgno);  }  pTos++;  if( rc==SQLITE_OK ){    pTos->i = pgno;    pTos->flags = MEM_Int;    *(u32*)pOp->p3 = pgno;    pOp->p3 = 0;  }else{    pTos->flags = MEM_Null;  }  break;}/* Opcode: IntegrityCk P1 P2 ***** Do an analysis of the currently open database.  Push onto the** stack the text of an error message describing any problems.** 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.  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.**** This opcode is used for testing purposes only.*/case OP_IntegrityCk: {  int nRoot;  int *aRoot;  int iSet = pOp->p1;  Set *pSet;  int j;  HashElem *i;  char *z;  assert( iSet>=0 && iSet<p->nSet );  pTos++;  pSet = &p->aSet[iSet];  nRoot = sqliteHashCount(&pSet->hash);  aRoot = sqliteMallocRaw( sizeof(int)*(nRoot+1) );  if( aRoot==0 ) goto no_mem;  for(j=0, i=sqliteHashFirst(&pSet->hash); i; i=sqliteHashNext(i), j++){    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);    pTos->z = "ok";    pTos->n = 3;    pTos->flags = MEM_Str | MEM_Static;  }else{    pTos->z = z;    pTos->n = strlen(z) + 1;    pTos->flags = MEM_Str | MEM_Dyn;  }  sqliteFree(aRoot);  break;}/* Opcode: ListWrite * * ***** Write the integer on the top of the stack** into the temporary storage list.*/case OP_ListWrite: {  Keylist *pKeylist;  assert( pTos>=p->aStack );  pKeylist = p->pList;  if( pKeylist==0 || pKeylist->nUsed>=pKeylist->nKey ){    pKeylist = sqliteMallocRaw( sizeof(Keylist)+999*sizeof(pKeylist->aKey[0]) );    if( pKeylist==0 ) goto no_mem;    pKeylist->nKey = 1000;    pKeylist->nRead = 0;    pKeylist->nUsed = 0;    pKeylist->pNext = p->pList;    p->pList = pKeylist;  }  Integerify(pTos);  pKeylist->aKey[pKeylist->nUsed++] = pTos->i;  Release(pTos);  pTos--;  break;}/* Opcode: ListRewind * * ***** Rewind the temporary buffer back to the beginning.*/case OP_ListRewind: {  /* What this opcode codes, really, is reverse the order of the  ** linked list of Keylist structures so that they are read out  ** in the same order that they were read in. */  Keylist *pRev, *pTop;  pRev = 0;  while( p->pList ){    pTop = p->pList;    p->pList = pTop->pNext;    pTop->pNext = pRev;    pRev = pTop;  }  p->pList = pRev;  break;}/* Opcode: ListRead * P2 ***** Attempt to read an integer from the temporary storage buffer** and push it onto the stack.  If the storage buffer is empty, ** push nothing but instead jump to P2.*/case OP_ListRead: {  Keylist *pKeylist;  CHECK_FOR_INTERRUPT;  pKeylist = p->pList;  if( pKeylist!=0 ){    assert( pKeylist->nRead>=0 );    assert( pKeylist->nRead<pKeylist->nUsed );    assert( pKeylist->nRead<pKeylist->nKey );    pTos++;    pTos->i = pKeylist->aKey[pKeylist->nRead++];    pTos->flags = MEM_Int;    if( pKeylist->nRead>=pKeylist->nUsed ){      p->pList = pKeylist->pNext;      sqliteFree(pKeylist);    }  }else{    pc = pOp->p2 - 1;  }  break;}/* Opcode: ListReset * * ***** Reset the temporary storage buffer so that it holds nothing.*/case OP_ListReset: {  if( p->pList ){    sqliteVdbeKeylistFree(p->pList);    p->pList = 0;  }  break;}/* Opcode: ListPush * * * **** Save the current Vdbe list such that it can be restored by a ListPop** opcode. The list is empty after this is executed.*/case OP_ListPush: {  p->keylistStackDepth++;  assert(p->keylistStackDepth > 0);  p->keylistStack = sqliteRealloc(p->keylistStack,           sizeof(Keylist *) * p->keylistStackDepth);  if( p->keylistStack==0 ) goto no_mem;  p->keylistStack[p->keylistStackDepth - 1] = p->pList;  p->pList = 0;  break;}/* Opcode: ListPop * * * **** Restore the Vdbe list to the state it was in when ListPush was last** executed.*/case OP_ListPop: {  assert(p->keylistStackDepth > 0);  p->keylistStackDepth--;  sqliteVdbeKeylistFree(p->pList);  p->pList = p->keylistStack[p->keylistStackDepth];  p->keylistStack[p->keylistStackDepth] = 0;  if( p->keylistStackDepth == 0 ){    sqliteFree(p->keylistStack);    p->keylistStack = 0;  }  break;}/* Opcode: ContextPush * * * **** Save the current Vdbe context such that it can be restored by a ContextPop** opcode. The context stores the last insert row id, the last statement change** count, and the current statement change count.*/case OP_ContextPush: {  p->contextStackDepth++;  assert(p->contextStackDepth > 0);  p->contextStack = sqliteRealloc(p->contextStack,           sizeof(Context) * p->contextStackDepth);  if( p->contextStack==0 ) goto no_mem;  p->contextStack[p->contextStackDepth - 1].lastRowid = p->db->lastRowid;  p->contextStack[p->contextStackDepth - 1].lsChange = p->db->lsChange;  p->contextStack[p->contextStackDepth - 1].csChange = p->db->csChange;  break;}/* Opcode: ContextPop * * * **** Restore the Vdbe context to the state it was in when contextPush was last** executed. The context stores the last insert row id, the last statement** change count, and the current statement change count.*/case OP_ContextPop: {  assert(p->contextStackDepth > 0);  p->contextStackDepth--;  p->db->lastRowid = p->contextStack[p->contextStackDepth].lastRowid;  p->db->lsChange = p->contextStack[p->contextStackDepth].lsChange;  p->db->csChange = p->contextStack[p->contextStackDepth].csChange;  if( p->contextStackDepth == 0 ){    sqliteFree(p->contextStack);    p->contextStack = 0;  }  break;}/* Opcode: SortPut * * ***** The TOS is the key and the NOS is the data.  Pop both from the stack** and put them on the sorter.  The key and data should have been** made using SortMakeKey and SortMakeRec, respectively.*/case OP_SortPut: {  Mem *pNos = &pTos[-1];  Sorter *pSorter;  assert( pNos>=p->aStack );  if( Dynamicify(pTos) || Dynamicify(pNos) ) goto no_mem;  pSorter = sqliteMallocRaw( sizeof(Sorter) );  if( pSorter==0 ) goto no_mem;  pSorter->pNext = p->pSort;  p->pSort = pSorter;  assert( pTos->flags & MEM_Dyn );  pSorter->nKey = pTos->n;  pSorter->zKey = pTos->z;  assert( pNos->flags & MEM_Dyn );  pSorter->nData = pNos->n;  pSorter->pData = pNos->z;  pTos -= 2;  break;}/* Opcode: SortMakeRec P1 * ***** The top P1 elements are the arguments to a callback.  Form these** elements into a single data entry that can be stored on a sorter** using SortPut and later fed to a callback using SortCallback.*/case OP_SortMakeRec: {  char *z;  char **azArg;  int nByte;  int nField;  int i;  Mem *pRec;  nField = pOp->p1;  pRec = &pTos[1-nField];  assert( pRec>=p->aStack );  nByte = 0;  for(i=0; i<nField; i++, pRec++){    if( (pRec->flags & MEM_Null)==0 ){      Stringify(pRec);      nByte += pRec->n;    }  }  nByte += sizeof(char*)*(nField+1);  azArg = sqliteMallocRaw( nByte );  if( azArg==0 ) goto no_mem;  z = (char*)&azArg[nField+1];  for(pRec=&pTos[1-nField], i=0; i<nField; i++, pRec++){    if( pRec->flags & MEM_Null ){      azArg[i] = 0;    }else{      azArg[i] = z;      memcpy(z, pRec->z, pRec->n);      z += pRec->n;    }  }  popStack(&pTos, nField);  pTos++;  pTos->n = nByte;  pTos->z = (char*)azArg;  pTos->flags = MEM_Str | MEM_Dyn;  break;}/* Opcode: SortMakeKey * * P3**** Convert the top few entries of the stack into a sort key.  The** number of stack entries consumed is the number of characters in ** the string P3.  One character from P3 is prepended to each entry.** The first character of P3 is prepended to the element lowest in** the stack and the last character of P3 is prepended to the top of** the stack.  All stack entries are separated by a \000 character** in the result.  The whole key is terminated by two \000 characters** in a row.**** "N" is substituted in place of the P3 character for NULL values.**** See also the MakeKey and MakeIdxKey opcodes.*/case OP_SortMakeKey: {  char *zNewKey;  int nByte;  int nField;  int i, j, k;  Mem *pRec;  nField = strlen(pOp->p3);  pRec = &pTos[1-nField];  nByte = 1;  for(i=0; i<nField; i++, pRec++){    if( pRec->flags & MEM_Null ){      nByte += 2;    }else{      Stringify(pRec);      nByte += pRec->n+2;    }  }  zNewKey = sqliteMallocRaw( nByte );  if( zNewKey==0 ) goto no_mem;  j = 0;  k = 0;  for(pRec=&pTos[1-nField], i=0; i<nField; i++, pRec++){    if( pRec->flags & MEM_Null ){      zNewKey[j++] = 'N';      zNewKey[j++] = 0;      k++;    }else{      zNewKey[j++] = pOp->p3[k++];      memcpy(&zNewKey[j], pRec->z, pRec->n-1);      j += pRec->n-1;      zNewKey[j++] = 0;    }  }  zNewKey[j] = 0;  assert( j<nByte );  popStack(&pTos, nField);  pTos++;  pTos->n = nByte;  pTos->flags = MEM_Str|MEM_Dyn;  pTos->z = zNewKey;  break;}/* Opcode: Sort * * ***** Sort all elements on the sorter.  The algorithm is a** mergesort.*/case OP_Sort: {  int i;  Sorter *pElem;  Sorter *apSorter[NSORT];  for(i=0; i<NSORT; i++){    apSorter[i] = 0;  }  while( p->pSort ){    pElem = p->pSort;    p->pSort = pElem->pNext;    pElem->pNext = 0;    for(i=0; i<NSORT-1; i++){    if( apSorter[i]==0 ){        apSorter[i] = pElem;        break;      }else{        pElem = Merge(apSorter[i], pElem);        apSorter[i] = 0;      }    }    if( i>=NSORT-1 ){      apSorter[NSORT-1] = Merge(apSorter[NSORT-1],pElem);    }  }  pElem = 0;  for(i=0; i<NSORT; i++){    pElem = Merge(apSorter[i], pElem);  }  p->pSort = pElem;  break;}/* Opcode: SortNext * P2 ***** Push the data for the topmost element in the sorter onto the** stack, then remove the element from the sorter.  If the sorter** is empty, push nothing on the stack and instead jump immediately ** to instruction P2.*/case OP_SortNext: {  Sorter *pSorter = p->pSort;  CHECK_FOR_INTERRUPT;  if( pSorter!=0 ){    p->pSort = pSorter->pNext;    pTos++;    pTos->z = pSorter->pData;    pTos->n = pSorter->nData;    pTos->flags = MEM_Str|MEM_Dyn;    sqliteFree(pSorter->zKey);    sqliteFree(pSorter);  }else{    pc = pOp->p2 - 1;  }  break;}/* Opcode: SortCallback P1 * ***** The top of the stack contains a callback record built using** the SortMakeRec operation with the same P1 value as this** instruction.  Pop this record from the stack and invoke the** callback on it.*/case OP_SortCallback: {  assert( pTos>=p->aStack );  assert( pTos->flags & MEM_Str );  p->nCallback++;  p->pc = pc+1;  p->azResColumn = (char**)pTos->z;  assert( p->nResColumn==pOp->p1 );  p->popStack = 1;  p->pTos = pTos;  return SQLITE_ROW;}/* Opcode: SortReset * * ***** Remove any elements that remain on the sorter.*/case OP_SortReset: {  sqliteVdbeSorterReset(p);  break;}/* Opcode: FileOpen * * P3**** Open the file named by P3 for reading using the FileRead opcode.** If P3 is "stdin" then open standard input for reading.*/case OP_FileOpen: {  assert( pOp->p3!=0 );  if( p->pFile ){    if( p->pFile!=stdin ) fclose(p->pFile);    p->pFile = 0;  }  if( sqliteStrICmp(pOp->p3,"stdin")==0 ){    p->pFile = stdin;  }else{    p->pFile = fopen(pOp->p3, "r");  }  if( p->pFile==0 ){    sqliteSetString(&p->zErrMsg,"unable to open file: ", pOp->p3, (char*)0);    rc = SQLITE_ERROR;  }  break;}/* Opcode: FileRead P1 P2 P3**** Read a single line of input from the open file (the file opened using** FileOpen).  If we reach end-of-file, jump immediately to P2.  If** we are able to get another line, split the line apart using P3 as** a delimiter.  There should be P1 fields.  If the input line contains** more than P1 fields, ignore the excess.  If the input line contains** fewer than P1 fields, assume the remaining fields contain NULLs.**** Input ends if a line consists of just "\.".  A field containing only** "\N" is a null field.  The backslash \ character can be used be used** to escape newlines or the delimiter.*/case OP_FileRead: {  int n, eol, nField, i, c, nDelim;  char *zDelim, *z;  CHECK_FOR_INTERRUPT;  if( p->pFile==0 ) goto fileread_jump;  nField = pOp->p1;  if( nField<=0 ) goto fileread_jump;  if( nField!=p->nField || p->azField==0 ){    char **azField = sqliteRealloc(p->azField, sizeof(char*)*nField+1);    if( azField==0 ){ goto no_mem; }    p->azField = azField;    p->nField = nField;  }  n = 0;  eol = 0;  while( eol==0 ){    if( p->zLine==0 || n+200>p->nLineAlloc ){      char *zLine;      p->nLineAlloc = p->nLineAlloc*2 + 300;      zLine = sqliteRealloc(p->zLine, p->nLineAlloc);      if( zLine==0 ){        p->nLineAlloc = 0;        sqliteFree(p->zLine);        p->zLine = 0;        goto no_mem;      }      p->zLine = zLine;    }    if( vdbe_fgets(&p->zLine[n], p->nLineAlloc-n, p->pFile)==0 ){      eol = 1;      p->zLine[n] = 0;    }else{      int c;      while( (c = p->zLine[n])!=0 ){        if( c=='\\' ){          if( p->zLine[n+1]==0 ) break;          n += 2;        }else if( c=='\n' ){          p->zLine[n] = 0;          eol = 1;          break;        }else{          n++;        }      }    }  }  if( n==0 ) goto fileread_jump;  z = p->zLine;  if( z[0]=='\\' && z[1]=='.' && z[2]==0 ){    goto fileread_jump;  }  zDelim = pOp->p3;  if( zDelim==0 ) zDelim = "\t";  c = zDelim[0];  nDelim = strlen(zDelim);  p->azField[0] = z;  for(i=1; *z!=0 && i<=nField; i++){    int from, to;    from = to = 0;    if( z[0]=='\\' && z[1]=='N'        && (z[2]==0 || strncmp(&z[2],zDelim,nDelim)==0) ){      if( i<=nField ) p->azField[i-1] = 0;      z += 2 + nDelim;      if( i<nField ) p->azField[i] = z;      continue;    }    while( z[from] ){      if( z[from]=='\\' && z[from+1]!=0 ){        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;      }      if( z[from]==c && strncmp(&z[from],zDelim,nDelim)==0 ) break;      z[to++] = z[from++];    }    if( z[from] ){      z[to] = 0;      z += from + nDelim;      if( i<nField ) p->azField[i] = z;    }else{      z[to] = 0;      z = "";    }  }  while( i<nField ){    p->azField[i++] = 0;  }  break;  /* If we reach end-of-file, or if anything goes wrong, jump here.  ** This code will cause a jump to P2 */fileread_jump:  pc = pOp->p2 - 1;  break;}/* Opcode: FileColumn P1 * ***** Push onto the stack the P1-th column of the most recently read line** from the input file.*/case OP_FileColumn: {  int i = pOp->p1;  char *z;  assert( i>=0 && i<p->nField );  if( p->azField ){    z = p->azField[i];  }else{    z = 0;  }  pTos++;  if( z ){    pTos->n = strlen(z) + 1;    pTos->z = z;    pTos->flags = MEM_Str | MEM_Ephem;  }else{    pTos->flags = MEM_Null;  }  break;}/* Opcode: MemStore P1 P2 ***** Write the top of the stack into memory location P1.** P1 should be a small integer since space is allocated** for all memory locations between 0 and P1 inclusive.**** After the data is stored in the memory location, the** stack is popped once if P2 is 1.  If P2 is zero, then** the original data remains on the stack.*/case OP_MemStore: {  int i = pOp->p1;  Mem *pMem;  assert( pTos>=p->aStack );  if( i>=p->nMem ){    int nOld = p->nMem;    Mem *aMem;    p->nMem = i + 5;    aMem = sqliteRealloc(p->aMem, p->nMem*sizeof(p->aMem[0]));    if( aMem==0 ) goto no_mem;    if( aMem!=p->aMem ){      int j;      for(j=0; j<nOld; j++){        if( aMem[j].flags & MEM_Short ){          aMem[j].z = aMem[j].zShort;        }      }    }    p->aMem = aMem;    if( nOld<p->nMem ){      memset(&p->aMem[nOld], 0, sizeof(p->aMem[0])*(p->nMem-nOld));    }  }  Deephemeralize(pTos);  pMem = &p->aMem[i];  Release(pMem);  *pMem = *pTos;  if( pMem->flags & MEM_Dyn ){    if( pOp->p2 ){      pTos->flags = MEM_Null;    }else{      pMem->z = sqliteMallocRaw( pMem->n );      if( pMem->z==0 ) goto no_mem;      memcpy(pMem->z, pTos->z, pMem->n);    }  }else if( pMem->flags & MEM_Short ){    pMem->z = pMem->zShort;  }  if( pOp->p2 ){    Release(pTos);    pTos--;  }  break;}/* Opcode: MemLoad P1 * ***** Push a copy of the value in memory location P1 onto the stack.**** If the value is a string, then the value pushed is a pointer to** the string that is stored in the memory location.  If the memory** location is subsequently changed (using OP_MemStore) then the** value pushed onto the stack will change too.*/case OP_MemLoad: {  int i = pOp->p1;  assert( i>=0 && i<p->nMem );  pTos++;  memcpy(pTos, &p->aMem[i], sizeof(pTos[0])-NBFS);;  if( pTos->flags & MEM_Str ){    pTos->flags |= MEM_Ephem;    pTos->flags &= ~(MEM_Dyn|MEM_Static|MEM_Short);  }  break;}/* Opcode: MemIncr P1 P2 ***** Increment the integer valued memory cell P1 by 1.  If P2 is not zero** and the result after the increment is greater than zero, then jump** to P2.**** This instruction throws an error if the memory cell is not initially** an integer.*/case OP_MemIncr: {  int i = pOp->p1;  Mem *pMem;  assert( i>=0 && i<p->nMem );  pMem = &p->aMem[i];  assert( pMem->flags==MEM_Int );  pMem->i++;  if( pOp->p2>0 && pMem->i>0 ){     pc = pOp->p2 - 1;  }  break;}/* Opcode: AggReset * P2 ***** Reset the aggregator so that it no longer contains any data.** Future aggregator elements will contain P2 values each.*/case OP_AggReset: {  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;  break;}/* Opcode: AggInit * P2 P3**** Initialize the function parameters for an aggregate function.** The aggregate will operate out of aggregate column P2.** P3 is a pointer to the FuncDef structure for the function.*/case OP_AggInit: {  int i = pOp->p2;  assert( i>=0 && i<p->agg.nMem );  p->agg.apFunc[i] = (FuncDef*)pOp->p3;  break;}/* Opcode: AggFunc * P2 P3**** Execute the step function for an aggregate.  The** function has P2 arguments.  P3 is a pointer to the FuncDef** structure that specifies the function.**** The top of the stack must be an integer which is the index of** the aggregate column that corresponds to this aggregate function.** Ideally, this index would be another parameter, but there are** no free parameters left.  The integer is popped from the stack.*/case OP_AggFunc: {  int n = pOp->p2;  int i;  Mem *pMem, *pRec;  char **azArgv = p->zArgv;  sqlite_func ctx;  assert( n>=0 );  assert( pTos->flags==MEM_Int );  pRec = &pTos[-n];  assert( pRec>=p->aStack );  for(i=0; i<n; i++, pRec++){    if( pRec->flags & MEM_Null ){      azArgv[i] = 0;    }else{      Stringify(pRec);      azArgv[i] = pRec->z;    }  }  i = pTos->i;  assert( i>=0 && i<p->agg.nMem );  ctx.pFunc = (FuncDef*)pOp->p3;  pMem = &p->agg.pCurrent->aMem[i];  ctx.s.z = pMem->zShort;  /* Space used for small aggregate contexts */  ctx.pAgg = pMem->z;  ctx.cnt = ++pMem->i;  ctx.isError = 0;  ctx.isStep = 1;  (ctx.pFunc->xStep)(&ctx, n, (const char**)azArgv);  pMem->z = ctx.pAgg;  pMem->flags = MEM_AggCtx;  popStack(&pTos, n+1);  if( ctx.isError ){    rc = SQLITE_ERROR;  }  break;}/* Opcode: AggFocus * P2 ***** Pop the top of the stack and use that as an aggregator key.  If** an aggregator with that same key already exists, then make the** aggregator the current aggregator and jump to P2.  If no aggregator** with the given key exists, create one and make it current but** do not jump.**** The order of aggregator opcodes is important.  The order is:** AggReset AggFocus AggNext.  In other words, you must execute** AggReset first, then zero or more AggFocus operations, then** zero or more AggNext operations.  You must not execute an AggFocus** in between an AggNext and an AggReset.*/case OP_AggFocus: {  AggElem *pElem;  char *zKey;  int nKey;  assert( pTos>=p->aStack );  Stringify(pTos);  zKey = pTos->z;  nKey = pTos->n;  pElem = sqliteHashFind(&p->agg.hash, zKey, nKey);  if( pElem ){    p->agg.pCurrent = pElem;    pc = pOp->p2 - 1;  }else{    AggInsert(&p->agg, zKey, nKey);    if( sqlite_malloc_failed ) goto no_mem;  }  Release(pTos);  pTos--;  break; }/* Opcode: AggSet * P2 ***** Move the top of the stack into the P2-th field of the current** aggregate.  String values are duplicated into new memory.*/case OP_AggSet: {  AggElem *pFocus = AggInFocus(p->agg);  Mem *pMem;  int i = pOp->p2;  assert( pTos>=p->aStack );  if( pFocus==0 ) goto no_mem;  assert( i>=0 && i<p->agg.nMem );  Deephemeralize(pTos);  pMem = &pFocus->aMem[i];  Release(pMem);  *pMem = *pTos;  if( pMem->flags & MEM_Dyn ){    pTos->flags = MEM_Null;  }else if( pMem->flags & MEM_Short ){    pMem->z = pMem->zShort;  }  Release(pTos);  pTos--;  break;}/* Opcode: AggGet * P2 ***** Push a new entry onto the stack which is a copy of the P2-th field** of the current aggregate.  Strings are not duplicated so** string values will be ephemeral.*/case OP_AggGet: {  AggElem *pFocus = AggInFocus(p->agg);  Mem *pMem;  int i = pOp->p2;  if( pFocus==0 ) goto no_mem;  assert( i>=0 && i<p->agg.nMem );  pTos++;  pMem = &pFocus->aMem[i];  *pTos = *pMem;  if( pTos->flags & MEM_Str ){    pTos->flags &= ~(MEM_Dyn|MEM_Static|MEM_Short);    pTos->flags |= MEM_Ephem;  }  break;}/* Opcode: AggNext * P2 ***** Make the next aggregate value the current aggregate.  The prior** aggregate is deleted.  If all aggregate values have been consumed,** jump to P2.**** The order of aggregator opcodes is important.  The order is:** AggReset AggFocus AggNext.  In other words, you must execute** AggReset first, then zero or more AggFocus operations, then** zero or more AggNext operations.  You must not execute an AggFocus** in between an AggNext and an AggReset.*/case OP_AggNext: {  CHECK_FOR_INTERRUPT;  if( p->agg.pSearch==0 ){    p->agg.pSearch = sqliteHashFirst(&p->agg.hash);  }else{    p->agg.pSearch = sqliteHashNext(p->agg.pSearch);  }  if( p->agg.pSearch==0 ){    pc = pOp->p2 - 1;  } else {    int i;    sqlite_func ctx;    Mem *aMem;    p->agg.pCurrent = sqliteHashData(p->agg.pSearch);    aMem = p->agg.pCurrent->aMem;    for(i=0; i<p->agg.nMem; i++){      int freeCtx;      if( p->agg.apFunc[i]==0 ) continue;      if( p->agg.apFunc[i]->xFinalize==0 ) continue;      ctx.s.flags = MEM_Null;      ctx.s.z = aMem[i].zShort;      ctx.pAgg = (void*)aMem[i].z;      freeCtx = aMem[i].z && aMem[i].z!=aMem[i].zShort;      ctx.cnt = aMem[i].i;      ctx.isStep = 0;      ctx.pFunc = p->agg.apFunc[i];      (*p->agg.apFunc[i]->xFinalize)(&ctx);      if( freeCtx ){        sqliteFree( aMem[i].z );      }      aMem[i] = ctx.s;      if( aMem[i].flags & MEM_Short ){        aMem[i].z = aMem[i].zShort;      }    }  }  break;}/* Opcode: SetInsert P1 * P3**** If Set P1 does not exist then create it.  Then insert value** P3 into that set.  If P3 is NULL, then insert the top of the** stack into the set.*/case OP_SetInsert: {  int i = pOp->p1;  if( p->nSet<=i ){    int k;    Set *aSet = sqliteRealloc(p->aSet, (i+1)*sizeof(p->aSet[0]) );    if( aSet==0 ) goto no_mem;    p->aSet = aSet;    for(k=p->nSet; k<=i; k++){      sqliteHashInit(&p->aSet[k].hash, SQLITE_HASH_BINARY, 1);    }    p->nSet = i+1;  }  if( pOp->p3 ){    sqliteHashInsert(&p->aSet[i].hash, pOp->p3, strlen(pOp->p3)+1, p);  }else{    assert( pTos>=p->aStack );    Stringify(pTos);    sqliteHashInsert(&p->aSet[i].hash, pTos->z, pTos->n, p);    Release(pTos);    pTos--;  }  if( sqlite_malloc_failed ) goto no_mem;  break;}/* Opcode: SetFound P1 P2 ***** Pop the stack once and compare the value popped off with the** contents of set P1.  If the element popped exists in set P1,** then jump to P2.  Otherwise fall through.*/case OP_SetFound: {  int i = pOp->p1;  assert( pTos>=p->aStack );  Stringify(pTos);  if( i>=0 && i<p->nSet && sqliteHashFind(&p->aSet[i].hash, pTos->z, pTos->n)){    pc = pOp->p2 - 1;  }  Release(pTos);  pTos--;  break;}/* Opcode: SetNotFound P1 P2 ***** Pop the stack once and compare the value popped off with the** contents of set P1.  If the element popped does not exists in ** set P1, then jump to P2.  Otherwise fall through.*/case OP_SetNotFound: {  int i = pOp->p1;  assert( pTos>=p->aStack );  Stringify(pTos);  if( i<0 || i>=p->nSet ||       sqliteHashFind(&p->aSet[i].hash, pTos->z, pTos->n)==0 ){    pc = pOp->p2 - 1;  }  Release(pTos);  pTos--;  break;}/* Opcode: SetFirst P1 P2 ***** Read the first element from set P1 and push it onto the stack.  If the** set is empty, push nothing and jump immediately to P2.  This opcode is** used in combination with OP_SetNext to loop over all elements of a set.*//* Opcode: SetNext P1 P2 ***** Read the next element from set P1 and push it onto the stack.  If there** are no more elements in the set, do not do the push and fall through.** Otherwise, jump to P2 after pushing the next set element.*/case OP_SetFirst: case OP_SetNext: {  Set *pSet;  CHECK_FOR_INTERRUPT;  if( pOp->p1<0 || pOp->p1>=p->nSet ){    if( pOp->opcode==OP_SetFirst ) pc = pOp->p2 - 1;    break;  }  pSet = &p->aSet[pOp->p1];  if( pOp->opcode==OP_SetFirst ){    pSet->prev = sqliteHashFirst(&pSet->hash);    if( pSet->prev==0 ){      pc = pOp->p2 - 1;      break;    }  }else{    assert( pSet->prev );    pSet->prev = sqliteHashNext(pSet->prev);    if( pSet->prev==0 ){      break;    }else{      pc = pOp->p2 - 1;    }  }  pTos++;  pTos->z = sqliteHashKey(pSet->prev);  pTos->n = sqliteHashKeysize(pSet->prev);  pTos->flags = MEM_Str | MEM_Ephem;  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: {  sqlite_snprintf(sizeof(zBuf),zBuf,"%d",pOp->opcode);  sqliteSetString(&p->zErrMsg, "unknown opcode ", zBuf, (char*)0);  rc = SQLITE_INTERNAL;  break;}/******************************************************************************* The cases of the switch statement above this line should all be indented** by 6 spaces.  But the left-most 6 spaces have been removed to improve the** readability.  From this point on down, the normal indentation rules are** restored.*****************************************************************************/    }#ifdef VDBE_PROFILE    {      long long elapse = hwtime() - start;      pOp->cycles += elapse;      pOp->cnt++;#if 0        fprintf(stdout, "%10lld ", elapse);        sqliteVdbePrintOp(stdout, origPc, &p->aOp[origPc]);#endif    }#endif    /* The following code adds nothing to the actual functionality    ** of the program.  It is only here for testing and debugging.    ** On the other hand, it does burn CPU cycles every time through    ** the evaluator loop.  So we can leave it out when NDEBUG is defined.    */#ifndef NDEBUG    /* Sanity checking on the top element of the stack */    if( pTos>=p->aStack ){      assert( pTos->flags!=0 );  /* Must define some type */      if( pTos->flags & MEM_Str ){        int x = pTos->flags & (MEM_Static|MEM_Dyn|MEM_Ephem|MEM_Short);        assert( x!=0 );            /* Strings must define a string subtype */        assert( (x & (x-1))==0 );  /* Only one string subtype can be defined */        assert( pTos->z!=0 );      /* Strings must have a value */        /* Mem.z points to Mem.zShort iff the subtype is MEM_Short */        assert( (pTos->flags & MEM_Short)==0 || pTos->z==pTos->zShort );        assert( (pTos->flags & MEM_Short)!=0 || pTos->z!=pTos->zShort );      }else{        /* Cannot define a string subtype for non-string objects */        assert( (pTos->flags & (MEM_Static|MEM_Dyn|MEM_Ephem|MEM_Short))==0 );      }      /* MEM_Null excludes all other types */      assert( pTos->flags==MEM_Null || (pTos->flags&MEM_Null)==0 );    }    if( pc<-1 || pc>=p->nOp ){      sqliteSetString(&p->zErrMsg, "jump destination out of range", (char*)0);      rc = SQLITE_INTERNAL;    }    if( p->trace && pTos>=p->aStack ){      int i;      fprintf(p->trace, "Stack:");      for(i=0; i>-5 && &pTos[i]>=p->aStack; i--){        if( pTos[i].flags & MEM_Null ){          fprintf(p->trace, " NULL");        }else if( (pTos[i].flags & (MEM_Int|MEM_Str))==(MEM_Int|MEM_Str) ){          fprintf(p->trace, " si:%d", pTos[i].i);        }else if( pTos[i].flags & MEM_Int ){          fprintf(p->trace, " i:%d", pTos[i].i);        }else if( pTos[i].flags & MEM_Real ){          fprintf(p->trace, " r:%g", pTos[i].r);        }else if( pTos[i].flags & MEM_Str ){          int j, k;          char zBuf[100];          zBuf[0] = ' ';          if( pTos[i].flags & MEM_Dyn ){            zBuf[1] = 'z';            assert( (pTos[i].flags & (MEM_Static|MEM_Ephem))==0 );          }else if( pTos[i].flags & MEM_Static ){            zBuf[1] = 't';            assert( (pTos[i].flags & (MEM_Dyn|MEM_Ephem))==0 );          }else if( pTos[i].flags & MEM_Ephem ){            zBuf[1] = 'e';            assert( (pTos[i].flags & (MEM_Static|MEM_Dyn))==0 );          }else{            zBuf[1] = 's';          }          zBuf[2] = '[';          k = 3;          for(j=0; j<20 && j<pTos[i].n; j++){            int c = pTos[i].z[j];            if( c==0 && j==pTos[i].n-1 ) break;            if( isprint(c) && !isspace(c) ){              zBuf[k++] = c;            }else{              zBuf[k++] = '.';            }          }          zBuf[k++] = ']';          zBuf[k++] = 0;          fprintf(p->trace, "%s", zBuf);        }else{          fprintf(p->trace, " ???");        }      }      if( rc!=0 ) fprintf(p->trace," rc=%d",rc);      fprintf(p->trace,"\n");    }#endif  }  /* The end of the for(;;) loop the loops through opcodes */  /* If we reach this point, it means that execution is finished.  */vdbe_halt:  if( rc ){    p->rc = rc;    rc = SQLITE_ERROR;  }else{    rc = SQLITE_DONE;  }  p->magic = VDBE_MAGIC_HALT;  p->pTos = pTos;  return rc;  /* Jump to here if a malloc() fails.  It's hard to get a malloc()  ** to fail on a modern VM computer, so this code is untested.  */no_mem:  sqliteSetString(&p->zErrMsg, "out of memory", (char*)0);  rc = SQLITE_NOMEM;  goto vdbe_halt;  /* Jump to here for an SQLITE_MISUSE error.  */abort_due_to_misuse:  rc = SQLITE_MISUSE;  /* Fall thru into abort_due_to_error */  /* Jump to here for any other kind of fatal error.  The "rc" variable  ** should hold the error number.  */abort_due_to_error:  if( p->zErrMsg==0 ){    if( sqlite_malloc_failed ) rc = SQLITE_NOMEM;    sqliteSetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0);  }  goto vdbe_halt;  /* Jump to here if the sqlite_interrupt() API sets the interrupt  ** flag.  */abort_due_to_interrupt:  assert( db->flags & SQLITE_Interrupt );  db->flags &= ~SQLITE_Interrupt;  if( db->magic!=SQLITE_MAGIC_BUSY ){    rc = SQLITE_MISUSE;  }else{    rc = SQLITE_INTERRUPT;  }  sqliteSetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0);  goto vdbe_halt;}