Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Changes to src/insert.c.

  1103   1103   **                                return code of SQLITE_CONSTRAINT.
  1104   1104   **
  1105   1105   **  any              ABORT        Back out changes from the current command
  1106   1106   **                                only (do not do a complete rollback) then
  1107   1107   **                                cause sqlite3_exec() to return immediately
  1108   1108   **                                with SQLITE_CONSTRAINT.
  1109   1109   **
  1110         -**  any              FAIL         Sqlite_exec() returns immediately with a
         1110  +**  any              FAIL         Sqlite3_exec() returns immediately with a
  1111   1111   **                                return code of SQLITE_CONSTRAINT.  The
  1112   1112   **                                transaction is not rolled back and any
  1113   1113   **                                prior changes are retained.
  1114   1114   **
  1115   1115   **  any              IGNORE       The record number and data is popped from
  1116   1116   **                                the stack and there is an immediate jump
  1117   1117   **                                to label ignoreDest.

Changes to src/mutex.c.

   146    146     return p==0 || sqlite3GlobalConfig.mutex.xMutexHeld(p);
   147    147   }
   148    148   int sqlite3_mutex_notheld(sqlite3_mutex *p){
   149    149     return p==0 || sqlite3GlobalConfig.mutex.xMutexNotheld(p);
   150    150   }
   151    151   #endif
   152    152   
   153         -#endif /* SQLITE_MUTEX_OMIT */
          153  +#endif /* !defined(SQLITE_MUTEX_OMIT) */

Changes to src/mutex_noop.c.

   198    198   ** If compiled with SQLITE_MUTEX_NOOP, then the no-op mutex implementation
   199    199   ** is used regardless of the run-time threadsafety setting.
   200    200   */
   201    201   #ifdef SQLITE_MUTEX_NOOP
   202    202   sqlite3_mutex_methods const *sqlite3DefaultMutex(void){
   203    203     return sqlite3NoopMutex();
   204    204   }
   205         -#endif /* SQLITE_MUTEX_NOOP */
   206         -#endif /* SQLITE_MUTEX_OMIT */
          205  +#endif /* defined(SQLITE_MUTEX_NOOP) */
          206  +#endif /* !defined(SQLITE_MUTEX_OMIT) */

Changes to src/mutex_unix.c.

   344    344       0
   345    345   #endif
   346    346     };
   347    347   
   348    348     return &sMutex;
   349    349   }
   350    350   
   351         -#endif /* SQLITE_MUTEX_PTHREAD */
          351  +#endif /* SQLITE_MUTEX_PTHREADS */

