• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2 *******************************************************************************
3 *   Copyright (C) 2001-2011, International Business Machines
4 *   Corporation and others.  All Rights Reserved.
5 *******************************************************************************
6 *   file name:  bocsu.cpp
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 #include "unicode/bytestream.h"
20 
21 #if !UCONFIG_NO_COLLATION
22 
23 #include "bocsu.h"
24 
25 /*
26  * encode one difference value -0x10ffff..+0x10ffff in 1..3 bytes,
27  * preserving lexical order
28  */
29 U_CFUNC uint8_t *
u_writeDiff(int32_t diff,uint8_t * p)30 u_writeDiff(int32_t diff, uint8_t *p) {
31     if(diff>=SLOPE_REACH_NEG_1) {
32         if(diff<=SLOPE_REACH_POS_1) {
33             *p++=(uint8_t)(SLOPE_MIDDLE+diff);
34         } else if(diff<=SLOPE_REACH_POS_2) {
35             *p++=(uint8_t)(SLOPE_START_POS_2+(diff/SLOPE_TAIL_COUNT));
36             *p++=(uint8_t)(SLOPE_MIN+diff%SLOPE_TAIL_COUNT);
37         } else if(diff<=SLOPE_REACH_POS_3) {
38             p[2]=(uint8_t)(SLOPE_MIN+diff%SLOPE_TAIL_COUNT);
39             diff/=SLOPE_TAIL_COUNT;
40             p[1]=(uint8_t)(SLOPE_MIN+diff%SLOPE_TAIL_COUNT);
41             *p=(uint8_t)(SLOPE_START_POS_3+(diff/SLOPE_TAIL_COUNT));
42             p+=3;
43         } else {
44             p[3]=(uint8_t)(SLOPE_MIN+diff%SLOPE_TAIL_COUNT);
45             diff/=SLOPE_TAIL_COUNT;
46             p[2]=(uint8_t)(SLOPE_MIN+diff%SLOPE_TAIL_COUNT);
47             diff/=SLOPE_TAIL_COUNT;
48             p[1]=(uint8_t)(SLOPE_MIN+diff%SLOPE_TAIL_COUNT);
49             *p=SLOPE_MAX;
50             p+=4;
51         }
52     } else {
53         int32_t m;
54 
55         if(diff>=SLOPE_REACH_NEG_2) {
56             NEGDIVMOD(diff, SLOPE_TAIL_COUNT, m);
57             *p++=(uint8_t)(SLOPE_START_NEG_2+diff);
58             *p++=(uint8_t)(SLOPE_MIN+m);
59         } else if(diff>=SLOPE_REACH_NEG_3) {
60             NEGDIVMOD(diff, SLOPE_TAIL_COUNT, m);
61             p[2]=(uint8_t)(SLOPE_MIN+m);
62             NEGDIVMOD(diff, SLOPE_TAIL_COUNT, m);
63             p[1]=(uint8_t)(SLOPE_MIN+m);
64             *p=(uint8_t)(SLOPE_START_NEG_3+diff);
65             p+=3;
66         } else {
67             NEGDIVMOD(diff, SLOPE_TAIL_COUNT, m);
68             p[3]=(uint8_t)(SLOPE_MIN+m);
69             NEGDIVMOD(diff, SLOPE_TAIL_COUNT, m);
70             p[2]=(uint8_t)(SLOPE_MIN+m);
71             NEGDIVMOD(diff, SLOPE_TAIL_COUNT, m);
72             p[1]=(uint8_t)(SLOPE_MIN+m);
73             *p=SLOPE_MIN;
74             p+=4;
75         }
76     }
77     return p;
78 }
79 
80 /*
81  * Encode the code points of a string as
82  * a sequence of byte-encoded differences (slope detection),
83  * preserving lexical order.
84  *
85  * Optimize the difference-taking for runs of Unicode text within
86  * small scripts:
87  *
88  * Most small scripts are allocated within aligned 128-blocks of Unicode
89  * code points. Lexical order is preserved if "prev" is always moved
90  * into the middle of such a block.
91  *
92  * Additionally, "prev" is moved from anywhere in the Unihan
93  * area into the middle of that area.
94  * Note that the identical-level run in a sort key is generated from
95  * NFD text - there are never Hangul characters included.
96  */
97 U_CFUNC void
u_writeIdenticalLevelRun(const UChar * s,int32_t length,U_NAMESPACE_QUALIFIER ByteSink & sink)98 u_writeIdenticalLevelRun(const UChar *s, int32_t length, U_NAMESPACE_QUALIFIER ByteSink &sink) {
99     char scratch[64];
100     int32_t capacity;
101 
102     UChar32 prev=0;
103     int32_t i=0;
104     while(i<length) {
105         char *buffer=sink.GetAppendBuffer(1, length*2, scratch, (int32_t)sizeof(scratch), &capacity);
106         uint8_t *p;
107         // We must have capacity>=SLOPE_MAX_BYTES in case u_writeDiff() writes that much,
108         // but we do not want to force the sink.GetAppendBuffer() to allocate
109         // for a large min_capacity because we might actually only write one byte.
110         if(capacity<16) {
111             buffer=scratch;
112             capacity=(int32_t)sizeof(scratch);
113         }
114         p=reinterpret_cast<uint8_t *>(buffer);
115         uint8_t *lastSafe=p+capacity-SLOPE_MAX_BYTES;
116         while(i<length && p<=lastSafe) {
117             if(prev<0x4e00 || prev>=0xa000) {
118                 prev=(prev&~0x7f)-SLOPE_REACH_NEG_1;
119             } else {
120                 /*
121                  * Unihan U+4e00..U+9fa5:
122                  * double-bytes down from the upper end
123                  */
124                 prev=0x9fff-SLOPE_REACH_POS_2;
125             }
126 
127             UChar32 c;
128             U16_NEXT(s, i, length, c);
129             p=u_writeDiff(c-prev, p);
130             prev=c;
131         }
132         sink.Append(buffer, (int32_t)(p-reinterpret_cast<uint8_t *>(buffer)));
133     }
134 }
135 
136 U_CFUNC int32_t
u_writeIdenticalLevelRunTwoChars(UChar32 first,UChar32 second,uint8_t * p)137 u_writeIdenticalLevelRunTwoChars(UChar32 first, UChar32 second, uint8_t *p) {
138     uint8_t *p0 = p;
139     if(first<0x4e00 || first>=0xa000) {
140         first=(first&~0x7f)-SLOPE_REACH_NEG_1;
141     } else {
142         /*
143          * Unihan U+4e00..U+9fa5:
144          * double-bytes down from the upper end
145          */
146         first=0x9fff-SLOPE_REACH_POS_2;
147     }
148 
149     p=u_writeDiff(second-first, p);
150     return (int32_t)(p-p0);
151 }
152 
153 #endif /* #if !UCONFIG_NO_COLLATION */
154