icuSources/i18n/bocsu.c

   1 /*
   2 *******************************************************************************
   3 *   Copyright (C) 2001-2003, International Business Machines
   4 *   Corporation and others.  All Rights Reserved.
   5 *******************************************************************************
   6 *   file name:  bocsu.c
   7 *   encoding:   US-ASCII
   8 *   tab size:   8 (not used)
   9 *   indentation:4
  10 *
  11 *   Author: Markus W. Scherer
  12 *
  13 *   Modification history:
  14 *   05/18/2001  weiv    Made into separate module
  15 */
  16
  17
  18 #include "unicode/utypes.h"
  19
  20 #if !UCONFIG_NO_COLLATION
  21
  22 #include "bocsu.h"
  23
  24 /*
  25  * encode one difference value -0x10ffff..+0x10ffff in 1..3 bytes,
  26  * preserving lexical order
  27  */
  28 U_CFUNC uint8_t *
  29 u_writeDiff(int32_t diff, uint8_t *p) {
  30     if(diff>=SLOPE_REACH_NEG_1) {
  31         if(diff<=SLOPE_REACH_POS_1) {
  32             *p++=(uint8_t)(SLOPE_MIDDLE+diff);
  33         } else if(diff<=SLOPE_REACH_POS_2) {
  34             *p++=(uint8_t)(SLOPE_START_POS_2+(diff/SLOPE_TAIL_COUNT));
  35             *p++=(uint8_t)(SLOPE_MIN+diff%SLOPE_TAIL_COUNT);
  36         } else if(diff<=SLOPE_REACH_POS_3) {
  37             p[2]=(uint8_t)(SLOPE_MIN+diff%SLOPE_TAIL_COUNT);
  38             diff/=SLOPE_TAIL_COUNT;
  39             p[1]=(uint8_t)(SLOPE_MIN+diff%SLOPE_TAIL_COUNT);
  40             *p=(uint8_t)(SLOPE_START_POS_3+(diff/SLOPE_TAIL_COUNT));
  41             p+=3;
  42         } else {
  43             p[3]=(uint8_t)(SLOPE_MIN+diff%SLOPE_TAIL_COUNT);
  44             diff/=SLOPE_TAIL_COUNT;
  45             p[2]=(uint8_t)(SLOPE_MIN+diff%SLOPE_TAIL_COUNT);
  46             diff/=SLOPE_TAIL_COUNT;
  47             p[1]=(uint8_t)(SLOPE_MIN+diff%SLOPE_TAIL_COUNT);
  48             *p=SLOPE_MAX;
  49             p+=4;
  50         }
  51     } else {
  52         int32_t m;
  53
  54         if(diff>=SLOPE_REACH_NEG_2) {
  55             NEGDIVMOD(diff, SLOPE_TAIL_COUNT, m);
  56             *p++=(uint8_t)(SLOPE_START_NEG_2+diff);
  57             *p++=(uint8_t)(SLOPE_MIN+m);
  58         } else if(diff>=SLOPE_REACH_NEG_3) {
  59             NEGDIVMOD(diff, SLOPE_TAIL_COUNT, m);
  60             p[2]=(uint8_t)(SLOPE_MIN+m);
  61             NEGDIVMOD(diff, SLOPE_TAIL_COUNT, m);
  62             p[1]=(uint8_t)(SLOPE_MIN+m);
  63             *p=(uint8_t)(SLOPE_START_NEG_3+diff);
  64             p+=3;
  65         } else {
  66             NEGDIVMOD(diff, SLOPE_TAIL_COUNT, m);
  67             p[3]=(uint8_t)(SLOPE_MIN+m);
  68             NEGDIVMOD(diff, SLOPE_TAIL_COUNT, m);
  69             p[2]=(uint8_t)(SLOPE_MIN+m);
  70             NEGDIVMOD(diff, SLOPE_TAIL_COUNT, m);
  71             p[1]=(uint8_t)(SLOPE_MIN+m);
  72             *p=SLOPE_MIN;
  73             p+=4;
  74         }
  75     }
  76     return p;
  77 }
  78
  79 /* How many bytes would writeDiff() write? */
  80 static int32_t
  81 lengthOfDiff(int32_t diff) {
  82     if(diff>=SLOPE_REACH_NEG_1) {
  83         if(diff<=SLOPE_REACH_POS_1) {
  84             return 1;
  85         } else if(diff<=SLOPE_REACH_POS_2) {
  86             return 2;
  87         } else if(diff<=SLOPE_REACH_POS_3) {
  88             return 3;
  89         } else {
  90             return 4;
  91         }
  92     } else {
  93         if(diff>=SLOPE_REACH_NEG_2) {
  94             return 2;
  95         } else if(diff>=SLOPE_REACH_NEG_3) {
  96             return 3;
  97         } else {
  98             return 4;
  99         }
 100     }
 101 }
 102
 103 /*
 104  * Encode the code points of a string as
 105  * a sequence of byte-encoded differences (slope detection),
 106  * preserving lexical order.
 107  *
 108  * Optimize the difference-taking for runs of Unicode text within
 109  * small scripts:
 110  *
 111  * Most small scripts are allocated within aligned 128-blocks of Unicode
 112  * code points. Lexical order is preserved if "prev" is always moved
 113  * into the middle of such a block.
 114  *
 115  * Additionally, "prev" is moved from anywhere in the Unihan
 116  * area into the middle of that area.
 117  * Note that the identical-level run in a sort key is generated from
 118  * NFD text - there are never Hangul characters included.
 119  */
 120 U_CFUNC int32_t
 121 u_writeIdenticalLevelRun(const UChar *s, int32_t length, uint8_t *p) {
 122     uint8_t *p0;
 123     int32_t c, prev;
 124     int32_t i;
 125
 126     prev=0;
 127     p0=p;
 128     i=0;
 129     while(i<length) {
 130         if(prev<0x4e00 || prev>=0xa000) {
 131             prev=(prev&~0x7f)-SLOPE_REACH_NEG_1;
 132         } else {
 133             /*
 134              * Unihan U+4e00..U+9fa5:
 135              * double-bytes down from the upper end
 136              */
 137             prev=0x9fff-SLOPE_REACH_POS_2;
 138         }
 139
 140         UTF_NEXT_CHAR(s, i, length, c);
 141         p=u_writeDiff(c-prev, p);
 142         prev=c;
 143     }
 144     return (int32_t)(p-p0);
 145 }
 146
 147 U_CFUNC int32_t
 148 u_writeIdenticalLevelRunTwoChars(UChar32 first, UChar32 second, uint8_t *p) {
 149     uint8_t *p0 = p;
 150     if(first<0x4e00 || first>=0xa000) {
 151         first=(first&~0x7f)-SLOPE_REACH_NEG_1;
 152     } else {
 153         /*
 154          * Unihan U+4e00..U+9fa5:
 155          * double-bytes down from the upper end
 156          */
 157         first=0x9fff-SLOPE_REACH_POS_2;
 158     }
 159
 160     p=u_writeDiff(second-first, p);
 161     return (int32_t)(p-p0);
 162 }
 163
 164 /* How many bytes would writeIdenticalLevelRun() write? */
 165 U_CFUNC int32_t
 166 u_lengthOfIdenticalLevelRun(const UChar *s, int32_t length) {
 167     int32_t c, prev;
 168     int32_t i, runLength;
 169
 170     prev=0;
 171     runLength=0;
 172     i=0;
 173     while(i<length) {
 174         if(prev<0x4e00 || prev>=0xa000) {
 175             prev=(prev&~0x7f)-SLOPE_REACH_NEG_1;
 176         } else {
 177             /*
 178              * Unihan U+4e00..U+9fa5:
 179              * double-bytes down from the upper end
 180              */
 181             prev=0x9fff-SLOPE_REACH_POS_2;
 182         }
 183
 184         UTF_NEXT_CHAR(s, i, length, c);
 185         runLength+=lengthOfDiff(c-prev);
 186         prev=c;
 187     }
 188     return runLength;
 189 }
 190
 191 #endif /* #if !UCONFIG_NO_COLLATION */