Changes to src/sqlite.h.in.

  5394   5394   ** The SQLite source code contains multiple implementations
  5395   5395   ** of these mutex routines.  An appropriate implementation
  5396   5396   ** is selected automatically at compile-time.  ^(The following
  5397   5397   ** implementations are available in the SQLite core:
  5398   5398   **
  5399   5399   ** <ul>
  5400   5400   ** <li>   SQLITE_MUTEX_OS2
  5401         -** <li>   SQLITE_MUTEX_PTHREAD
         5401  +** <li>   SQLITE_MUTEX_PTHREADS
  5402   5402   ** <li>   SQLITE_MUTEX_W32
  5403   5403   ** <li>   SQLITE_MUTEX_NOOP
  5404   5404   ** </ul>)^
  5405   5405   **
  5406   5406   ** ^The SQLITE_MUTEX_NOOP implementation is a set of routines
  5407   5407   ** that does no real locking and is appropriate for use in
  5408   5408   ** a single-threaded application.  ^The SQLITE_MUTEX_OS2,
  5409         -** SQLITE_MUTEX_PTHREAD, and SQLITE_MUTEX_W32 implementations
         5409  +** SQLITE_MUTEX_PTHREADS, and SQLITE_MUTEX_W32 implementations
  5410   5410   ** are appropriate for use on OS/2, Unix, and Windows.
  5411   5411   **
  5412   5412   ** ^(If SQLite is compiled with the SQLITE_MUTEX_APPDEF preprocessor
  5413   5413   ** macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex
  5414   5414   ** implementation is included with the library. In this case the
  5415   5415   ** application must supply a custom mutex implementation using the
  5416   5416   ** [SQLITE_CONFIG_MUTEX] option of the sqlite3_config() function

Changes to src/test_func.c.

Changes to src/vdbe.c.

    48     48   
    49     49   /*
    50     50   ** Invoke this macro on memory cells just prior to changing the
    51     51   ** value of the cell.  This macro verifies that shallow copies are
    52     52   ** not misused.
    53     53   */
    54     54   #ifdef SQLITE_DEBUG
    55         -# define memAboutToChange(P,M) sqlite3VdbeMemPrepareToChange(P,M)
           55  +# define memAboutToChange(P,M) sqlite3VdbeMemAboutToChange(P,M)
    56     56   #else
    57     57   # define memAboutToChange(P,M)
    58     58   #endif
    59     59   
    60     60   /*
    61     61   ** The following global variable is incremented every time a cursor
    62     62   ** moves, either by the OP_SeekXX, OP_Next, or OP_Prev opcodes.  The test
................................................................................
    66     66   */
    67     67   #ifdef SQLITE_TEST
    68     68   int sqlite3_search_count = 0;
    69     69   #endif
    70     70   
    71     71   /*
    72     72   ** When this global variable is positive, it gets decremented once before
    73         -** each instruction in the VDBE.  When reaches zero, the u1.isInterrupted
    74         -** field of the sqlite3 structure is set in order to simulate and interrupt.
           73  +** each instruction in the VDBE.  When it reaches zero, the u1.isInterrupted
           74  +** field of the sqlite3 structure is set in order to simulate an interrupt.
    75     75   **
    76     76   ** This facility is used for testing purposes only.  It does not function
    77     77   ** in an ordinary build.
    78     78   */
    79     79   #ifdef SQLITE_TEST
    80     80   int sqlite3_interrupt_count = 0;
    81     81   #endif
................................................................................
   192    192   ** Allocate VdbeCursor number iCur.  Return a pointer to it.  Return NULL
   193    193   ** if we run out of memory.
   194    194   */
   195    195   static VdbeCursor *allocateCursor(
   196    196     Vdbe *p,              /* The virtual machine */
   197    197     int iCur,             /* Index of the new VdbeCursor */
   198    198     int nField,           /* Number of fields in the table or index */
   199         -  int iDb,              /* When database the cursor belongs to, or -1 */
          199  +  int iDb,              /* Database the cursor belongs to, or -1 */
   200    200     int isBtreeCursor     /* True for B-Tree.  False for pseudo-table or vtab */
   201    201   ){
   202    202     /* Find the memory cell that will be used to store the blob of memory
   203    203     ** required for this VdbeCursor structure. It is convenient to use a 
   204    204     ** vdbe memory cell to manage the memory allocation required for a
   205    205     ** VdbeCursor structure for the following reasons:
   206    206     **
................................................................................
   474    474   /*
   475    475   ** The CHECK_FOR_INTERRUPT macro defined here looks to see if the
   476    476   ** sqlite3_interrupt() routine has been called.  If it has been, then
   477    477   ** processing of the VDBE program is interrupted.
   478    478   **
   479    479   ** This macro added to every instruction that does a jump in order to
   480    480   ** implement a loop.  This test used to be on every single instruction,
   481         -** but that meant we more testing that we needed.  By only testing the
          481  +** but that meant we more testing than we needed.  By only testing the
   482    482   ** flag on jump instructions, we get a (small) speed improvement.
   483    483   */
   484    484   #define CHECK_FOR_INTERRUPT \
   485    485      if( db->u1.isInterrupted ) goto abort_due_to_interrupt;
   486    486   
   487    487   
   488    488   #ifndef NDEBUG
................................................................................
   669    669       */
   670    670       assert( pOp->opflags==sqlite3OpcodeProperty[pOp->opcode] );
   671    671       if( pOp->opflags & OPFLG_OUT2_PRERELEASE ){
   672    672         assert( pOp->p2>0 );
   673    673         assert( pOp->p2<=p->nMem );
   674    674         pOut = &aMem[pOp->p2];
   675    675         memAboutToChange(p, pOut);
   676         -      MemReleaseExt(pOut);
          676  +      VdbeMemRelease(pOut);
   677    677         pOut->flags = MEM_Int;
   678    678       }
   679    679   
   680    680       /* Sanity checking on other operands */
   681    681   #ifdef SQLITE_DEBUG
   682    682       if( (pOp->opflags & OPFLG_IN1)!=0 ){
   683    683         assert( pOp->p1>0 );
................................................................................
   973    973     int cnt;
   974    974     cnt = pOp->p3-pOp->p2;
   975    975     assert( pOp->p3<=p->nMem );
   976    976     pOut->flags = MEM_Null;
   977    977     while( cnt>0 ){
   978    978       pOut++;
   979    979       memAboutToChange(p, pOut);
   980         -    MemReleaseExt(pOut);
          980  +    VdbeMemRelease(pOut);
   981    981       pOut->flags = MEM_Null;
   982    982       cnt--;
   983    983     }
   984    984     break;
   985    985   }
   986    986   
   987    987   
................................................................................
  2371   2371     ** then there are not enough fields in the record to satisfy the
  2372   2372     ** request.  In this case, set the value NULL or to P4 if P4 is
  2373   2373     ** a pointer to a Mem object.
  2374   2374     */
  2375   2375     if( aOffset[p2] ){
  2376   2376       assert( rc==SQLITE_OK );
  2377   2377       if( zRec ){
  2378         -      MemReleaseExt(pDest);
         2378  +      VdbeMemRelease(pDest);
  2379   2379         sqlite3VdbeSerialGet((u8 *)&zRec[aOffset[p2]], aType[p2], pDest);
  2380   2380       }else{
  2381   2381         len = sqlite3VdbeSerialTypeLen(aType[p2]);
  2382   2382         sqlite3VdbeMemMove(&sMem, pDest);
  2383   2383         rc = sqlite3VdbeMemFromBtree(pCrsr, aOffset[p2], len, pC->isIndex, &sMem);
  2384   2384         if( rc!=SQLITE_OK ){
  2385   2385           goto op_column_out;

Changes to src/vdbeInt.h.

   404    404   double sqlite3VdbeRealValue(Mem*);
   405    405   void sqlite3VdbeIntegerAffinity(Mem*);
   406    406   int sqlite3VdbeMemRealify(Mem*);
   407    407   int sqlite3VdbeMemNumerify(Mem*);
   408    408   int sqlite3VdbeMemFromBtree(BtCursor*,int,int,int,Mem*);
   409    409   void sqlite3VdbeMemRelease(Mem *p);
   410    410   void sqlite3VdbeMemReleaseExternal(Mem *p);
   411         -#define MemReleaseExt(X)  \
          411  +#define VdbeMemRelease(X)  \
   412    412     if((X)->flags&(MEM_Agg|MEM_Dyn|MEM_RowSet|MEM_Frame)) \
   413    413       sqlite3VdbeMemReleaseExternal(X);
   414    414   int sqlite3VdbeMemFinalize(Mem*, FuncDef*);
   415    415   const char *sqlite3OpcodeName(int);
   416    416   int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve);
   417    417   int sqlite3VdbeCloseStatement(Vdbe *, int);
   418    418   void sqlite3VdbeFrameDelete(VdbeFrame*);
................................................................................
   443    443     void sqlite3VdbeLeave(Vdbe*);
   444    444   #else
   445    445   # define sqlite3VdbeEnter(X)
   446    446   # define sqlite3VdbeLeave(X)
   447    447   #endif
   448    448   
   449    449   #ifdef SQLITE_DEBUG
   450         -void sqlite3VdbeMemPrepareToChange(Vdbe*,Mem*);
          450  +void sqlite3VdbeMemAboutToChange(Vdbe*,Mem*);
   451    451   #endif
   452    452   
   453    453   #ifndef SQLITE_OMIT_FOREIGN_KEY
   454    454   int sqlite3VdbeCheckFk(Vdbe *, int);
   455    455   #else
   456    456   # define sqlite3VdbeCheckFk(p,i) 0
   457    457   #endif

Changes to src/vdbeaux.c.

   192    192     int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3);
   193    193     sqlite3VdbeChangeP4(p, addr, zP4, p4type);
   194    194     return addr;
   195    195   }
   196    196   
   197    197   /*
   198    198   ** Add an OP_ParseSchema opcode.  This routine is broken out from
   199         -** sqlite3VdbeAddOp4() since it needs to also local all btrees.
          199  +** sqlite3VdbeAddOp4() since it needs to also needs to mark all btrees
          200  +** as having been used.
   200    201   **
   201    202   ** The zWhere string must have been obtained from sqlite3_malloc().
   202    203   ** This routine will take ownership of the allocated memory.
   203    204   */
   204    205   void sqlite3VdbeAddParseSchemaOp(Vdbe *p, int iDb, char *zWhere){
   205    206     int j;
   206    207     int addr = sqlite3VdbeAddOp3(p, OP_ParseSchema, iDb, 0, 0);
................................................................................
   959    960   }
   960    961   #endif
   961    962   
   962    963   /*
   963    964   ** Declare to the Vdbe that the BTree object at db->aDb[i] is used.
   964    965   **
   965    966   ** The prepared statements need to know in advance the complete set of
   966         -** attached databases that they will be using.  A mask of these databases
   967         -** is maintained in p->btreeMask and is used for locking and other purposes.
          967  +** attached databases that will be use.  A mask of these databases
          968  +** is maintained in p->btreeMask.  The p->lockMask value is the subset of
          969  +** p->btreeMask of databases that will require a lock.
   968    970   */
   969    971   void sqlite3VdbeUsesBtree(Vdbe *p, int i){
   970    972     assert( i>=0 && i<p->db->nDb && i<(int)sizeof(yDbMask)*8 );
   971    973     assert( i<(int)sizeof(p->btreeMask)*8 );
   972    974     p->btreeMask |= ((yDbMask)1)<<i;
   973    975     if( i!=1 && sqlite3BtreeSharable(p->db->aDb[i].pBt) ){
   974    976       p->lockMask |= ((yDbMask)1)<<i;

Changes to src/vdbemem.c.

   288    288   
   289    289   /*
   290    290   ** Release any memory held by the Mem. This may leave the Mem in an
   291    291   ** inconsistent state, for example with (Mem.z==0) and
   292    292   ** (Mem.type==SQLITE_TEXT).
   293    293   */
   294    294   void sqlite3VdbeMemRelease(Mem *p){
   295         -  MemReleaseExt(p);
          295  +  VdbeMemRelease(p);
   296    296     sqlite3DbFree(p->db, p->zMalloc);
   297    297     p->z = 0;
   298    298     p->zMalloc = 0;
   299    299     p->xDel = 0;
   300    300   }
   301    301   
   302    302   /*
................................................................................
   584    584   ** This routine prepares a memory cell for modication by breaking
   585    585   ** its link to a shallow copy and by marking any current shallow
   586    586   ** copies of this cell as invalid.
   587    587   **
   588    588   ** This is used for testing and debugging only - to make sure shallow
   589    589   ** copies are not misused.
   590    590   */
   591         -void sqlite3VdbeMemPrepareToChange(Vdbe *pVdbe, Mem *pMem){
          591  +void sqlite3VdbeMemAboutToChange(Vdbe *pVdbe, Mem *pMem){
   592    592     int i;
   593    593     Mem *pX;
   594    594     for(i=1, pX=&pVdbe->aMem[1]; i<=pVdbe->nMem; i++, pX++){
   595    595       if( pX->pScopyFrom==pMem ){
   596    596         pX->flags |= MEM_Invalid;
   597    597         pX->pScopyFrom = 0;
   598    598       }
................................................................................
   610    610   ** Make an shallow copy of pFrom into pTo.  Prior contents of
   611    611   ** pTo are freed.  The pFrom->z field is not duplicated.  If
   612    612   ** pFrom->z is used, then pTo->z points to the same thing as pFrom->z
   613    613   ** and flags gets srcType (either MEM_Ephem or MEM_Static).
   614    614   */
   615    615   void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
   616    616     assert( (pFrom->flags & MEM_RowSet)==0 );
   617         -  MemReleaseExt(pTo);
          617  +  VdbeMemRelease(pTo);
   618    618     memcpy(pTo, pFrom, MEMCELLSIZE);
   619    619     pTo->xDel = 0;
   620    620     if( (pFrom->flags&MEM_Static)==0 ){
   621    621       pTo->flags &= ~(MEM_Dyn|MEM_Static|MEM_Ephem);
   622    622       assert( srcType==MEM_Ephem || srcType==MEM_Static );
   623    623       pTo->flags |= srcType;
   624    624     }
................................................................................
   628    628   ** Make a full copy of pFrom into pTo.  Prior contents of pTo are
   629    629   ** freed before the copy is made.
   630    630   */
   631    631   int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
   632    632     int rc = SQLITE_OK;
   633    633   
   634    634     assert( (pFrom->flags & MEM_RowSet)==0 );
   635         -  MemReleaseExt(pTo);
          635  +  VdbeMemRelease(pTo);
   636    636     memcpy(pTo, pFrom, MEMCELLSIZE);
   637    637     pTo->flags &= ~MEM_Dyn;
   638    638   
   639    639     if( pTo->flags&(MEM_Str|MEM_Blob) ){
   640    640       if( 0==(pFrom->flags&MEM_Static) ){
   641    641         pTo->flags |= MEM_Ephem;
   642    642         rc = sqlite3VdbeMemMakeWriteable(pTo);