File indexing completed on 2024-04-28 15:58:54

 /* This file is part of the KDE project
    Copyright (C) 2015 Jarosław Staniek <staniek@kde.org>
 
    Contains portions of sqlite3.c licensed under public domain. The author disclaims
    copyright to this source code.
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this program; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "SqliteFunctions.h"
 
 #include <QDebug>
 
 #include <cctype>
 
 /*
 ** Integers of known sizes.  These typedefs might change for architectures
 ** where the sizes very.  Preprocessor macros are available so that the
 ** types can be conveniently redefined at compile-type.  Like this:
 **
 **         cc '-DUINTPTR_TYPE=long long int' ...
 */
 #ifndef UINT32_TYPE
 # ifdef HAVE_UINT32_T
 #  define UINT32_TYPE uint32_t
 # else
 #  define UINT32_TYPE unsigned int
 # endif
 #endif
 #ifndef UINT16_TYPE
 # ifdef HAVE_UINT16_T
 #  define UINT16_TYPE uint16_t
 # else
 #  define UINT16_TYPE unsigned short int
 # endif
 #endif
 #ifndef INT16_TYPE
 # ifdef HAVE_INT16_T
 #  define INT16_TYPE int16_t
 # else
 #  define INT16_TYPE short int
 # endif
 #endif
 #ifndef UINT8_TYPE
 # ifdef HAVE_UINT8_T
 #  define UINT8_TYPE uint8_t
 # else
 #  define UINT8_TYPE unsigned char
 # endif
 #endif
 #ifndef INT8_TYPE
 # ifdef HAVE_INT8_T
 #  define INT8_TYPE int8_t
 # else
 #  define INT8_TYPE signed char
 # endif
 #endif
 #ifndef LONGDOUBLE_TYPE
 # define LONGDOUBLE_TYPE long double
 #endif
 typedef sqlite_int64 i64;          /* 8-byte signed integer */
 typedef sqlite_uint64 u64;         /* 8-byte unsigned integer */
 typedef UINT32_TYPE u32;           /* 4-byte unsigned integer */
 typedef UINT16_TYPE u16;           /* 2-byte unsigned integer */
 typedef INT16_TYPE i16;            /* 2-byte signed integer */
 typedef UINT8_TYPE u8;             /* 1-byte unsigned integer */
 typedef INT8_TYPE i8;              /* 1-byte signed integer */
 
 static bool tryExec(sqlite3 *db, const char *sql)
 {
     return SQLITE_OK == sqlite3_exec(db, sql, nullptr /*callback*/,
                                      nullptr /* 1st argument to callback */, nullptr /*err*/);
 }
 
 // BEGIN from sqlite3.c
 #define sqlite3Toupper(x)   toupper((unsigned char)(x))
 #define sqlite3Isalpha(x)   isalpha((unsigned char)(x))
 
 /*
 ** Compute the soundex encoding of a word.
 **
 ** IMP: R-59782-00072 The soundex(X) function returns a string that is the
 ** soundex encoding of the string X.
 */
 static void soundexFunc(
   sqlite3_context *context,
   int argc,
   sqlite3_value **argv
 ){
   char zResult[8];
   const u8 *zIn;
   int i, j;
   static const unsigned char iCode[] = {
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
     1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
     0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
     1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
   };
   assert( argc==1 );
   zIn = (u8*)sqlite3_value_text(argv[0]);
   if( zIn==0 ) zIn = (u8*)"";
   for(i=0; zIn[i] && !sqlite3Isalpha(zIn[i]); i++){}
   if( zIn[i] ){
     u8 prevcode = iCode[zIn[i]&0x7f];
     zResult[0] = sqlite3Toupper(zIn[i]);
     for(j=1; j<4 && zIn[i]; i++){
       int code = iCode[zIn[i]&0x7f];
       if( code>0 ){
         if( code!=prevcode ){
           prevcode = code;
           zResult[j++] = code + '0';
         }
       }else{
         prevcode = 0;
       }
     }
     while( j<4 ){
       zResult[j++] = '0';
     }
     zResult[j] = 0;
     sqlite3_result_text(context, zResult, 4, SQLITE_TRANSIENT);
   }else{
     /* IMP: R-64894-50321 The string "?000" is returned if the argument
     ** is NULL or contains no ASCII alphabetic characters. */
     sqlite3_result_text(context, "?000", 4, SQLITE_STATIC);
   }
 }
 
 bool createCustomSQLiteFunctions(sqlite3 *db)
 {
     int eTextRep = SQLITE_UTF8;
 #if SQLITE_VERSION_NUMBER >= 3008003
     eTextRep |= SQLITE_DETERMINISTIC;
 #endif
     if (!tryExec(db, "SELECT SOUNDEX()")) {
         int res = sqlite3_create_function_v2(
             db,
             "SOUNDEX",
             1, //nArg
             eTextRep,
             nullptr, // pApp
             soundexFunc,
             nullptr, // xStep
             nullptr, // xFinal
             nullptr // xDestroy
         );
         if (res != SQLITE_OK) {
             return false;
         }
     }
     return true;
 }
 
 // END from sqlite3.c