[sql] Import reference version of SQLite 3.10.2.

third_party/sqlite/sqlite-src-3100200/ext/fts5/fts5_unicode2.c

 /*
 ** 2012 May 25
 **
 ** 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.
 **
 ******************************************************************************
 */
 
 /*
 ** DO NOT EDIT THIS MACHINE GENERATED FILE.
 */
 
-#ifndef SQLITE_DISABLE_FTS3_UNICODE
-#if defined(SQLITE_ENABLE_FTS3) || defined(SQLITE_ENABLE_FTS4)
 
 #include <assert.h>
 
 /*
 ** Return true if the argument corresponds to a unicode codepoint
 ** classified as either a letter or a number. Otherwise false.
 **
 ** The results are undefined if the value passed to this function
 ** is less than zero.
 */
-int sqlite3FtsUnicodeIsalnum(int c){
+int sqlite3Fts5UnicodeIsalnum(int c){
   /* Each unsigned integer in the following array corresponds to a contiguous
   ** range of unicode codepoints that are not either letters or numbers (i.e.
   ** codepoints for which this function should return 0).
   **
   ** The most significant 22 bits in each 32-bit value contain the first 
   ** codepoint in the range. The least significant 10 bits are used to store
   ** the size of the range (always at least 1). In other words, the value 
   ** ((C<<22) + N) represents a range of N codepoints starting with codepoint 
   ** C. It is not possible to represent a range larger than 1023 codepoints 
   ** using this format.
@@ skipping 111 matching lines @@
 
 
 /*
 ** If the argument is a codepoint corresponding to a lowercase letter
 ** in the ASCII range with a diacritic added, return the codepoint
 ** of the ASCII letter only. For example, if passed 235 - "LATIN
 ** SMALL LETTER E WITH DIAERESIS" - return 65 ("LATIN SMALL LETTER
 ** E"). The resuls of passing a codepoint that corresponds to an
 ** uppercase letter are undefined.
 */
-static int remove_diacritic(int c){
+static int fts5_remove_diacritic(int c){
   unsigned short aDia[] = {
         0,  1797,  1848,  1859,  1891,  1928,  1940,  1995, 
      2024,  2040,  2060,  2110,  2168,  2206,  2264,  2286, 
      2344,  2383,  2472,  2488,  2516,  2596,  2668,  2732, 
      2782,  2842,  2894,  2954,  2984,  3000,  3028,  3336, 
      3456,  3696,  3712,  3728,  3744,  3896,  3912,  3928, 
      3968,  4008,  4040,  4106,  4138,  4170,  4202,  4234, 
      4266,  4296,  4312,  4344,  4408,  4424,  4472,  4504, 
      6148,  6198,  6264,  6280,  6360,  6429,  6505,  6529, 
     61448, 61468, 61534, 61592, 61642, 61688, 61704, 61726, 
@@ skipping 29 matching lines @@
   }
   assert( key>=aDia[iRes] );
   return ((c > (aDia[iRes]>>3) + (aDia[iRes]&0x07)) ? c : (int)aChar[iRes]);
 }
 
 
 /*
 ** Return true if the argument interpreted as a unicode codepoint
 ** is a diacritical modifier character.
 */
-int sqlite3FtsUnicodeIsdiacritic(int c){
+int sqlite3Fts5UnicodeIsdiacritic(int c){
   unsigned int mask0 = 0x08029FDF;
   unsigned int mask1 = 0x000361F8;
   if( c<768 || c>817 ) return 0;
   return (c < 768+32) ?
       (mask0 & (1 << (c-768))) :
       (mask1 & (1 << (c-768-32)));
 }
 
 
 /*
 ** Interpret the argument as a unicode codepoint. If the codepoint
 ** is an upper case character that has a lower case equivalent,
 ** return the codepoint corresponding to the lower case version.
 ** Otherwise, return a copy of the argument.
 **
 ** The results are undefined if the value passed to this function
 ** is less than zero.
 */
-int sqlite3FtsUnicodeFold(int c, int bRemoveDiacritic){
+int sqlite3Fts5UnicodeFold(int c, int bRemoveDiacritic){
   /* Each entry in the following array defines a rule for folding a range
   ** of codepoints to lower case. The rule applies to a range of nRange
   ** codepoints starting at codepoint iCode.
   **
   ** If the least significant bit in flags is clear, then the rule applies
   ** to all nRange codepoints (i.e. all nRange codepoints are upper case and
   ** need to be folded). Or, if it is set, then the rule only applies to
   ** every second codepoint in the range, starting with codepoint C.
   **
   ** The 7 most significant bits in flags are an index into the aiOff[]
@@ skipping 73 matching lines @@
    775,   7264,  10792, 10795, 23228, 23256, 30204, 54721, 
    54753, 54754, 54756, 54787, 54793, 54809, 57153, 57274, 
    57921, 58019, 58363, 61722, 65268, 65341, 65373, 65406, 
    65408, 65410, 65415, 65424, 65436, 65439, 65450, 65462, 
    65472, 65476, 65478, 65480, 65482, 65488, 65506, 65511, 
    65514, 65521, 65527, 65528, 65529, 
   };
 
   int ret = c;
 
-  assert( c>=0 );
   assert( sizeof(unsigned short)==2 && sizeof(unsigned char)==1 );
 
   if( c<128 ){
     if( c>='A' && c<='Z' ) ret = c + ('a' - 'A');
   }else if( c<65536 ){
+    const struct TableEntry *p;
     int iHi = sizeof(aEntry)/sizeof(aEntry[0]) - 1;
     int iLo = 0;
     int iRes = -1;
 
+    assert( c>aEntry[0].iCode );
     while( iHi>=iLo ){
       int iTest = (iHi + iLo) / 2;
       int cmp = (c - aEntry[iTest].iCode);
       if( cmp>=0 ){
         iRes = iTest;
         iLo = iTest+1;
       }else{
         iHi = iTest-1;
       }
     }
-    assert( iRes<0 || c>=aEntry[iRes].iCode );
 
-    if( iRes>=0 ){
-      const struct TableEntry *p = &aEntry[iRes];
-      if( c<(p->iCode + p->nRange) && 0==(0x01 & p->flags & (p->iCode ^ c)) ){
-        ret = (c + (aiOff[p->flags>>1])) & 0x0000FFFF;
-        assert( ret>0 );
-      }
+    assert( iRes>=0 && c>=aEntry[iRes].iCode );
+    p = &aEntry[iRes];
+    if( c<(p->iCode + p->nRange) && 0==(0x01 & p->flags & (p->iCode ^ c)) ){
+      ret = (c + (aiOff[p->flags>>1])) & 0x0000FFFF;
+      assert( ret>0 );
     }
 
-    if( bRemoveDiacritic ) ret = remove_diacritic(ret);
+    if( bRemoveDiacritic ) ret = fts5_remove_diacritic(ret);
   }
   
   else if( c>=66560 && c<66600 ){
     ret = c + 40;
   }
 
   return ret;
 }
-#endif /* defined(SQLITE_ENABLE_FTS3) || defined(SQLITE_ENABLE_FTS4) */
-#endif /* !defined(SQLITE_DISABLE_FTS3_UNICODE) */