Add //third_party/sqlite to dirs_to_snapshot, remove net_sql.patch

third_party/sqlite/src/ext/fts2/fts2.c

 /* fts2 has a design flaw which can lead to database corruption (see
 ** below).  It is recommended not to use it any longer, instead use
 ** fts3 (or higher).  If you believe that your use of fts2 is safe,
 ** add -DSQLITE_ENABLE_BROKEN_FTS2=1 to your CFLAGS.
 */
 #if (!defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS2)) \
         && !defined(SQLITE_ENABLE_BROKEN_FTS2)
 #error fts2 has a design flaw and has been deprecated.
 #endif
 /* The flaw is that fts2 uses the content table's unaliased rowid as
@@ skipping 306 matching lines @@
 #endif
 
 #include <assert.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include "fts2.h"
 #include "fts2_hash.h"
 #include "fts2_tokenizer.h"
 #include "sqlite3.h"
-#ifndef SQLITE_CORE 
+#ifndef SQLITE_CORE
 # include "sqlite3ext.h"
   SQLITE_EXTENSION_INIT1
 #endif
 
 
 /* TODO(shess) MAN, this thing needs some refactoring.  At minimum, it
 ** would be nice to order the file better, perhaps something along the
 ** lines of:
 **
 **  - utility functions
@@ skipping 3420 matching lines @@
      * sets isPrefix correctly, but since that code doesn't eat the '*', the
      * ICU tokenizer returns it as the next token.  So eat it here until a
      * better solution presents itself.
      */
     if( pQuery->nTerms>0 && nToken==1 && pSegment[iBegin]=='*' &&
         iEndLast==iBegin){
       pQuery->pTerms[pQuery->nTerms-1].isPrefix = 1;
       continue;
     }
     iEndLast = iEnd;
