[sql] Import SQLite 3.17.0.

third_party/sqlite/src/ext/misc/spellfix.c

 /*
 ** 2012 April 10
 **
 ** The author disclaims copyright to this source code.  In place of
 ** a legal notice, here is a blessing:
 **
 **    May you do good and not evil.
 **    May you find forgiveness for yourself and forgive others.
 **    May you share freely, never taking more than you give.
 **
@@ skipping 168 matching lines @@
 **   * Omit T when followed by CH
 **   * Omit W when followed by R
 **   * Omit D when followed by J or G
 **   * Omit K in KN or G in GN at the beginning of a word
 **
 ** Space to hold the result is obtained from sqlite3_malloc()
 **
 ** Return NULL if memory allocation fails.  
 */
 static unsigned char *phoneticHash(const unsigned char *zIn, int nIn){
-  unsigned char *zOut = sqlite3_malloc( nIn + 1 );
+  unsigned char *zOut = sqlite3_malloc64( nIn + 1 );
   int i;
   int nOut = 0;
   char cPrev = 0x77;
   char cPrevX = 0x77;
   const unsigned char *aClass = initClass;
 
   if( zOut==0 ) return 0;
   if( nIn>2 ){
     switch( zIn[0] ){
       case 'g': 
@@ skipping 158 matching lines @@
   int xA, xB;            /* Loop counters for zA[] and zB[] */
   char cA = 0, cB;       /* Current character of zA and zB */
   char cAprev, cBprev;   /* Previous character of zA and zB */
   char cAnext, cBnext;   /* Next character in zA and zB */
   int d;                 /* North-west cost value */
   int dc = 0;            /* North-west character value */
   int res;               /* Final result */
   int *m;                /* The cost matrix */
   char *cx;              /* Corresponding character values */
   int *toFree = 0;       /* Malloced space */
+  int nMatch = 0;
   int mStack[60+15];     /* Stack space to use if not too much is needed */
-  int nMatch = 0;
 
   /* Early out if either input is NULL */
   if( zA==0 || zB==0 ) return -1;
 
   /* Skip any common prefix */
   while( zA[0] && zA[0]==zB[0] ){ dc = zA[0]; zA++; zB++; nMatch++; }
   if( pnMatch ) *pnMatch = nMatch;
   if( zA[0]==0 && zB[0]==0 ) return 0;
 
 #if 0
   printf("A=\"%s\" B=\"%s\" dc=%c\n", zA, zB, dc?dc:' ');
 #endif
 
   /* Verify input strings and measure their lengths */
   for(nA=0; zA[nA]; nA++){
     if( zA[nA]&0x80 ) return -2;
   }
   for(nB=0; zB[nB]; nB++){
     if( zB[nB]&0x80 ) return -2;
   }
 
   /* Special processing if either string is empty */
   if( nA==0 ){
-    cBprev = dc;
+    cBprev = (char)dc;
     for(xB=res=0; (cB = zB[xB])!=0; xB++){
       res += insertOrDeleteCost(cBprev, cB, zB[xB+1])/FINAL_INS_COST_DIV;
       cBprev = cB;
     }
     return res;
   }
   if( nB==0 ){
-    cAprev = dc;
+    cAprev = (char)dc;
     for(xA=res=0; (cA = zA[xA])!=0; xA++){
       res += insertOrDeleteCost(cAprev, cA, zA[xA+1]);
       cAprev = cA;
     }
     return res;
   }
 
   /* A is a prefix of B */
   if( zA[0]=='*' && zA[1]==0 ) return 0;
 
   /* Allocate and initialize the Wagner matrix */
   if( nB<(sizeof(mStack)*4)/(sizeof(mStack[0])*5) ){
     m = mStack;
   }else{
-    m = toFree = sqlite3_malloc( (nB+1)*5*sizeof(m[0])/4 );
+    m = toFree = sqlite3_malloc64( (nB+1)*5*sizeof(m[0])/4 );
     if( m==0 ) return -3;
   }
   cx = (char*)&m[nB+1];
 
   /* Compute the Wagner edit distance */
   m[0] = 0;
-  cx[0] = dc;
-  cBprev = dc;
+  cx[0] = (char)dc;
+  cBprev = (char)dc;
   for(xB=1; xB<=nB; xB++){
     cBnext = zB[xB];
     cB = zB[xB-1];
     cx[xB] = cB;
     m[xB] = m[xB-1] + insertOrDeleteCost(cBprev, cB, cBnext);
     cBprev = cB;
   }
-  cAprev = dc;
+  cAprev = (char)dc;
   for(xA=1; xA<=nA; xA++){
     int lastA = (xA==nA);
     cA = zA[xA-1];
     cAnext = zA[xA];
     if( cA=='*' && lastA ) break;
     d = m[0];
     dc = cx[0];
     m[0] = d + insertOrDeleteCost(cAprev, cA, cAnext);
     cBprev = 0;
     for(xB=1; xB<=nB; xB++){
@@ skipping 26 matching lines @@
       printf("%d,%d d=%4d u=%4d r=%4d dc=%c cA=%c cB=%c"
              " ins=%4d del=%4d sub=%4d t=%4d ncx=%c\n",
              xA, xB, d, m[xB], m[xB-1], dc?dc:' ', cA, cB,
              insCost, delCost, subCost, totalCost, ncx?ncx:' ');
 #endif
 
       /* Update the matrix */
       d = m[xB];
       dc = cx[xB];
       m[xB] = totalCost;
-      cx[xB] = ncx;
+      cx[xB] = (char)ncx;
       cBprev = cB;
     }
     cAprev = cA;
   }
 
   /* Free the wagner matrix and return the result */
   if( cA=='*' ){
     res = m[1];
     for(xB=1; xB<=nB; xB++){
       if( m[xB]<res ){
@@ skipping 190 matching lines @@
     const char *zTo = (const char*)sqlite3_column_text(pStmt, 2);
     int nTo = zTo ? sqlite3_column_bytes(pStmt, 2) : 0;
     int iCost = sqlite3_column_int(pStmt, 3);
 
     assert( zFrom!=0 || nFrom==0 );
     assert( zTo!=0 || nTo==0 );
     if( nFrom>100 || nTo>100 ) continue;
     if( iCost<0 ) continue;
     if( pLang==0 || iLang!=iLangPrev ){
       EditDist3Lang *pNew;
-      pNew = sqlite3_realloc(p->a, (p->nLang+1)*sizeof(p->a[0]));
+      pNew = sqlite3_realloc64(p->a, (p->nLang+1)*sizeof(p->a[0]));
       if( pNew==0 ){ rc = SQLITE_NOMEM; break; }
       p->a = pNew;
       pLang = &p->a[p->nLang];
       p->nLang++;
       pLang->iLang = iLang;
       pLang->iInsCost = 100;
       pLang->iDelCost = 100;
       pLang->iSubCost = 150;
       pLang->pCost = 0;
       iLangPrev = iLang;
     }
     if( nFrom==1 && zFrom[0]=='?' && nTo==0 ){
       pLang->iDelCost = iCost;
     }else if( nFrom==0 && nTo==1 && zTo[0]=='?' ){
       pLang->iInsCost = iCost;
     }else if( nFrom==1 && nTo==1 && zFrom[0]=='?' && zTo[0]=='?' ){
       pLang->iSubCost = iCost;
     }else{
       EditDist3Cost *pCost;
       int nExtra = nFrom + nTo - 4;
       if( nExtra<0 ) nExtra = 0;
-      pCost = sqlite3_malloc( sizeof(*pCost) + nExtra );
+      pCost = sqlite3_malloc64( sizeof(*pCost) + nExtra );
       if( pCost==0 ){ rc = SQLITE_NOMEM; break; }
-      pCost->nFrom = nFrom;
-      pCost->nTo = nTo;
-      pCost->iCost = iCost;
+      pCost->nFrom = (u8)nFrom;
+      pCost->nTo = (u8)nTo;
+      pCost->iCost = (u16)iCost;
       memcpy(pCost->a, zFrom, nFrom);
       memcpy(pCost->a + nFrom, zTo, nTo);
       pCost->pNext = pLang->pCost;
       pLang->pCost = pCost; 
     }
   }
   rc2 = sqlite3_finalize(pStmt);
   if( rc==SQLITE_OK ) rc = rc2;
   return rc;
 }
@@ skipping 74 matching lines @@
   const EditDist3Lang *pLang,
   const char *z,
   int n
 ){
   EditDist3FromString *pStr;
   EditDist3Cost *p;
   int i;
 
   if( z==0 ) return 0;
   if( n<0 ) n = (int)strlen(z);
-  pStr = sqlite3_malloc( sizeof(*pStr) + sizeof(pStr->a[0])*n + n + 1 );
+  pStr = sqlite3_malloc64( sizeof(*pStr) + sizeof(pStr->a[0])*n + n + 1 );
   if( pStr==0 ) return 0;
   pStr->a = (EditDist3From*)&pStr[1];
   memset(pStr->a, 0, sizeof(pStr->a[0])*n);
   pStr->n = n;
   pStr->z = (char*)&pStr->a[n];
   memcpy(pStr->z, z, n+1);
   if( n && z[n-1]=='*' ){
     pStr->isPrefix = 1;
     n--;
     pStr->n--;
     pStr->z[n] = 0;
   }else{
     pStr->isPrefix = 0;
   }
 
   for(i=0; i<n; i++){
     EditDist3From *pFrom = &pStr->a[i];
     memset(pFrom, 0, sizeof(*pFrom));
     pFrom->nByte = utf8Len((unsigned char)z[i], n-i);
     for(p=pLang->pCost; p; p=p->pNext){
       EditDist3Cost **apNew;
       if( i+p->nFrom>n ) continue;
       if( matchFrom(p, z+i, n-i)==0 ) continue;
       if( p->nTo==0 ){
-        apNew = sqlite3_realloc(pFrom->apDel,
+        apNew = sqlite3_realloc64(pFrom->apDel,
                                 sizeof(*apNew)*(pFrom->nDel+1));
         if( apNew==0 ) break;
         pFrom->apDel = apNew;
         apNew[pFrom->nDel++] = p;
       }else{
-        apNew = sqlite3_realloc(pFrom->apSubst,
+        apNew = sqlite3_realloc64(pFrom->apSubst,
                                 sizeof(*apNew)*(pFrom->nSubst+1));
         if( apNew==0 ) break;
         pFrom->apSubst = apNew;
         apNew[pFrom->nSubst++] = p;
       }
     }
     if( p ){
       editDist3FromStringDelete(pStr);
       pStr = 0;
       break;
@@ skipping 15 matching lines @@
   int j,
   int iCost
 ){
   assert( iCost>=0 );
   if( iCost<10000 ){
     unsigned int b = m[j] + iCost;
     if( b<m[i] ) m[i] = b;
   }
 }
 
+/*
+** How much stack space (int bytes) to use for Wagner matrix in 
+** editDist3Core().  If more space than this is required, the entire
+** matrix is taken from the heap.  To reduce the load on the memory
+** allocator, make this value as large as practical for the
+** architecture in use.
+*/
+#ifndef SQLITE_SPELLFIX_STACKALLOC_SZ
+# define SQLITE_SPELLFIX_STACKALLOC_SZ  (1024)
+#endif
+
 /* Compute the edit distance between two strings.
 **
 ** If an error occurs, return a negative number which is the error code.
 **
 ** If pnMatch is not NULL, then *pnMatch is set to the number of characters
 ** (not bytes) in z2 that matched the search pattern in *pFrom. If pFrom does
 ** not contain the pattern for a prefix-search, then this is always the number
 ** of characters in z2. If pFrom does contain a prefix search pattern, then
 ** it is the number of characters in the prefix of z2 that was deemed to 
 ** match pFrom.
 */
 static int editDist3Core(
   EditDist3FromString *pFrom,  /* The FROM string */
   const char *z2,              /* The TO string */
   int n2,                      /* Length of the TO string */
   const EditDist3Lang *pLang,  /* Edit weights for a particular language ID */
   int *pnMatch                 /* OUT: Characters in matched prefix */
 ){
   int k, n;
   int i1, b1;
   int i2, b2;
   EditDist3FromString f = *pFrom;
   EditDist3To *a2;
   unsigned int *m;
+  unsigned int *pToFree;
   int szRow;
   EditDist3Cost *p;
   int res;
+  sqlite3_uint64 nByte;
+  unsigned int stackSpace[SQLITE_SPELLFIX_STACKALLOC_SZ/sizeof(unsigned int)];
 
   /* allocate the Wagner matrix and the aTo[] array for the TO string */
   n = (f.n+1)*(n2+1);
   n = (n+1)&~1;
-  m = sqlite3_malloc( n*sizeof(m[0]) + sizeof(a2[0])*n2 );
-  if( m==0 ) return -1;            /* Out of memory */
+  nByte = n*sizeof(m[0]) + sizeof(a2[0])*n2;
+  if( nByte<=sizeof(stackSpace) ){
+    m = stackSpace;
+    pToFree = 0;
+  }else{
+    m = pToFree = sqlite3_malloc64( nByte );
+    if( m==0 ) return -1;            /* Out of memory */
+  }
   a2 = (EditDist3To*)&m[n];
   memset(a2, 0, sizeof(a2[0])*n2);
 
   /* Fill in the a1[] matrix for all characters of the TO string */
   for(i2=0; i2<n2; i2++){
     a2[i2].nByte = utf8Len((unsigned char)z2[i2], n2-i2);
     for(p=pLang->pCost; p; p=p->pNext){
       EditDist3Cost **apNew;
       if( p->nFrom>0 ) continue;
       if( i2+p->nTo>n2 ) continue;
       if( matchTo(p, z2+i2, n2-i2)==0 ) continue;
       a2[i2].nIns++;
-      apNew = sqlite3_realloc(a2[i2].apIns, sizeof(*apNew)*a2[i2].nIns);
+      apNew = sqlite3_realloc64(a2[i2].apIns, sizeof(*apNew)*a2[i2].nIns);
       if( apNew==0 ){
         res = -1;  /* Out of memory */
         goto editDist3Abort;
       }
       a2[i2].apIns = apNew;
       a2[i2].apIns[a2[i2].nIns-1] = p;
     }
   }
 
   /* Prepare to compute the minimum edit distance */
@@ skipping 88 matching lines @@
   if( pnMatch ){
     int nExtra = 0;
     for(k=0; k<n; k++){
       if( (z2[k] & 0xc0)==0x80 ) nExtra++;
     }
     *pnMatch = n - nExtra;
   }
 
 editDist3Abort:
   for(i2=0; i2<n2; i2++) sqlite3_free(a2[i2].apIns);
-  sqlite3_free(m);
+  sqlite3_free(pToFree);
   return res;
 }
 
 /*
 ** Get an appropriate EditDist3Lang object.
 */
 static const EditDist3Lang *editDist3FindLang(
   EditDist3Config *pConfig,
   int iLang
 ){
@@ skipping 48 matching lines @@
       sqlite3_result_int(context, dist);
     }
   } 
 }
 
 /*
 ** Register the editDist3 function with SQLite
 */
 static int editDist3Install(sqlite3 *db){
   int rc;
-  EditDist3Config *pConfig = sqlite3_malloc( sizeof(*pConfig) );
+  EditDist3Config *pConfig = sqlite3_malloc64( sizeof(*pConfig) );
   if( pConfig==0 ) return SQLITE_NOMEM;
   memset(pConfig, 0, sizeof(*pConfig));
   rc = sqlite3_create_function_v2(db, "editdist3",
               2, SQLITE_UTF8, pConfig, editDist3SqlFunc, 0, 0, 0);
   if( rc==SQLITE_OK ){
     rc = sqlite3_create_function_v2(db, "editdist3",
                 3, SQLITE_UTF8, pConfig, editDist3SqlFunc, 0, 0, 0);
   }
   if( rc==SQLITE_OK ){
     rc = sqlite3_create_function_v2(db, "editdist3",
@@ skipping 468 matching lines @@
 ** Convert the input string from UTF-8 into pure ASCII by converting
 ** all non-ASCII characters to some combination of characters in the
 ** ASCII subset.
 **
 ** The returned string might contain more characters than the input.
 **
 ** Space to hold the returned string comes from sqlite3_malloc() and
 ** should be freed by the caller.
 */
 static unsigned char *transliterate(const unsigned char *zIn, int nIn){
-  unsigned char *zOut = sqlite3_malloc( nIn*4 + 1 );
+  unsigned char *zOut = sqlite3_malloc64( nIn*4 + 1 );
   int c, sz, nOut;
   if( zOut==0 ) return 0;
   nOut = 0;
   while( nIn>0 ){
     c = utf8Read(zIn, nIn, &sz);
     zIn += sz;
     nIn -= sz;
     if( c<=127 ){
-      zOut[nOut++] = c;
+      zOut[nOut++] = (unsigned char)c;
     }else{
       int xTop, xBtm, x;
       xTop = sizeof(translit)/sizeof(translit[0]) - 1;
       xBtm = 0;
       while( xTop>=xBtm ){
         x = (xTop + xBtm)/2;
         if( translit[x].cFrom==c ){
           zOut[nOut++] = translit[x].cTo0;
           if( translit[x].cTo1 ){
             zOut[nOut++] = translit[x].cTo1;
@@ skipping 97 matching lines @@
 static void scriptCodeSqlFunc(
   sqlite3_context *context,
   int argc,
   sqlite3_value **argv
 ){
   const unsigned char *zIn = sqlite3_value_text(argv[0]);
   int nIn = sqlite3_value_bytes(argv[0]);
   int c, sz;
   int scriptMask = 0;
   int res;
+  int seenDigit = 0;
 # define SCRIPT_LATIN       0x0001
 # define SCRIPT_CYRILLIC    0x0002
 # define SCRIPT_GREEK       0x0004
 # define SCRIPT_HEBREW      0x0008
 # define SCRIPT_ARABIC      0x0010
 
   while( nIn>0 ){
     c = utf8Read(zIn, nIn, &sz);
     zIn += sz;
     nIn -= sz;
-    if( c<0x02af && (c>=0x80 || midClass[c&0x7f]<CCLASS_DIGIT) ){
-      scriptMask |= SCRIPT_LATIN;
+    if( c<0x02af ){
+      if( c>=0x80 || midClass[c&0x7f]<CCLASS_DIGIT ){
+        scriptMask |= SCRIPT_LATIN;
+      }else if( c>='0' && c<='9' ){
+        seenDigit = 1;
+      }
     }else if( c>=0x0400 && c<=0x04ff ){
       scriptMask |= SCRIPT_CYRILLIC;
     }else if( c>=0x0386 && c<=0x03ce ){
       scriptMask |= SCRIPT_GREEK;
     }else if( c>=0x0590 && c<=0x05ff ){
       scriptMask |= SCRIPT_HEBREW;
     }else if( c>=0x0600 && c<=0x06ff ){
       scriptMask |= SCRIPT_ARABIC;
     }
   }
+  if( scriptMask==0 && seenDigit ) scriptMask = SCRIPT_LATIN;
   switch( scriptMask ){
     case 0:                res = 999; break;
     case SCRIPT_LATIN:     res = 215; break;
     case SCRIPT_CYRILLIC:  res = 220; break;
     case SCRIPT_GREEK:     res = 200; break;
     case SCRIPT_HEBREW:    res = 125; break;
     case SCRIPT_ARABIC:    res = 160; break;
     default:               res = 998; break;
   }
   sqlite3_result_int(context, res);
 }
 
 /* End transliterate
 ******************************************************************************
 ******************************************************************************
 ** Begin spellfix1 virtual table.
 */
 
 /* Maximum length of a phonehash used for querying the shadow table */
-#define SPELLFIX_MX_HASH  8
+#define SPELLFIX_MX_HASH  32
 
 /* Maximum number of hash strings to examine per query */
 #define SPELLFIX_MX_RUN   1
 
 typedef struct spellfix1_vtab spellfix1_vtab;
 typedef struct spellfix1_cursor spellfix1_cursor;
 
 /* Fuzzy-search virtual table object */
 struct spellfix1_vtab {
   sqlite3_vtab base;         /* Base class - must be first */
@@ skipping 134 matching lines @@
 ){
   spellfix1_vtab *pNew = 0;
   /* const char *zModule = argv[0]; // not used */
   const char *zDbName = argv[1];
   const char *zTableName = argv[2];
   int nDbName;
   int rc = SQLITE_OK;
   int i;
 
   nDbName = (int)strlen(zDbName);
-  pNew = sqlite3_malloc( sizeof(*pNew) + nDbName + 1);
+  pNew = sqlite3_malloc64( sizeof(*pNew) + nDbName + 1);
   if( pNew==0 ){
     rc = SQLITE_NOMEM;
   }else{
     memset(pNew, 0, sizeof(*pNew));
     pNew->zDbName = (char*)&pNew[1];
     memcpy(pNew->zDbName, zDbName, nDbName+1);
     pNew->zTableName = sqlite3_mprintf("%s", zTableName);
     pNew->db = db;
     if( pNew->zTableName==0 ){
       rc = SQLITE_NOMEM;
@@ skipping 93 matching lines @@
     pCur->pFullScan = 0;
   }
 }
 
 /*
 ** Resize the cursor to hold up to N rows of content
 */
 static void spellfix1ResizeCursor(spellfix1_cursor *pCur, int N){
   struct spellfix1_row *aNew;
   assert( N>=pCur->nRow );
-  aNew = sqlite3_realloc(pCur->a, sizeof(pCur->a[0])*N);
+  aNew = sqlite3_realloc64(pCur->a, sizeof(pCur->a[0])*N);
   if( aNew==0 && N>0 ){
     spellfix1ResetCursor(pCur);
     sqlite3_free(pCur->a);
     pCur->nAlloc = 0;
     pCur->a = 0;
   }else{
     pCur->nAlloc = N;
     pCur->a = aNew;
   }
 }
@@ skipping 138 matching lines @@
   }
   return SQLITE_OK;
 }
 
 /*
 ** Open a new fuzzy-search cursor.
 */
 static int spellfix1Open(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
   spellfix1_vtab *p = (spellfix1_vtab*)pVTab;
   spellfix1_cursor *pCur;
-  pCur = sqlite3_malloc( sizeof(*pCur) );
+  pCur = sqlite3_malloc64( sizeof(*pCur) );
   if( pCur==0 ) return SQLITE_NOMEM;
   memset(pCur, 0, sizeof(*pCur));
   pCur->pVTab = p;
   *ppCursor = &pCur->base;
   return SQLITE_OK;
 }
 
 /*
 ** Adjust a distance measurement by the words rank in order to show
 ** preference to common words.
 */
 static int spellfix1Score(int iDistance, int iRank){
   int iLog2;
   for(iLog2=0; iRank>0; iLog2++, iRank>>=1){}
   return iDistance + 32 - iLog2;
 }
 
 /*
 ** Compare two spellfix1_row objects for sorting purposes in qsort() such
 ** that they sort in order of increasing distance.
 */
-static int spellfix1RowCompare(const void *A, const void *B){
+static int SQLITE_CDECL spellfix1RowCompare(const void *A, const void *B){
   const struct spellfix1_row *a = (const struct spellfix1_row*)A;
   const struct spellfix1_row *b = (const struct spellfix1_row*)B;
   return a->iScore - b->iScore;
 }
 
 /*
 ** A structure used to pass information from spellfix1FilterForMatch()
 ** into spellfix1RunQuery().
 */
 typedef struct MatchQuery {
@@ skipping 171 matching lines @@
   int iLang = 0;                     /* Language code */
   char *zSql;                        /* SQL of shadow table query */
   sqlite3_stmt *pStmt = 0;           /* Shadow table query */
   int rc;                            /* Result code */
   int idx = 1;                       /* Next available filter parameter */
   spellfix1_vtab *p = pCur->pVTab;   /* The virtual table that owns pCur */
   MatchQuery x;                      /* For passing info to RunQuery() */
 
   /* Load the cost table if we have not already done so */
   if( p->zCostTable!=0 && p->pConfig3==0 ){
-    p->pConfig3 = sqlite3_malloc( sizeof(p->pConfig3[0]) );
+    p->pConfig3 = sqlite3_malloc64( sizeof(p->pConfig3[0]) );
     if( p->pConfig3==0 ) return SQLITE_NOMEM;
     memset(p->pConfig3, 0, sizeof(p->pConfig3[0]));
     rc = editDist3ConfigLoad(p->pConfig3, p->db, p->zCostTable);
     if( rc ) return rc;
   }
   memset(&x, 0, sizeof(x));
   x.iScope = 3;  /* Default scope if none specified by "WHERE scope=N" */
   x.iMaxDist = -1;   /* Maximum allowed edit distance */
 
   if( idxNum&2 ){
@@ skipping 499 matching lines @@
   sqlite3 *db, 
   char **pzErrMsg, 
   const sqlite3_api_routines *pApi
 ){
   SQLITE_EXTENSION_INIT2(pApi);
 #ifndef SQLITE_OMIT_VIRTUALTABLE
   return spellfix1Register(db);
 #endif
   return SQLITE_OK;
 }