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