-    
+
     queryAdd(pQuery, pToken, nToken);
     if( !inPhrase && iBegin>0 && pSegment[iBegin-1]=='-' ){
       pQuery->pTerms[pQuery->nTerms-1].isNot = 1;
     }
     if( iEnd<nSegment && pSegment[iEnd]=='*' ){
       pQuery->pTerms[pQuery->nTerms-1].isPrefix = 1;
     }
     pQuery->pTerms[pQuery->nTerms-1].iPhrase = nTerm;
     if( inPhrase ){
       nTerm++;
@@ skipping 1502 matching lines @@
 
 /* loadSegmentLeaves() may not read all the way to SQLITE_DONE, thus
 ** leaving the statement handle open, which locks the table.
 */
 /* TODO(shess) This "solution" is not satisfactory.  Really, there
 ** should be check-in function for all statement handles which
 ** arranges to call sqlite3_reset().  This most likely will require
 ** modification to control flow all over the place, though, so for now
 ** just punt.
 **
-** Note the the current system assumes that segment merges will run to
+** Note the current system assumes that segment merges will run to
 ** completion, which is why this particular probably hasn't arisen in
 ** this case.  Probably a brittle assumption.
 */
 static int leavesReaderReset(LeavesReader *pReader){
   return sqlite3_reset(pReader->pStmt);
 }
 
 static void leavesReaderDestroy(LeavesReader *pReader){
   /* If idx is -1, that means we're using a non-cached statement
   ** handle in the optimize() case, so we need to release it.
@@ skipping 243 matching lines @@
     if( pData==NULL ){
       rc = SQLITE_CORRUPT_BKPT;
       break;
     }
     rc = dlrInit(&dlReaders[i], DL_DEFAULT,
                  pData,
                  leavesReaderDataBytes(pReaders+i));
     if( rc!=SQLITE_OK ) break;
   }
   if( rc!=SQLITE_OK ){
-    while( i-->0 ){ 
+    while( i-->0 ){
       dlrDestroy(&dlReaders[i]);
     }
     return rc;
   }
 
   return leafWriterStepMerge(v, pWriter, pTerm, nTerm, dlReaders, nReaders);
 }
 
 /* Forward ref due to mutual recursion with segdirNextIndex(). */
 static int segmentMerge(fulltext_vtab *v, int iLevel);
@@ skipping 1328 matching lines @@
 */
 static void createDoclistResult(sqlite3_context *pContext,
                                 const char *pData, int nData){
   DataBuffer dump;
   DLReader dlReader;
   int rc;
 
   assert( pData!=NULL && nData>0 );
 
   rc = dlrInit(&dlReader, DL_DEFAULT, pData, nData);
-  if( rc!=SQLITE_OK ) return rc;
+  if( rc!=SQLITE_OK ) return;
   dataBufferInit(&dump, 0);
   for( ; rc==SQLITE_OK && !dlrAtEnd(&dlReader); rc = dlrStep(&dlReader) ){
     char buf[256];
     PLReader plReader;
 
     rc = plrInit(&plReader, &dlReader);
     if( rc!=SQLITE_OK ) break;
     if( DL_DEFAULT==DL_DOCIDS || plrAtEnd(&plReader) ){
       sqlite3_snprintf(sizeof(buf), buf, "[%lld] ", dlrDocid(&dlReader));
       dataBufferAppend(&dump, buf, strlen(buf));
@@ skipping 30 matching lines @@
 
       assert( dump.nData>0 );
       dump.nData--;                     /* Overwrite trailing space. */
       assert( dump.pData[dump.nData]==' ');
       dataBufferAppend(&dump, "]] ", 3);
     }
   }
   dlrDestroy(&dlReader);
   if( rc!=SQLITE_OK ){
     dataBufferDestroy(&dump);
-    return rc;
+    return;
   }
 
   assert( dump.nData>0 );
   dump.nData--;                     /* Overwrite trailing space. */
   assert( dump.pData[dump.nData]==' ');
   dump.pData[dump.nData] = '\0';
   assert( dump.nData>0 );
 
   /* Passes ownership of dump's buffer to pContext. */
   sqlite3_result_text(pContext, dump.pData, dump.nData, sqlite3_free);
   dump.pData = NULL;
   dump.nData = dump.nCapacity = 0;
-  return SQLITE_OK;
 }
 
 /* Implements dump_doclist() for use in inspecting the fts2 index from
 ** tests.  TEXT result containing a string representation of the
 ** doclist for the indicated term.  dump_doclist(t, term, level, idx)
 ** dumps the doclist for term from the segment specified by level, idx
 ** (in %_segdir), while dump_doclist(t, term) dumps the logical
 ** doclist for the term across all segments.  The per-segment doclist
 ** can contain deletions, while the full-index doclist will not
 ** (deletions are omitted).
@@ skipping 221 matching lines @@
 ** Function ...PorterTokenizerModule() sets *pModule to point to the
 ** porter tokenizer/stemmer implementation.
 */
 void sqlite3Fts2SimpleTokenizerModule(sqlite3_tokenizer_module const**ppModule);
 void sqlite3Fts2PorterTokenizerModule(sqlite3_tokenizer_module const**ppModule);
 void sqlite3Fts2IcuTokenizerModule(sqlite3_tokenizer_module const**ppModule);
 
 int sqlite3Fts2InitHashTable(sqlite3 *, fts2Hash *, const char *);
 
 /*
-** Initialise the fts2 extension. If this extension is built as part
+** Initialize the fts2 extension. If this extension is built as part
 ** of the sqlite library, then this function is called directly by
 ** SQLite. If fts2 is built as a dynamically loadable extension, this
 ** function is called by the sqlite3_extension_init() entry point.
 */
 int sqlite3Fts2Init(sqlite3 *db){
   int rc = SQLITE_OK;
   fts2Hash *pHash = 0;
   const sqlite3_tokenizer_module *pSimple = 0;
   const sqlite3_tokenizer_module *pPorter = 0;
   const sqlite3_tokenizer_module *pIcu = 0;
 
   sqlite3Fts2SimpleTokenizerModule(&pSimple);
   sqlite3Fts2PorterTokenizerModule(&pPorter);
 #ifdef SQLITE_ENABLE_ICU
   sqlite3Fts2IcuTokenizerModule(&pIcu);
 #endif
 
-  /* Allocate and initialise the hash-table used to store tokenizers. */
+  /* Allocate and initialize the hash-table used to store tokenizers. */
   pHash = sqlite3_malloc(sizeof(fts2Hash));
   if( !pHash ){
     rc = SQLITE_NOMEM;
   }else{
     sqlite3Fts2HashInit(pHash, FTS2_HASH_STRING, 1);
   }
 
   /* Load the built-in tokenizers into the hash table */
   if( rc==SQLITE_OK ){
     if( sqlite3Fts2HashInsert(pHash, "simple", 7, (void *)pSimple)
@@ skipping 30 matching lines @@
   /* An error has occurred. Delete the hash table and return the error code. */
   assert( rc!=SQLITE_OK );
   if( pHash ){
     sqlite3Fts2HashClear(pHash);
     sqlite3_free(pHash);
   }
   return rc;
 }
 
 #if !SQLITE_CORE
-int sqlite3_extension_init(
+#ifdef _WIN32
+__declspec(dllexport)
+#endif
+int sqlite3_fts2_init(
   sqlite3 *db, 
   char **pzErrMsg,
   const sqlite3_api_routines *pApi
 ){
   SQLITE_EXTENSION_INIT2(pApi)
   return sqlite3Fts2Init(db);
 }
 #endif
 
 #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS2) */