1 /*
2 ******************************************************************************
3 *
4 * Copyright (C) 2000-2011, International Business Machines
5 * Corporation and others. All Rights Reserved.
6 *
7 ******************************************************************************
8 * file name: ushape.c
9 * encoding: US-ASCII
10 * tab size: 8 (not used)
11 * indentation:4
12 *
13 * created on: 2000jun29
14 * created by: Markus W. Scherer
15 *
16 * Arabic letter shaping implemented by Ayman Roshdy
17 */
18
19 #include "unicode/utypes.h"
20 #include "unicode/uchar.h"
21 #include "unicode/ustring.h"
22 #include "unicode/ushape.h"
23 #include "cmemory.h"
24 #include "putilimp.h"
25 #include "ustr_imp.h"
26 #include "ubidi_props.h"
27
28 #if UTF_SIZE<16
29 /*
30 * This implementation assumes that the internal encoding is UTF-16
31 * or UTF-32, not UTF-8.
32 * The main assumption is that the Arabic characters and their
33 * presentation forms each fit into a single UChar.
34 * With UTF-8, they occupy 2 or 3 bytes, and more than the ASCII
35 * characters.
36 */
37 # error This implementation assumes UTF-16 or UTF-32 (check UTF_SIZE)
38 #endif
39
40 /*
41 * ### TODO in general for letter shaping:
42 * - the letter shaping code is UTF-16-unaware; needs update
43 * + especially invertBuffer()?!
44 * - needs to handle the "Arabic Tail" that is used in some legacy codepages
45 * as a glyph fragment of wide-glyph letters
46 * + IBM Unicode conversion tables map it to U+200B (ZWSP)
47 * + IBM Egypt has proposed to encode the tail in Unicode among Arabic Presentation Forms
48 */
49
50 /* definitions for Arabic letter shaping ------------------------------------ */
51
52 #define IRRELEVANT 4
53 #define LAMTYPE 16
54 #define ALEFTYPE 32
55 #define LINKR 1
56 #define LINKL 2
57 #define APRESENT 8
58 #define SHADDA 64
59 #define CSHADDA 128
60 #define COMBINE (SHADDA+CSHADDA)
61
62 #define HAMZAFE_CHAR 0xfe80
63 #define HAMZA06_CHAR 0x0621
64 #define YEH_HAMZA_CHAR 0x0626
65 #define YEH_HAMZAFE_CHAR 0xFE89
66 #define LAMALEF_SPACE_SUB 0xFFFF
67 #define TASHKEEL_SPACE_SUB 0xFFFE
68 #define NEW_TAIL_CHAR 0xFE73
69 #define OLD_TAIL_CHAR 0x200B
70 #define LAM_CHAR 0x0644
71 #define SPACE_CHAR 0x0020
72 #define SHADDA_CHAR 0xFE7C
73 #define TATWEEL_CHAR 0x0640
74 #define SHADDA_TATWEEL_CHAR 0xFE7D
75
76 #define SHAPE_MODE 0
77 #define DESHAPE_MODE 1
78
79 static UChar tailChar = OLD_TAIL_CHAR;
80 static uint32_t uShapeLamalefBegin = U_SHAPE_LAMALEF_BEGIN;
81 static uint32_t uShapeLamalefEnd = U_SHAPE_LAMALEF_END;
82 static uint32_t uShapeTashkeelBegin = U_SHAPE_TASHKEEL_BEGIN;
83 static uint32_t uShapeTashkeelEnd = U_SHAPE_TASHKEEL_END;
84 static int spacesRelativeToTextBeginEnd = 0;
85
86 static const uint8_t tailFamilyIsolatedFinal[] = {
87 /* FEB1 */ 1,
88 /* FEB2 */ 1,
89 /* FEB3 */ 0,
90 /* FEB4 */ 0,
91 /* FEB5 */ 1,
92 /* FEB6 */ 1,
93 /* FEB7 */ 0,
94 /* FEB8 */ 0,
95 /* FEB9 */ 1,
96 /* FEBA */ 1,
97 /* FEBB */ 0,
98 /* FEBC */ 0,
99 /* FEBD */ 1,
100 /* FEBE */ 1
101 };
102
103 static const uint8_t tashkeelMedial[] = {
104 /* FE70 */ 0,
105 /* FE71 */ 1,
106 /* FE72 */ 0,
107 /* FE73 */ 0,
108 /* FE74 */ 0,
109 /* FE75 */ 0,
110 /* FE76 */ 0,
111 /* FE77 */ 1,
112 /* FE78 */ 0,
113 /* FE79 */ 1,
114 /* FE7A */ 0,
115 /* FE7B */ 1,
116 /* FE7C */ 0,
117 /* FE7D */ 1,
118 /* FE7E */ 0,
119 /* FE7F */ 1
120 };
121
122 static const UChar yehHamzaToYeh[] =
123 {
124 /* isolated*/ 0xFEEF,
125 /* final */ 0xFEF0
126 };
127
128 static const uint8_t IrrelevantPos[] = {
129 0x0, 0x2, 0x4, 0x6,
130 0x8, 0xA, 0xC, 0xE
131 };
132
133
134 static const UChar convertLamAlef[] =
135 {
136 /*FEF5*/ 0x0622,
137 /*FEF6*/ 0x0622,
138 /*FEF7*/ 0x0623,
139 /*FEF8*/ 0x0623,
140 /*FEF9*/ 0x0625,
141 /*FEFA*/ 0x0625,
142 /*FEFB*/ 0x0627,
143 /*FEFC*/ 0x0627
144 };
145
146 static const UChar araLink[178]=
147 {
148 1 + 32 + 256 * 0x11,/*0x0622*/
149 1 + 32 + 256 * 0x13,/*0x0623*/
150 1 + 256 * 0x15,/*0x0624*/
151 1 + 32 + 256 * 0x17,/*0x0625*/
152 1 + 2 + 256 * 0x19,/*0x0626*/
153 1 + 32 + 256 * 0x1D,/*0x0627*/
154 1 + 2 + 256 * 0x1F,/*0x0628*/
155 1 + 256 * 0x23,/*0x0629*/
156 1 + 2 + 256 * 0x25,/*0x062A*/
157 1 + 2 + 256 * 0x29,/*0x062B*/
158 1 + 2 + 256 * 0x2D,/*0x062C*/
159 1 + 2 + 256 * 0x31,/*0x062D*/
160 1 + 2 + 256 * 0x35,/*0x062E*/
161 1 + 256 * 0x39,/*0x062F*/
162 1 + 256 * 0x3B,/*0x0630*/
163 1 + 256 * 0x3D,/*0x0631*/
164 1 + 256 * 0x3F,/*0x0632*/
165 1 + 2 + 256 * 0x41,/*0x0633*/
166 1 + 2 + 256 * 0x45,/*0x0634*/
167 1 + 2 + 256 * 0x49,/*0x0635*/
168 1 + 2 + 256 * 0x4D,/*0x0636*/
169 1 + 2 + 256 * 0x51,/*0x0637*/
170 1 + 2 + 256 * 0x55,/*0x0638*/
171 1 + 2 + 256 * 0x59,/*0x0639*/
172 1 + 2 + 256 * 0x5D,/*0x063A*/
173 0, 0, 0, 0, 0, /*0x063B-0x063F*/
174 1 + 2, /*0x0640*/
175 1 + 2 + 256 * 0x61,/*0x0641*/
176 1 + 2 + 256 * 0x65,/*0x0642*/
177 1 + 2 + 256 * 0x69,/*0x0643*/
178 1 + 2 + 16 + 256 * 0x6D,/*0x0644*/
179 1 + 2 + 256 * 0x71,/*0x0645*/
180 1 + 2 + 256 * 0x75,/*0x0646*/
181 1 + 2 + 256 * 0x79,/*0x0647*/
182 1 + 256 * 0x7D,/*0x0648*/
183 1 + 256 * 0x7F,/*0x0649*/
184 1 + 2 + 256 * 0x81,/*0x064A*/
185 4 + 256 * 1, /*0x064B*/
186 4 + 128 + 256 * 1, /*0x064C*/
187 4 + 128 + 256 * 1, /*0x064D*/
188 4 + 128 + 256 * 1, /*0x064E*/
189 4 + 128 + 256 * 1, /*0x064F*/
190 4 + 128 + 256 * 1, /*0x0650*/
191 4 + 64 + 256 * 3, /*0x0651*/
192 4 + 256 * 1, /*0x0652*/
193 4 + 256 * 7, /*0x0653*/
194 4 + 256 * 8, /*0x0654*/
195 4 + 256 * 8, /*0x0655*/
196 4 + 256 * 1, /*0x0656*/
197 0, 0, 0, 0, 0, /*0x0657-0x065B*/
198 1 + 256 * 0x85,/*0x065C*/
199 1 + 256 * 0x87,/*0x065D*/
200 1 + 256 * 0x89,/*0x065E*/
201 1 + 256 * 0x8B,/*0x065F*/
202 0, 0, 0, 0, 0, /*0x0660-0x0664*/
203 0, 0, 0, 0, 0, /*0x0665-0x0669*/
204 0, 0, 0, 0, 0, 0, /*0x066A-0x066F*/
205 4 + 256 * 6, /*0x0670*/
206 1 + 8 + 256 * 0x00,/*0x0671*/
207 1 + 32, /*0x0672*/
208 1 + 32, /*0x0673*/
209 0, /*0x0674*/
210 1 + 32, /*0x0675*/
211 1, 1, /*0x0676-0x0677*/
212 1+2, 1+2, 1+2, 1+2, 1+2, 1+2, /*0x0678-0x067D*/
213 1+2+8+256 * 0x06, 1+2, 1+2, 1+2, 1+2, 1+2, /*0x067E-0x0683*/
214 1+2, 1+2, 1+2+8+256 * 0x2A, 1+2, /*0x0684-0x0687*/
215 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /*0x0688-0x0691*/
216 1, 1, 1, 1, 1, 1, 1+8+256 * 0x3A, 1, /*0x0692-0x0699*/
217 1+2, 1+2, 1+2, 1+2, 1+2, 1+2, /*0x069A-0x06A3*/
218 1+2, 1+2, 1+2, 1+2, /*0x069A-0x06A3*/
219 1+2, 1+2, 1+2, 1+2, 1+2, 1+2+8+256 * 0x3E, /*0x06A4-0x06AD*/
220 1+2, 1+2, 1+2, 1+2, /*0x06A4-0x06AD*/
221 1+2, 1+2+8+256 * 0x42, 1+2, 1+2, 1+2, 1+2, /*0x06AE-0x06B7*/
222 1+2, 1+2, 1+2, 1+2, /*0x06AE-0x06B7*/
223 1+2, 1+2, 1+2, 1+2, 1+2, 1+2, /*0x06B8-0x06BF*/
224 1+2, 1+2, /*0x06B8-0x06BF*/
225 1, /*0x06C0*/
226 1+2, /*0x06C1*/
227 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /*0x06C2-0x06CB*/
228 1+2+8+256 * 0xAC, /*0x06CC*/
229 1, /*0x06CD*/
230 1+2, 1+2, 1+2, 1+2, /*0x06CE-0x06D1*/
231 1, 1 /*0x06D2-0x06D3*/
232 };
233
234 static const uint8_t presALink[] = {
235 /***********0*****1*****2*****3*****4*****5*****6*****7*****8*****9*****A*****B*****C*****D*****E*****F*/
236 /*FB5*/ 0, 1, 0, 0, 0, 0, 0, 1, 2,1 + 2, 0, 0, 0, 0, 0, 0,
237 /*FB6*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
238 /*FB7*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2,1 + 2, 0, 0,
239 /*FB8*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1,
240 /*FB9*/ 2,1 + 2, 0, 1, 2,1 + 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
241 /*FBA*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
242 /*FBB*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
243 /*FBC*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
244 /*FBD*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
245 /*FBE*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
246 /*FBF*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2,1 + 2,
247 /*FC0*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
248 /*FC1*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
249 /*FC2*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
250 /*FC3*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
251 /*FC4*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
252 /*FC5*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4,
253 /*FC6*/ 4, 4, 4
254 };
255
256 static const uint8_t presBLink[]=
257 {
258 /***********0*****1*****2*****3*****4*****5*****6*****7*****8*****9*****A*****B*****C*****D*****E*****F*/
259 /*FE7*/1 + 2,1 + 2,1 + 2, 0,1 + 2, 0,1 + 2,1 + 2,1 + 2,1 + 2,1 + 2,1 + 2,1 + 2,1 + 2,1 + 2,1 + 2,
260 /*FE8*/ 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2,1 + 2, 0, 1, 0,
261 /*FE9*/ 1, 2,1 + 2, 0, 1, 0, 1, 2,1 + 2, 0, 1, 2,1 + 2, 0, 1, 2,
262 /*FEA*/1 + 2, 0, 1, 2,1 + 2, 0, 1, 2,1 + 2, 0, 1, 0, 1, 0, 1, 0,
263 /*FEB*/ 1, 0, 1, 2,1 + 2, 0, 1, 2,1 + 2, 0, 1, 2,1 + 2, 0, 1, 2,
264 /*FEC*/1 + 2, 0, 1, 2,1 + 2, 0, 1, 2,1 + 2, 0, 1, 2,1 + 2, 0, 1, 2,
265 /*FED*/1 + 2, 0, 1, 2,1 + 2, 0, 1, 2,1 + 2, 0, 1, 2,1 + 2, 0, 1, 2,
266 /*FEE*/1 + 2, 0, 1, 2,1 + 2, 0, 1, 2,1 + 2, 0, 1, 2,1 + 2, 0, 1, 0,
267 /*FEF*/ 1, 0, 1, 2,1 + 2, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0
268 };
269
270 static const UChar convertFBto06[] =
271 {
272 /***********0******1******2******3******4******5******6******7******8******9******A******B******C******D******E******F***/
273 /*FB5*/ 0x671, 0x671, 0, 0, 0, 0, 0x07E, 0x07E, 0x07E, 0x07E, 0, 0, 0, 0, 0, 0,
274 /*FB6*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
275 /*FB7*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x686, 0x686, 0x686, 0x686, 0, 0,
276 /*FB8*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x698, 0x698, 0, 0, 0x6A9, 0x6A9,
277 /*FB9*/ 0x6A9, 0x6A9, 0x6AF, 0x6AF, 0x6AF, 0x6AF, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
278 /*FBA*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
279 /*FBB*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
280 /*FBC*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
281 /*FBD*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
282 /*FBE*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
283 /*FBF*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x6CC, 0x6CC, 0x6CC, 0x6CC
284 };
285
286 static const UChar convertFEto06[] =
287 {
288 /***********0******1******2******3******4******5******6******7******8******9******A******B******C******D******E******F***/
289 /*FE7*/ 0x64B, 0x64B, 0x64C, 0x64C, 0x64D, 0x64D, 0x64E, 0x64E, 0x64F, 0x64F, 0x650, 0x650, 0x651, 0x651, 0x652, 0x652,
290 /*FE8*/ 0x621, 0x622, 0x622, 0x623, 0x623, 0x624, 0x624, 0x625, 0x625, 0x626, 0x626, 0x626, 0x626, 0x627, 0x627, 0x628,
291 /*FE9*/ 0x628, 0x628, 0x628, 0x629, 0x629, 0x62A, 0x62A, 0x62A, 0x62A, 0x62B, 0x62B, 0x62B, 0x62B, 0x62C, 0x62C, 0x62C,
292 /*FEA*/ 0x62C, 0x62D, 0x62D, 0x62D, 0x62D, 0x62E, 0x62E, 0x62E, 0x62E, 0x62F, 0x62F, 0x630, 0x630, 0x631, 0x631, 0x632,
293 /*FEB*/ 0x632, 0x633, 0x633, 0x633, 0x633, 0x634, 0x634, 0x634, 0x634, 0x635, 0x635, 0x635, 0x635, 0x636, 0x636, 0x636,
294 /*FEC*/ 0x636, 0x637, 0x637, 0x637, 0x637, 0x638, 0x638, 0x638, 0x638, 0x639, 0x639, 0x639, 0x639, 0x63A, 0x63A, 0x63A,
295 /*FED*/ 0x63A, 0x641, 0x641, 0x641, 0x641, 0x642, 0x642, 0x642, 0x642, 0x643, 0x643, 0x643, 0x643, 0x644, 0x644, 0x644,
296 /*FEE*/ 0x644, 0x645, 0x645, 0x645, 0x645, 0x646, 0x646, 0x646, 0x646, 0x647, 0x647, 0x647, 0x647, 0x648, 0x648, 0x649,
297 /*FEF*/ 0x649, 0x64A, 0x64A, 0x64A, 0x64A, 0x65C, 0x65C, 0x65D, 0x65D, 0x65E, 0x65E, 0x65F, 0x65F
298 };
299
300 static const uint8_t shapeTable[4][4][4]=
301 {
302 { {0,0,0,0}, {0,0,0,0}, {0,1,0,3}, {0,1,0,1} },
303 { {0,0,2,2}, {0,0,1,2}, {0,1,1,2}, {0,1,1,3} },
304 { {0,0,0,0}, {0,0,0,0}, {0,1,0,3}, {0,1,0,3} },
305 { {0,0,1,2}, {0,0,1,2}, {0,1,1,2}, {0,1,1,3} }
306 };
307
308 /*
309 * This function shapes European digits to Arabic-Indic digits
310 * in-place, writing over the input characters.
311 * Since we know that we are only looking for BMP code points,
312 * we can safely just work with code units (again, at least UTF-16).
313 */
314 static void
_shapeToArabicDigitsWithContext(UChar * s,int32_t length,UChar digitBase,UBool isLogical,UBool lastStrongWasAL)315 _shapeToArabicDigitsWithContext(UChar *s, int32_t length,
316 UChar digitBase,
317 UBool isLogical, UBool lastStrongWasAL) {
318 const UBiDiProps *bdp;
319 int32_t i;
320 UChar c;
321
322 bdp=ubidi_getSingleton();
323 digitBase-=0x30;
324
325 /* the iteration direction depends on the type of input */
326 if(isLogical) {
327 for(i=0; i<length; ++i) {
328 c=s[i];
329 switch(ubidi_getClass(bdp, c)) {
330 case U_LEFT_TO_RIGHT: /* L */
331 case U_RIGHT_TO_LEFT: /* R */
332 lastStrongWasAL=FALSE;
333 break;
334 case U_RIGHT_TO_LEFT_ARABIC: /* AL */
335 lastStrongWasAL=TRUE;
336 break;
337 case U_EUROPEAN_NUMBER: /* EN */
338 if(lastStrongWasAL && (uint32_t)(c-0x30)<10) {
339 s[i]=(UChar)(digitBase+c); /* digitBase+(c-0x30) - digitBase was modified above */
340 }
341 break;
342 default :
343 break;
344 }
345 }
346 } else {
347 for(i=length; i>0; /* pre-decrement in the body */) {
348 c=s[--i];
349 switch(ubidi_getClass(bdp, c)) {
350 case U_LEFT_TO_RIGHT: /* L */
351 case U_RIGHT_TO_LEFT: /* R */
352 lastStrongWasAL=FALSE;
353 break;
354 case U_RIGHT_TO_LEFT_ARABIC: /* AL */
355 lastStrongWasAL=TRUE;
356 break;
357 case U_EUROPEAN_NUMBER: /* EN */
358 if(lastStrongWasAL && (uint32_t)(c-0x30)<10) {
359 s[i]=(UChar)(digitBase+c); /* digitBase+(c-0x30) - digitBase was modified above */
360 }
361 break;
362 default :
363 break;
364 }
365 }
366 }
367 }
368
369 /*
370 *Name : invertBuffer
371 *Function : This function inverts the buffer, it's used
372 * in case the user specifies the buffer to be
373 * U_SHAPE_TEXT_DIRECTION_LOGICAL
374 */
375 static void
376 /* BEGIN android-changed */
invertBuffer(UChar * buffer,int32_t size,uint64_t options,int32_t lowlimit,int32_t highlimit)377 invertBuffer(UChar *buffer,int32_t size,uint64_t options,int32_t lowlimit,int32_t highlimit) {
378 /* END android-changed */
379 UChar temp;
380 int32_t i=0,j=0;
381 for(i=lowlimit,j=size-highlimit-1;i<j;i++,j--) {
382 temp = buffer[i];
383 buffer[i] = buffer[j];
384 buffer[j] = temp;
385 }
386 }
387
388 /*
389 *Name : changeLamAlef
390 *Function : Converts the Alef characters into an equivalent
391 * LamAlef location in the 0x06xx Range, this is an
392 * intermediate stage in the operation of the program
393 * later it'll be converted into the 0xFExx LamAlefs
394 * in the shaping function.
395 */
396 static U_INLINE UChar
changeLamAlef(UChar ch)397 changeLamAlef(UChar ch) {
398 switch(ch) {
399 case 0x0622 :
400 return 0x065C;
401 case 0x0623 :
402 return 0x065D;
403 case 0x0625 :
404 return 0x065E;
405 case 0x0627 :
406 return 0x065F;
407 }
408 return 0;
409 }
410
411 /*
412 *Name : getLink
413 *Function : Resolves the link between the characters as
414 * Arabic characters have four forms :
415 * Isolated, Initial, Middle and Final Form
416 */
417 static UChar
getLink(UChar ch)418 getLink(UChar ch) {
419 if(ch >= 0x0622 && ch <= 0x06D3) {
420 return(araLink[ch-0x0622]);
421 } else if(ch == 0x200D) {
422 return(3);
423 } else if(ch >= 0x206D && ch <= 0x206F) {
424 return(4);
425 }else if(ch >= 0xFB50 && ch <= 0xFC62) {
426 return(presALink[ch-0xFB50]);
427 } else if(ch >= 0xFE70 && ch <= 0xFEFC) {
428 return(presBLink[ch-0xFE70]);
429 }else {
430 return(0);
431 }
432 }
433
434 /*
435 *Name : countSpaces
436 *Function : Counts the number of spaces
437 * at each end of the logical buffer
438 */
439 static void
440 /* BEGIN android-changed */
countSpaces(UChar * dest,int32_t size,uint64_t options,int32_t * spacesCountl,int32_t * spacesCountr)441 countSpaces(UChar *dest,int32_t size,uint64_t options,int32_t *spacesCountl,int32_t *spacesCountr) {
442 /* END android-changed */
443 int32_t i = 0;
444 int32_t countl = 0,countr = 0;
445 while(dest[i] == SPACE_CHAR) {
446 countl++;
447 i++;
448 }
449 while(dest[size-1] == SPACE_CHAR) {
450 countr++;
451 size--;
452 }
453 *spacesCountl = countl;
454 *spacesCountr = countr;
455 }
456
457 /*
458 *Name : isTashkeelChar
459 *Function : Returns 1 for Tashkeel characters in 06 range else return 0
460 */
461 static U_INLINE int32_t
isTashkeelChar(UChar ch)462 isTashkeelChar(UChar ch) {
463 return (int32_t)( ch>=0x064B && ch<= 0x0652 );
464 }
465
466 /*
467 *Name : isTashkeelCharFE
468 *Function : Returns 1 for Tashkeel characters in FE range else return 0
469 */
470 static U_INLINE int32_t
isTashkeelCharFE(UChar ch)471 isTashkeelCharFE(UChar ch) {
472 return (int32_t)( ch>=0xFE70 && ch<= 0xFE7F );
473 }
474
475 /*
476 *Name : isAlefChar
477 *Function : Returns 1 for Alef characters else return 0
478 */
479 static U_INLINE int32_t
isAlefChar(UChar ch)480 isAlefChar(UChar ch) {
481 return (int32_t)( (ch==0x0622)||(ch==0x0623)||(ch==0x0625)||(ch==0x0627) );
482 }
483
484 /*
485 *Name : isLamAlefChar
486 *Function : Returns 1 for LamAlef characters else return 0
487 */
488 static U_INLINE int32_t
isLamAlefChar(UChar ch)489 isLamAlefChar(UChar ch) {
490 return (int32_t)((ch>=0xFEF5)&&(ch<=0xFEFC) );
491 }
492
493 /*BIDI
494 *Name : isTailChar
495 *Function : returns 1 if the character matches one of the tail characters (0xfe73 or 0x200b) otherwise returns 0
496 */
497
498 static U_INLINE int32_t
isTailChar(UChar ch)499 isTailChar(UChar ch) {
500 if(ch == OLD_TAIL_CHAR || ch == NEW_TAIL_CHAR){
501 return 1;
502 }else{
503 return 0;
504 }
505 }
506
507 /*BIDI
508 *Name : isSeenTailFamilyChar
509 *Function : returns 1 if the character is a seen family isolated character
510 * in the FE range otherwise returns 0
511 */
512
513 static U_INLINE int32_t
isSeenTailFamilyChar(UChar ch)514 isSeenTailFamilyChar(UChar ch) {
515 if(ch >= 0xfeb1 && ch < 0xfebf){
516 return tailFamilyIsolatedFinal [ch - 0xFEB1];
517 }else{
518 return 0;
519 }
520 }
521
522 /* Name : isSeenFamilyChar
523 * Function : returns 1 if the character is a seen family character in the Unicode
524 * 06 range otherwise returns 0
525 */
526
527 static U_INLINE int32_t
isSeenFamilyChar(UChar ch)528 isSeenFamilyChar(UChar ch){
529 if(ch >= 0x633 && ch <= 0x636){
530 return 1;
531 }else {
532 return 0;
533 }
534 }
535
536 /*Start of BIDI*/
537 /*
538 *Name : isAlefMaksouraChar
539 *Function : returns 1 if the character is a Alef Maksoura Final or isolated
540 * otherwise returns 0
541 */
542 static U_INLINE int32_t
isAlefMaksouraChar(UChar ch)543 isAlefMaksouraChar(UChar ch) {
544 return (int32_t)( (ch == 0xFEEF) || ( ch == 0xFEF0) || (ch == 0x0649));
545 }
546
547 /*
548 * Name : isYehHamzaChar
549 * Function : returns 1 if the character is a yehHamza isolated or yehhamza
550 * final is found otherwise returns 0
551 */
552 static U_INLINE int32_t
isYehHamzaChar(UChar ch)553 isYehHamzaChar(UChar ch) {
554 if((ch==0xFE89)||(ch==0xFE8A)){
555 return 1;
556 }else{
557 return 0;
558 }
559 }
560
561 /*
562 * Name: isTashkeelOnTatweelChar
563 * Function: Checks if the Tashkeel Character is on Tatweel or not,if the
564 * Tashkeel on tatweel (FE range), it returns 1 else if the
565 * Tashkeel with shadda on tatweel (FC range)return 2 otherwise
566 * returns 0
567 */
568 static U_INLINE int32_t
isTashkeelOnTatweelChar(UChar ch)569 isTashkeelOnTatweelChar(UChar ch){
570 if(ch >= 0xfe70 && ch <= 0xfe7f && ch != NEW_TAIL_CHAR && ch != 0xFE75 && ch != SHADDA_TATWEEL_CHAR)
571 {
572 return tashkeelMedial [ch - 0xFE70];
573 }else if( (ch >= 0xfcf2 && ch <= 0xfcf4) || (ch == SHADDA_TATWEEL_CHAR)) {
574 return 2;
575 }else{
576 return 0;
577 }
578 }
579
580 /*
581 * Name: isIsolatedTashkeelChar
582 * Function: Checks if the Tashkeel Character is in the isolated form
583 * (i.e. Unicode FE range) returns 1 else if the Tashkeel
584 * with shadda is in the isolated form (i.e. Unicode FC range)
585 * returns 2 otherwise returns 0
586 */
587 static U_INLINE int32_t
isIsolatedTashkeelChar(UChar ch)588 isIsolatedTashkeelChar(UChar ch){
589 if(ch >= 0xfe70 && ch <= 0xfe7f && ch != NEW_TAIL_CHAR && ch != 0xFE75){
590 return (1 - tashkeelMedial [ch - 0xFE70]);
591 }else if(ch >= 0xfc5e && ch <= 0xfc63){
592 return 1;
593 }else{
594 return 0;
595 }
596 }
597
598
599
600
601 /*
602 *Name : calculateSize
603 *Function : This function calculates the destSize to be used in preflighting
604 * when the destSize is equal to 0
605 * It is used also to calculate the new destsize in case the
606 * destination buffer will be resized.
607 */
608
609 /* BEGIN android-changed */
610 static int32_t
calculateSize(const UChar * source,int32_t sourceLength,int32_t destSize,uint64_t options)611 calculateSize(const UChar *source, int32_t sourceLength,
612 int32_t destSize,uint64_t options) {
613 /* END android-changed */
614 int32_t i = 0;
615
616 int lamAlefOption = 0;
617 int tashkeelOption = 0;
618
619 destSize = sourceLength;
620
621 if (((options&U_SHAPE_LETTERS_MASK) == U_SHAPE_LETTERS_SHAPE ||
622 ((options&U_SHAPE_LETTERS_MASK) == U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED )) &&
623 ((options&U_SHAPE_LAMALEF_MASK) == U_SHAPE_LAMALEF_RESIZE )){
624 lamAlefOption = 1;
625 }
626 if((options&U_SHAPE_LETTERS_MASK) == U_SHAPE_LETTERS_SHAPE &&
627 ((options&U_SHAPE_TASHKEEL_MASK) == U_SHAPE_TASHKEEL_RESIZE ) ){
628 tashkeelOption = 1;
629 }
630
631 if(lamAlefOption || tashkeelOption){
632 if((options&U_SHAPE_TEXT_DIRECTION_MASK)==U_SHAPE_TEXT_DIRECTION_VISUAL_LTR) {
633 for(i=0;i<sourceLength;i++) {
634 if( ((isAlefChar(source[i]))&& (i<(sourceLength-1)) &&(source[i+1] == LAM_CHAR)) || (isTashkeelCharFE(source[i])) ) {
635 destSize--;
636 }
637 }
638 }else if((options&U_SHAPE_TEXT_DIRECTION_MASK)==U_SHAPE_TEXT_DIRECTION_LOGICAL) {
639 for(i=0;i<sourceLength;i++) {
640 if( ( (source[i] == LAM_CHAR) && (i<(sourceLength-1)) && (isAlefChar(source[i+1]))) || (isTashkeelCharFE(source[i])) ) {
641 destSize--;
642 }
643 }
644 }
645 }
646
647 if ((options&U_SHAPE_LETTERS_MASK) == U_SHAPE_LETTERS_UNSHAPE){
648 if ( (options&U_SHAPE_LAMALEF_MASK) == U_SHAPE_LAMALEF_RESIZE){
649 for(i=0;i<sourceLength;i++) {
650 if(isLamAlefChar(source[i]))
651 destSize++;
652 }
653 }
654 }
655
656 return destSize;
657 }
658
659 /*
660 *Name : handleTashkeelWithTatweel
661 *Function : Replaces Tashkeel as following:
662 * Case 1 :if the Tashkeel on tatweel, replace it with Tatweel.
663 * Case 2 :if the Tashkeel aggregated with Shadda on Tatweel, replace
664 * it with Shadda on Tatweel.
665 * Case 3: if the Tashkeel is isolated replace it with Space.
666 *
667 */
668 /* BEGIN android-changed */
669 static int32_t
handleTashkeelWithTatweel(UChar * dest,int32_t sourceLength,int32_t destSize,uint64_t options,UErrorCode * pErrorCode)670 handleTashkeelWithTatweel(UChar *dest, int32_t sourceLength,
671 int32_t destSize,uint64_t options,
672 UErrorCode *pErrorCode) {
673 /* END android-changed */
674 int i;
675 for(i = 0; i < sourceLength; i++){
676 if((isTashkeelOnTatweelChar(dest[i]) == 1)){
677 dest[i] = TATWEEL_CHAR;
678 }else if((isTashkeelOnTatweelChar(dest[i]) == 2)){
679 dest[i] = SHADDA_TATWEEL_CHAR;
680 }else if(isIsolatedTashkeelChar(dest[i]) && dest[i] != SHADDA_CHAR){
681 dest[i] = SPACE_CHAR;
682 }
683 }
684 return sourceLength;
685 }
686
687
688
689 /*
690 *Name : handleGeneratedSpaces
691 *Function : The shapeUnicode function converts Lam + Alef into LamAlef + space,
692 * and Tashkeel to space.
693 * handleGeneratedSpaces function puts these generated spaces
694 * according to the options the user specifies. LamAlef and Tashkeel
695 * spaces can be replaced at begin, at end, at near or decrease the
696 * buffer size.
697 *
698 * There is also Auto option for LamAlef and tashkeel, which will put
699 * the spaces at end of the buffer (or end of text if the user used
700 * the option U_SHAPE_SPACES_RELATIVE_TO_TEXT_BEGIN_END).
701 *
702 * If the text type was visual_LTR and the option
703 * U_SHAPE_SPACES_RELATIVE_TO_TEXT_BEGIN_END was selected the END
704 * option will place the space at the beginning of the buffer and
705 * BEGIN will place the space at the end of the buffer.
706 */
707
708 /* BEGIN android-changed */
709 static int32_t
handleGeneratedSpaces(UChar * dest,int32_t sourceLength,int32_t destSize,uint64_t options,UErrorCode * pErrorCode)710 handleGeneratedSpaces(UChar *dest, int32_t sourceLength,
711 int32_t destSize,
712 uint64_t options,
713 UErrorCode *pErrorCode ) {
714 /* END android-changed */
715
716 int32_t i = 0, j = 0;
717 int32_t count = 0;
718 UChar *tempbuffer=NULL;
719
720 int lamAlefOption = 0;
721 int tashkeelOption = 0;
722 int shapingMode = SHAPE_MODE;
723
724 if (shapingMode == 0){
725 if ( (options&U_SHAPE_LAMALEF_MASK) == U_SHAPE_LAMALEF_RESIZE ){
726 lamAlefOption = 1;
727 }
728 if ( (options&U_SHAPE_TASHKEEL_MASK) == U_SHAPE_TASHKEEL_RESIZE ){
729 tashkeelOption = 1;
730 }
731 }
732
733 if (lamAlefOption || tashkeelOption){
734 tempbuffer = (UChar *)uprv_malloc((sourceLength+1)*U_SIZEOF_UCHAR);
735 /* Test for NULL */
736 if(tempbuffer == NULL) {
737 *pErrorCode = U_MEMORY_ALLOCATION_ERROR;
738 return 0;
739 }
740
741 uprv_memset(tempbuffer, 0, (sourceLength+1)*U_SIZEOF_UCHAR);
742
743 i = j = 0; count = 0;
744 while(i < sourceLength) {
745 if ( (lamAlefOption && dest[i] == LAMALEF_SPACE_SUB) ||
746 (tashkeelOption && dest[i] == TASHKEEL_SPACE_SUB) ){
747 j--;
748 count++;
749 } else {
750 tempbuffer[j] = dest[i];
751 }
752 i++;
753 j++;
754 }
755
756 while(count >= 0) {
757 tempbuffer[i] = 0x0000;
758 i--;
759 count--;
760 }
761
762 uprv_memcpy(dest, tempbuffer, sourceLength*U_SIZEOF_UCHAR);
763 destSize = u_strlen(dest);
764 }
765
766 lamAlefOption = 0;
767
768 if (shapingMode == 0){
769 /* BEGIN android-changed */
770 if ( (options&U_SHAPE_LAMALEF_MASK) == U_SHAPE_LAMALEF_NEAR &&
771 (options&U_SHAPE_X_LAMALEF_SUB_ALTERNATE) == 0) { /* if set, leave LAMALEF_SPACE_SUB in the output */
772 /* END android-changed */
773 lamAlefOption = 1;
774 }
775 }
776
777 if (lamAlefOption){
778 /* Lam+Alef is already shaped into LamAlef + FFFF */
779 i = 0;
780 while(i < sourceLength) {
781 if(lamAlefOption&&dest[i] == LAMALEF_SPACE_SUB){
782 dest[i] = SPACE_CHAR;
783 }
784 i++;
785 }
786 destSize = sourceLength;
787 }
788 lamAlefOption = 0;
789 tashkeelOption = 0;
790
791 if (shapingMode == 0) {
792 if ( ((options&U_SHAPE_LAMALEF_MASK) == uShapeLamalefBegin) ||
793 (((options&U_SHAPE_LAMALEF_MASK) == U_SHAPE_LAMALEF_AUTO )
794 && (spacesRelativeToTextBeginEnd==1)) ) {
795 lamAlefOption = 1;
796 }
797 if ( (options&U_SHAPE_TASHKEEL_MASK) == uShapeTashkeelBegin ) {
798 tashkeelOption = 1;
799 }
800 }
801
802 if(lamAlefOption || tashkeelOption){
803 tempbuffer = (UChar *)uprv_malloc((sourceLength+1)*U_SIZEOF_UCHAR);
804
805 /* Test for NULL */
806 if(tempbuffer == NULL) {
807 *pErrorCode = U_MEMORY_ALLOCATION_ERROR;
808 return 0;
809 }
810
811 uprv_memset(tempbuffer, 0, (sourceLength+1)*U_SIZEOF_UCHAR);
812 i = j = sourceLength; count = 0;
813 while(i >= 0) {
814 if ( (lamAlefOption && dest[i] == LAMALEF_SPACE_SUB) ||
815 (tashkeelOption && dest[i] == TASHKEEL_SPACE_SUB) ){
816 j++;
817 count++;
818 }else {
819 tempbuffer[j] = dest[i];
820 }
821 i--;
822 j--;
823 }
824
825 for(i=0 ;i < count; i++){
826 tempbuffer[i] = SPACE_CHAR;
827 }
828
829 uprv_memcpy(dest, tempbuffer, sourceLength*U_SIZEOF_UCHAR);
830 destSize = sourceLength;
831 }
832
833
834
835 lamAlefOption = 0;
836 tashkeelOption = 0;
837
838 if (shapingMode == 0) {
839 if ( ((options&U_SHAPE_LAMALEF_MASK) == uShapeLamalefEnd) ||
840 (((options&U_SHAPE_LAMALEF_MASK) == U_SHAPE_LAMALEF_AUTO )
841 && (spacesRelativeToTextBeginEnd==0)) ) {
842 lamAlefOption = 1;
843 }
844 if ( (options&U_SHAPE_TASHKEEL_MASK) == uShapeTashkeelEnd ){
845 tashkeelOption = 1;
846 }
847 }
848
849 if(lamAlefOption || tashkeelOption){
850 tempbuffer = (UChar *)uprv_malloc((sourceLength+1)*U_SIZEOF_UCHAR);
851 /* Test for NULL */
852 if(tempbuffer == NULL) {
853 *pErrorCode = U_MEMORY_ALLOCATION_ERROR;
854 return 0;
855 }
856
857 uprv_memset(tempbuffer, 0, (sourceLength+1)*U_SIZEOF_UCHAR);
858
859 i = j = 0; count = 0;
860 while(i < sourceLength) {
861 if ( (lamAlefOption && dest[i] == LAMALEF_SPACE_SUB) ||
862 (tashkeelOption && dest[i] == TASHKEEL_SPACE_SUB) ){
863 j--;
864 count++;
865 }else {
866 tempbuffer[j] = dest[i];
867 }
868 i++;
869 j++;
870 }
871
872 while(count >= 0) {
873 tempbuffer[i] = SPACE_CHAR;
874 i--;
875 count--;
876 }
877
878 uprv_memcpy(dest,tempbuffer, sourceLength*U_SIZEOF_UCHAR);
879 destSize = sourceLength;
880 }
881
882
883 if(tempbuffer){
884 uprv_free(tempbuffer);
885 }
886
887 return destSize;
888 }
889
890 /*
891 *Name :expandCompositCharAtBegin
892 *Function :Expands the LamAlef character to Lam and Alef consuming the required
893 * space from beginning of the buffer. If the text type was visual_LTR
894 * and the option U_SHAPE_SPACES_RELATIVE_TO_TEXT_BEGIN_END was selected
895 * the spaces will be located at end of buffer.
896 * If there are no spaces to expand the LamAlef, an error
897 * will be set to U_NO_SPACE_AVAILABLE as defined in utypes.h
898 */
899
900 static int32_t
expandCompositCharAtBegin(UChar * dest,int32_t sourceLength,int32_t destSize,UErrorCode * pErrorCode)901 expandCompositCharAtBegin(UChar *dest, int32_t sourceLength, int32_t destSize,UErrorCode *pErrorCode) {
902 int32_t i = 0,j = 0;
903 int32_t countl = 0;
904 UChar *tempbuffer=NULL;
905
906 tempbuffer = (UChar *)uprv_malloc((sourceLength+1)*U_SIZEOF_UCHAR);
907
908 /* Test for NULL */
909 if(tempbuffer == NULL) {
910 *pErrorCode = U_MEMORY_ALLOCATION_ERROR;
911 return 0;
912 }
913
914 uprv_memset(tempbuffer, 0, (sourceLength+1)*U_SIZEOF_UCHAR);
915
916 i = 0;
917 while(dest[i] == SPACE_CHAR) {
918 countl++;
919 i++;
920 }
921
922 i = j = sourceLength-1;
923
924 while(i >= 0 && j >= 0) {
925 if( countl>0 && isLamAlefChar(dest[i])) {
926 tempbuffer[j] = LAM_CHAR;
927 tempbuffer[j-1] = convertLamAlef[ dest[i] - 0xFEF5 ];
928 j--;
929 countl--;
930 }else {
931 if( countl == 0 && isLamAlefChar(dest[i]) ) {
932 *pErrorCode=U_NO_SPACE_AVAILABLE;
933 }
934 tempbuffer[j] = dest[i];
935 }
936 i--;
937 j--;
938 }
939 uprv_memcpy(dest, tempbuffer, sourceLength*U_SIZEOF_UCHAR);
940
941 uprv_free(tempbuffer);
942
943 destSize = sourceLength;
944 return destSize;
945 }
946
947 /*
948 *Name : expandCompositCharAtEnd
949 *Function : Expands the LamAlef character to Lam and Alef consuming the
950 * required space from end of the buffer. If the text type was
951 * Visual LTR and the option U_SHAPE_SPACES_RELATIVE_TO_TEXT_BEGIN_END
952 * was used, the spaces will be consumed from begin of buffer. If
953 * there are no spaces to expand the LamAlef, an error
954 * will be set to U_NO_SPACE_AVAILABLE as defined in utypes.h
955 */
956
957 static int32_t
expandCompositCharAtEnd(UChar * dest,int32_t sourceLength,int32_t destSize,UErrorCode * pErrorCode)958 expandCompositCharAtEnd(UChar *dest, int32_t sourceLength, int32_t destSize,UErrorCode *pErrorCode) {
959 int32_t i = 0,j = 0;
960
961 int32_t countr = 0;
962 int32_t inpsize = sourceLength;
963
964 UChar *tempbuffer=NULL;
965 tempbuffer = (UChar *)uprv_malloc((sourceLength+1)*U_SIZEOF_UCHAR);
966
967 /* Test for NULL */
968 if(tempbuffer == NULL) {
969 *pErrorCode = U_MEMORY_ALLOCATION_ERROR;
970 return 0;
971 }
972
973 uprv_memset(tempbuffer, 0, (sourceLength+1)*U_SIZEOF_UCHAR);
974
975 while(dest[inpsize-1] == SPACE_CHAR) {
976 countr++;
977 inpsize--;
978 }
979
980 i = sourceLength - countr - 1;
981 j = sourceLength - 1;
982
983 while(i >= 0 && j >= 0) {
984 if( countr>0 && isLamAlefChar(dest[i]) ) {
985 tempbuffer[j] = LAM_CHAR;
986 tempbuffer[j-1] = convertLamAlef[ dest[i] - 0xFEF5 ];
987 j--;
988 countr--;
989 }else {
990 if ((countr == 0) && isLamAlefChar(dest[i]) ) {
991 *pErrorCode=U_NO_SPACE_AVAILABLE;
992 }
993 tempbuffer[j] = dest[i];
994 }
995 i--;
996 j--;
997 }
998
999 if(countr > 0) {
1000 uprv_memmove(tempbuffer, tempbuffer+countr, sourceLength*U_SIZEOF_UCHAR);
1001 if(u_strlen(tempbuffer) < sourceLength) {
1002 for(i=sourceLength-1;i>=sourceLength-countr;i--) {
1003 tempbuffer[i] = SPACE_CHAR;
1004 }
1005 }
1006 }
1007 uprv_memcpy(dest, tempbuffer, sourceLength*U_SIZEOF_UCHAR);
1008
1009 uprv_free(tempbuffer);
1010
1011 destSize = sourceLength;
1012 return destSize;
1013 }
1014
1015 /*
1016 *Name : expandCompositCharAtNear
1017 *Function : Expands the LamAlef character into Lam + Alef, YehHamza character
1018 * into Yeh + Hamza, SeenFamily character into SeenFamily character
1019 * + Tail, while consuming the space next to the character.
1020 * If there are no spaces next to the character, an error
1021 * will be set to U_NO_SPACE_AVAILABLE as defined in utypes.h
1022 */
1023
1024 static int32_t
expandCompositCharAtNear(UChar * dest,int32_t sourceLength,int32_t destSize,UErrorCode * pErrorCode,int yehHamzaOption,int seenTailOption,int lamAlefOption)1025 expandCompositCharAtNear(UChar *dest, int32_t sourceLength, int32_t destSize,UErrorCode *pErrorCode,
1026 int yehHamzaOption, int seenTailOption, int lamAlefOption) {
1027 int32_t i = 0;
1028
1029
1030 UChar lamalefChar, yehhamzaChar;
1031
1032 for(i = 0 ;i<=sourceLength-1;i++) {
1033 if (seenTailOption && isSeenTailFamilyChar(dest[i])) {
1034 if ((i>0) && (dest[i-1] == SPACE_CHAR) ) {
1035 dest[i-1] = tailChar;
1036 }else {
1037 *pErrorCode=U_NO_SPACE_AVAILABLE;
1038 }
1039 }else if(yehHamzaOption && (isYehHamzaChar(dest[i])) ) {
1040 if ((i>0) && (dest[i-1] == SPACE_CHAR) ) {
1041 yehhamzaChar = dest[i];
1042 dest[i] = yehHamzaToYeh[yehhamzaChar - YEH_HAMZAFE_CHAR];
1043 dest[i-1] = HAMZAFE_CHAR;
1044 }else {
1045
1046 *pErrorCode=U_NO_SPACE_AVAILABLE;
1047 }
1048 }else if(lamAlefOption && isLamAlefChar(dest[i+1])) {
1049 if(dest[i] == SPACE_CHAR){
1050 lamalefChar = dest[i+1];
1051 dest[i+1] = LAM_CHAR;
1052 dest[i] = convertLamAlef[ lamalefChar - 0xFEF5 ];
1053 }else {
1054 *pErrorCode=U_NO_SPACE_AVAILABLE;
1055 }
1056 }
1057 }
1058 destSize = sourceLength;
1059 return destSize;
1060 }
1061 /*
1062 * Name : expandCompositChar
1063 * Function : LamAlef, need special handling, since it expands from one
1064 * character into two characters while shaping or deshaping.
1065 * In order to expand it, near or far spaces according to the
1066 * options user specifies. Also buffer size can be increased.
1067 *
1068 * For SeenFamily characters and YehHamza only the near option is
1069 * supported, while for LamAlef we can take spaces from begin, end,
1070 * near or even increase the buffer size.
1071 * There is also the Auto option for LamAlef only, which will first
1072 * search for a space at end, begin then near, respectively.
1073 * If there are no spaces to expand these characters, an error will be set to
1074 * U_NO_SPACE_AVAILABLE as defined in utypes.h
1075 */
1076 /* BEGIN android-changed */
1077 static int32_t
expandCompositChar(UChar * dest,int32_t sourceLength,int32_t destSize,uint64_t options,UErrorCode * pErrorCode,int shapingMode)1078 expandCompositChar(UChar *dest, int32_t sourceLength,
1079 int32_t destSize,uint64_t options,
1080 UErrorCode *pErrorCode, int shapingMode) {
1081 /* END android-changed */
1082
1083 int32_t i = 0,j = 0;
1084
1085 UChar *tempbuffer=NULL;
1086 int yehHamzaOption = 0;
1087 int seenTailOption = 0;
1088 int lamAlefOption = 0;
1089
1090 if (shapingMode == 1){
1091 if ( (options&U_SHAPE_LAMALEF_MASK) == U_SHAPE_LAMALEF_AUTO){
1092
1093 if(spacesRelativeToTextBeginEnd == 0) {
1094 destSize = expandCompositCharAtEnd(dest, sourceLength, destSize, pErrorCode);
1095
1096 if(*pErrorCode == U_NO_SPACE_AVAILABLE) {
1097 *pErrorCode = U_ZERO_ERROR;
1098 destSize = expandCompositCharAtBegin(dest, sourceLength, destSize, pErrorCode);
1099 }
1100 }else {
1101 destSize = expandCompositCharAtBegin(dest, sourceLength, destSize, pErrorCode);
1102
1103 if(*pErrorCode == U_NO_SPACE_AVAILABLE) {
1104 *pErrorCode = U_ZERO_ERROR;
1105 destSize = expandCompositCharAtEnd(dest, sourceLength, destSize, pErrorCode);
1106 }
1107 }
1108
1109 if(*pErrorCode == U_NO_SPACE_AVAILABLE) {
1110 *pErrorCode = U_ZERO_ERROR;
1111 destSize = expandCompositCharAtNear(dest, sourceLength, destSize, pErrorCode, yehHamzaOption,
1112 seenTailOption, 1);
1113 }
1114 }
1115 }
1116
1117 if (shapingMode == 1){
1118 if ( (options&U_SHAPE_LAMALEF_MASK) == uShapeLamalefEnd){
1119 destSize = expandCompositCharAtEnd(dest, sourceLength, destSize, pErrorCode);
1120 }
1121 }
1122
1123 if (shapingMode == 1){
1124 if ( (options&U_SHAPE_LAMALEF_MASK) == uShapeLamalefBegin){
1125 destSize = expandCompositCharAtBegin(dest, sourceLength, destSize, pErrorCode);
1126 }
1127 }
1128
1129 if (shapingMode == 0){
1130 if ((options&U_SHAPE_YEHHAMZA_MASK) == U_SHAPE_YEHHAMZA_TWOCELL_NEAR){
1131 yehHamzaOption = 1;
1132 }
1133 if ((options&U_SHAPE_SEEN_MASK) == U_SHAPE_SEEN_TWOCELL_NEAR){
1134 seenTailOption = 1;
1135 }
1136 }
1137 if (shapingMode == 1) {
1138 if ( (options&U_SHAPE_LAMALEF_MASK) == U_SHAPE_LAMALEF_NEAR) {
1139 lamAlefOption = 1;
1140 }
1141 }
1142
1143
1144 if (yehHamzaOption || seenTailOption || lamAlefOption){
1145 destSize = expandCompositCharAtNear(dest, sourceLength, destSize, pErrorCode, yehHamzaOption,
1146 seenTailOption,lamAlefOption);
1147 }
1148
1149
1150 if (shapingMode == 1){
1151 if ( (options&U_SHAPE_LAMALEF_MASK) == U_SHAPE_LAMALEF_RESIZE){
1152 destSize = calculateSize(dest,sourceLength,destSize,options);
1153 tempbuffer = (UChar *)uprv_malloc((destSize+1)*U_SIZEOF_UCHAR);
1154
1155 /* Test for NULL */
1156 if(tempbuffer == NULL) {
1157 *pErrorCode = U_MEMORY_ALLOCATION_ERROR;
1158 return 0;
1159 }
1160
1161 uprv_memset(tempbuffer, 0, (destSize+1)*U_SIZEOF_UCHAR);
1162
1163 i = j = 0;
1164 while(i < destSize && j < destSize) {
1165 if(isLamAlefChar(dest[i]) ) {
1166 tempbuffer[j] = convertLamAlef[ dest[i] - 0xFEF5 ];
1167 tempbuffer[j+1] = LAM_CHAR;
1168 j++;
1169 }else {
1170 tempbuffer[j] = dest[i];
1171 }
1172 i++;
1173 j++;
1174 }
1175
1176 uprv_memcpy(dest, tempbuffer, destSize*U_SIZEOF_UCHAR);
1177 }
1178 }
1179
1180 if(tempbuffer) {
1181 uprv_free(tempbuffer);
1182 }
1183 return destSize;
1184 }
1185
1186 /*
1187 *Name : shapeUnicode
1188 *Function : Converts an Arabic Unicode buffer in 06xx Range into a shaped
1189 * arabic Unicode buffer in FExx Range
1190 */
1191 /* BEGIN android-changed */
1192 static int32_t
shapeUnicode(UChar * dest,int32_t sourceLength,int32_t destSize,uint64_t options,UErrorCode * pErrorCode,int tashkeelFlag)1193 shapeUnicode(UChar *dest, int32_t sourceLength,
1194 int32_t destSize,uint64_t options,
1195 UErrorCode *pErrorCode,
1196 int tashkeelFlag) {
1197 /* END android-changed */
1198
1199 int32_t i, iend;
1200 int32_t step;
1201 int32_t lastPos,Nx, Nw;
1202 unsigned int Shape;
1203 int32_t lamalef_found = 0;
1204 int32_t seenfamFound = 0, yehhamzaFound =0, tashkeelFound = 0;
1205 UChar prevLink = 0, lastLink = 0, currLink, nextLink = 0;
1206 UChar wLamalef;
1207
1208 /*
1209 * Converts the input buffer from FExx Range into 06xx Range
1210 * to make sure that all characters are in the 06xx range
1211 * even the lamalef is converted to the special region in
1212 * the 06xx range
1213 */
1214 if ((options & U_SHAPE_PRESERVE_PRESENTATION_MASK) == U_SHAPE_PRESERVE_PRESENTATION_NOOP) {
1215 for (i = 0; i < sourceLength; i++) {
1216 UChar inputChar = dest[i];
1217 if ( (inputChar >= 0xFB50) && (inputChar <= 0xFBFF)) {
1218 UChar c = convertFBto06 [ (inputChar - 0xFB50) ];
1219 if (c != 0)
1220 dest[i] = c;
1221 } else if ( (inputChar >= 0xFE70) && (inputChar <= 0xFEFC)) {
1222 dest[i] = convertFEto06 [ (inputChar - 0xFE70) ] ;
1223 } else {
1224 dest[i] = inputChar ;
1225 }
1226 }
1227 }
1228
1229
1230 /* sets the index to the end of the buffer, together with the step point to -1 */
1231 i = sourceLength - 1;
1232 iend = -1;
1233 step = -1;
1234
1235 /*
1236 * This function resolves the link between the characters .
1237 * Arabic characters have four forms :
1238 * Isolated Form, Initial Form, Middle Form and Final Form
1239 */
1240 currLink = getLink(dest[i]);
1241
1242 lastPos = i;
1243 Nx = -2, Nw = 0;
1244
1245 while (i != iend) {
1246 /* If high byte of currLink > 0 then more than one shape */
1247 if ((currLink & 0xFF00) > 0 || (getLink(dest[i]) & IRRELEVANT) != 0) {
1248 Nw = i + step;
1249 while (Nx < 0) { /* we need to know about next char */
1250 if(Nw == iend) {
1251 nextLink = 0;
1252 Nx = 3000;
1253 } else {
1254 nextLink = getLink(dest[Nw]);
1255 if((nextLink & IRRELEVANT) == 0) {
1256 Nx = Nw;
1257 } else {
1258 Nw = Nw + step;
1259 }
1260 }
1261 }
1262
1263 if ( ((currLink & ALEFTYPE) > 0) && ((lastLink & LAMTYPE) > 0) ) {
1264 lamalef_found = 1;
1265 wLamalef = changeLamAlef(dest[i]); /*get from 0x065C-0x065f */
1266 if ( wLamalef != 0) {
1267 dest[i] = LAMALEF_SPACE_SUB; /* The default case is to drop the Alef and replace */
1268 dest[lastPos] =wLamalef; /* it by LAMALEF_SPACE_SUB which is the last character in the */
1269 i=lastPos; /* unicode private use area, this is done to make */
1270 } /* sure that removeLamAlefSpaces() handles only the */
1271 lastLink = prevLink; /* spaces generated during lamalef generation. */
1272 currLink = getLink(wLamalef); /* LAMALEF_SPACE_SUB is added here and is replaced by spaces */
1273 } /* in removeLamAlefSpaces() */
1274
1275 if ((i > 0) && (dest[i-1] == SPACE_CHAR)){
1276 if ( isSeenFamilyChar(dest[i])){
1277 seenfamFound = 1;
1278 } else if (dest[i] == YEH_HAMZA_CHAR) {
1279 yehhamzaFound = 1;
1280 }
1281 }
1282 else if(i==0){
1283 if ( isSeenFamilyChar(dest[i])){
1284 seenfamFound = 1;
1285 } else if (dest[i] == YEH_HAMZA_CHAR) {
1286 yehhamzaFound = 1;
1287 }
1288 }
1289
1290 /*
1291 * get the proper shape according to link ability of neighbors
1292 * and of character; depends on the order of the shapes
1293 * (isolated, initial, middle, final) in the compatibility area
1294 */
1295 Shape = shapeTable[nextLink & (LINKR + LINKL)]
1296 [lastLink & (LINKR + LINKL)]
1297 [currLink & (LINKR + LINKL)];
1298
1299 if ((currLink & (LINKR+LINKL)) == 1) {
1300 Shape &= 1;
1301 } else if(isTashkeelChar(dest[i])) {
1302 if( (lastLink & LINKL) && (nextLink & LINKR) && (tashkeelFlag == 1) &&
1303 dest[i] != 0x064C && dest[i] != 0x064D )
1304 {
1305 Shape = 1;
1306 if( (nextLink&ALEFTYPE) == ALEFTYPE && (lastLink&LAMTYPE) == LAMTYPE ) {
1307 Shape = 0;
1308 }
1309 }
1310 else {
1311 Shape = 0;
1312 }
1313 }
1314 if ((dest[i] ^ 0x0600) < 0x100) {
1315 if ( isTashkeelChar(dest[i]) ){
1316 if (tashkeelFlag == 2){
1317 dest[i] = TASHKEEL_SPACE_SUB;
1318 tashkeelFound = 1;
1319 }else {
1320 dest[i] = 0xFE70 + IrrelevantPos[(dest[i] - 0x064B)] + Shape;
1321 }
1322 }else if ((currLink & APRESENT) > 0) {
1323 dest[i] = (UChar)(0xFB50 + (currLink >> 8) + Shape);
1324 }else if ((currLink >> 8) > 0 && (currLink & IRRELEVANT) == 0) {
1325 dest[i] = (UChar)(0xFE70 + (currLink >> 8) + Shape);
1326 }
1327 }
1328 }
1329
1330 /* move one notch forward */
1331 if ((currLink & IRRELEVANT) == 0) {
1332 prevLink = lastLink;
1333 lastLink = currLink;
1334 lastPos = i;
1335 }
1336
1337 i = i + step;
1338 if (i == Nx) {
1339 currLink = nextLink;
1340 Nx = -2;
1341 } else if(i != iend) {
1342 currLink = getLink(dest[i]);
1343 }
1344 }
1345 destSize = sourceLength;
1346 if ( (lamalef_found != 0 ) || (tashkeelFound != 0) ){
1347 destSize = handleGeneratedSpaces(dest,sourceLength,destSize,options,pErrorCode);
1348 }
1349
1350 if ( (seenfamFound != 0) || (yehhamzaFound != 0) ) {
1351 destSize = expandCompositChar(dest, sourceLength,destSize,options,pErrorCode, SHAPE_MODE);
1352 }
1353 return destSize;
1354 }
1355
1356 /*
1357 *Name : deShapeUnicode
1358 *Function : Converts an Arabic Unicode buffer in FExx Range into unshaped
1359 * arabic Unicode buffer in 06xx Range
1360 */
1361 /* BEGIN android-changed */
1362 static int32_t
deShapeUnicode(UChar * dest,int32_t sourceLength,int32_t destSize,uint64_t options,UErrorCode * pErrorCode)1363 deShapeUnicode(UChar *dest, int32_t sourceLength,
1364 int32_t destSize,uint64_t options,
1365 UErrorCode *pErrorCode) {
1366 /* END android-changed */
1367 int32_t i = 0;
1368 int32_t lamalef_found = 0;
1369 int32_t yehHamzaComposeEnabled = 0;
1370 int32_t seenComposeEnabled = 0;
1371
1372 yehHamzaComposeEnabled = ((options&U_SHAPE_YEHHAMZA_MASK) == U_SHAPE_YEHHAMZA_TWOCELL_NEAR) ? 1 : 0;
1373 seenComposeEnabled = ((options&U_SHAPE_SEEN_MASK) == U_SHAPE_SEEN_TWOCELL_NEAR)? 1 : 0;
1374
1375 /*
1376 *This for loop changes the buffer from the Unicode FE range to
1377 *the Unicode 06 range
1378 */
1379
1380 for(i = 0; i < sourceLength; i++) {
1381 UChar inputChar = dest[i];
1382 if ( (inputChar >= 0xFB50) && (inputChar <= 0xFBFF)) { /* FBxx Arabic range */
1383 UChar c = convertFBto06 [ (inputChar - 0xFB50) ];
1384 if (c != 0)
1385 dest[i] = c;
1386 } else if( (yehHamzaComposeEnabled == 1) && ((inputChar == HAMZA06_CHAR) || (inputChar == HAMZAFE_CHAR))
1387 && (i < (sourceLength - 1)) && isAlefMaksouraChar(dest[i+1] )) {
1388 dest[i] = SPACE_CHAR;
1389 dest[i+1] = YEH_HAMZA_CHAR;
1390 } else if ( (seenComposeEnabled == 1) && (isTailChar(inputChar)) && (i< (sourceLength - 1))
1391 && (isSeenTailFamilyChar(dest[i+1])) ) {
1392 dest[i] = SPACE_CHAR;
1393 } else if (( inputChar >= 0xFE70) && (inputChar <= 0xFEF4 )) { /* FExx Arabic range */
1394 dest[i] = convertFEto06 [ (inputChar - 0xFE70) ];
1395 } else {
1396 dest[i] = inputChar ;
1397 }
1398
1399 if( isLamAlefChar(dest[i]) )
1400 lamalef_found = 1;
1401 }
1402
1403 destSize = sourceLength;
1404 if (lamalef_found != 0){
1405 destSize = expandCompositChar(dest,sourceLength,destSize,options,pErrorCode,DESHAPE_MODE);
1406 }
1407 return destSize;
1408 }
1409
1410 /*
1411 ****************************************
1412 * u_shapeArabic
1413 ****************************************
1414 */
1415
1416 /* BEGIN android-changed */
1417 U_CAPI int32_t U_EXPORT2
u_shapeArabic(const UChar * source,int32_t sourceLength,UChar * dest,int32_t destCapacity,uint64_t options,UErrorCode * pErrorCode)1418 u_shapeArabic(const UChar *source, int32_t sourceLength,
1419 UChar *dest, int32_t destCapacity,
1420 uint64_t options,
1421 UErrorCode *pErrorCode) {
1422 /* END android-changed */
1423
1424 int32_t destLength;
1425
1426 spacesRelativeToTextBeginEnd = 0;
1427 uShapeLamalefBegin = U_SHAPE_LAMALEF_BEGIN;
1428 uShapeLamalefEnd = U_SHAPE_LAMALEF_END;
1429 uShapeTashkeelBegin = U_SHAPE_TASHKEEL_BEGIN;
1430 uShapeTashkeelEnd = U_SHAPE_TASHKEEL_END;
1431
1432 /* usual error checking */
1433 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
1434 return 0;
1435 }
1436
1437 /* make sure that no reserved options values are used; allow dest==NULL only for preflighting */
1438 if( source==NULL || sourceLength<-1 || (dest==NULL && destCapacity!=0) || destCapacity<0 ||
1439 (((options&U_SHAPE_TASHKEEL_MASK) > 0) &&
1440 ((options&U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED) == U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED) ) ||
1441 (((options&U_SHAPE_TASHKEEL_MASK) > 0) &&
1442 ((options&U_SHAPE_LETTERS_MASK) == U_SHAPE_LETTERS_UNSHAPE)) ||
1443 (options&U_SHAPE_DIGIT_TYPE_RESERVED)==U_SHAPE_DIGIT_TYPE_RESERVED ||
1444 (options&U_SHAPE_DIGITS_MASK)==U_SHAPE_DIGITS_RESERVED ||
1445 ((options&U_SHAPE_LAMALEF_MASK) != U_SHAPE_LAMALEF_RESIZE &&
1446 (options&U_SHAPE_AGGREGATE_TASHKEEL_MASK) != 0) ||
1447 ((options&U_SHAPE_AGGREGATE_TASHKEEL_MASK) == U_SHAPE_AGGREGATE_TASHKEEL &&
1448 (options&U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED) != U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED)
1449 )
1450 {
1451 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
1452 return 0;
1453 }
1454 /* Validate lamalef options */
1455 if(((options&U_SHAPE_LAMALEF_MASK) > 0)&&
1456 !(((options & U_SHAPE_LAMALEF_MASK)==U_SHAPE_LAMALEF_BEGIN) ||
1457 ((options & U_SHAPE_LAMALEF_MASK)==U_SHAPE_LAMALEF_END ) ||
1458 ((options & U_SHAPE_LAMALEF_MASK)==U_SHAPE_LAMALEF_RESIZE )||
1459 ((options & U_SHAPE_LAMALEF_MASK)==U_SHAPE_LAMALEF_AUTO) ||
1460 ((options & U_SHAPE_LAMALEF_MASK)==U_SHAPE_LAMALEF_NEAR)))
1461 {
1462 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
1463 return 0;
1464 }
1465 /* Validate Tashkeel options */
1466 if(((options&U_SHAPE_TASHKEEL_MASK) > 0)&&
1467 !(((options & U_SHAPE_TASHKEEL_MASK)==U_SHAPE_TASHKEEL_BEGIN) ||
1468 ((options & U_SHAPE_TASHKEEL_MASK)==U_SHAPE_TASHKEEL_END )
1469 ||((options & U_SHAPE_TASHKEEL_MASK)==U_SHAPE_TASHKEEL_RESIZE )||
1470 ((options & U_SHAPE_TASHKEEL_MASK)==U_SHAPE_TASHKEEL_REPLACE_BY_TATWEEL)))
1471 {
1472 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
1473 return 0;
1474 }
1475 /* determine the source length */
1476 if(sourceLength==-1) {
1477 sourceLength=u_strlen(source);
1478 }
1479 if(sourceLength<=0) {
1480 return u_terminateUChars(dest, destCapacity, 0, pErrorCode);
1481 }
1482
1483 /* check that source and destination do not overlap */
1484 if( dest!=NULL &&
1485 ((source<=dest && dest<source+sourceLength) ||
1486 (dest<=source && source<dest+destCapacity))) {
1487 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
1488 return 0;
1489 }
1490
1491 /* Does Options contain the new Seen Tail Unicode code point option */
1492 if ( (options&U_SHAPE_TAIL_TYPE_MASK) == U_SHAPE_TAIL_NEW_UNICODE){
1493 tailChar = NEW_TAIL_CHAR;
1494 }else {
1495 tailChar = OLD_TAIL_CHAR;
1496 }
1497
1498 if((options&U_SHAPE_LETTERS_MASK)!=U_SHAPE_LETTERS_NOOP) {
1499 UChar buffer[300];
1500 UChar *tempbuffer, *tempsource = NULL;
1501 int32_t outputSize, spacesCountl=0, spacesCountr=0;
1502
1503 if((options&U_SHAPE_AGGREGATE_TASHKEEL_MASK)>0) {
1504 int32_t logical_order = (options&U_SHAPE_TEXT_DIRECTION_MASK) == U_SHAPE_TEXT_DIRECTION_LOGICAL;
1505 int32_t aggregate_tashkeel =
1506 (options&(U_SHAPE_AGGREGATE_TASHKEEL_MASK+U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED)) ==
1507 (U_SHAPE_AGGREGATE_TASHKEEL+U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED);
1508 int step=logical_order?1:-1;
1509 int j=logical_order?-1:2*sourceLength;
1510 int i=logical_order?-1:sourceLength;
1511 int end=logical_order?sourceLength:-1;
1512 int aggregation_possible = 1;
1513 UChar prev = 0;
1514 UChar prevLink, currLink = 0;
1515 int newSourceLength = 0;
1516 tempsource = (UChar *)uprv_malloc(2*sourceLength*U_SIZEOF_UCHAR);
1517 if(tempsource == NULL) {
1518 *pErrorCode = U_MEMORY_ALLOCATION_ERROR;
1519 return 0;
1520 }
1521
1522 while ((i+=step) != end) {
1523 prevLink = currLink;
1524 currLink = getLink(source[i]);
1525 if (aggregate_tashkeel && ((prevLink|currLink)&COMBINE) == COMBINE && aggregation_possible) {
1526 aggregation_possible = 0;
1527 tempsource[j] = (prev<source[i]?prev:source[i])-0x064C+0xFC5E;
1528 currLink = getLink(tempsource[j]);
1529 } else {
1530 aggregation_possible = 1;
1531 tempsource[j+=step] = source[i];
1532 prev = source[i];
1533 newSourceLength++;
1534 }
1535 }
1536 source = tempsource+(logical_order?0:j);
1537 sourceLength = newSourceLength;
1538 }
1539
1540 /* calculate destination size */
1541 /* TODO: do we ever need to do this pure preflighting? */
1542 if(((options&U_SHAPE_LAMALEF_MASK)==U_SHAPE_LAMALEF_RESIZE) ||
1543 ((options&U_SHAPE_TASHKEEL_MASK)==U_SHAPE_TASHKEEL_RESIZE)) {
1544 outputSize=calculateSize(source,sourceLength,destCapacity,options);
1545 } else {
1546 outputSize=sourceLength;
1547 }
1548
1549 if(outputSize>destCapacity) {
1550 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
1551 if (tempsource != NULL) uprv_free(tempsource);
1552 return outputSize;
1553 }
1554
1555 /*
1556 * need a temporary buffer of size max(outputSize, sourceLength)
1557 * because at first we copy source->temp
1558 */
1559 if(sourceLength>outputSize) {
1560 outputSize=sourceLength;
1561 }
1562
1563 /* Start of Arabic letter shaping part */
1564 if(outputSize<=sizeof(buffer)/U_SIZEOF_UCHAR) {
1565 outputSize=sizeof(buffer)/U_SIZEOF_UCHAR;
1566 tempbuffer=buffer;
1567 } else {
1568 tempbuffer = (UChar *)uprv_malloc(outputSize*U_SIZEOF_UCHAR);
1569
1570 /*Test for NULL*/
1571 if(tempbuffer == NULL) {
1572 *pErrorCode = U_MEMORY_ALLOCATION_ERROR;
1573 if (tempsource != NULL) uprv_free(tempsource);
1574 return 0;
1575 }
1576 }
1577 uprv_memcpy(tempbuffer, source, sourceLength*U_SIZEOF_UCHAR);
1578 if (tempsource != NULL){
1579 uprv_free(tempsource);
1580 }
1581
1582 if(sourceLength<outputSize) {
1583 uprv_memset(tempbuffer+sourceLength, 0, (outputSize-sourceLength)*U_SIZEOF_UCHAR);
1584 }
1585
1586 if((options&U_SHAPE_TEXT_DIRECTION_MASK) == U_SHAPE_TEXT_DIRECTION_LOGICAL) {
1587 countSpaces(tempbuffer,sourceLength,options,&spacesCountl,&spacesCountr);
1588 invertBuffer(tempbuffer,sourceLength,options,spacesCountl,spacesCountr);
1589 }
1590
1591 if((options&U_SHAPE_TEXT_DIRECTION_MASK) == U_SHAPE_TEXT_DIRECTION_VISUAL_LTR) {
1592 if((options&U_SHAPE_SPACES_RELATIVE_TO_TEXT_MASK) == U_SHAPE_SPACES_RELATIVE_TO_TEXT_BEGIN_END) {
1593 spacesRelativeToTextBeginEnd = 1;
1594 uShapeLamalefBegin = U_SHAPE_LAMALEF_END;
1595 uShapeLamalefEnd = U_SHAPE_LAMALEF_BEGIN;
1596
1597 uShapeTashkeelBegin = U_SHAPE_TASHKEEL_END;
1598 uShapeTashkeelEnd = U_SHAPE_TASHKEEL_BEGIN;
1599 }
1600 }
1601
1602 switch(options&U_SHAPE_LETTERS_MASK) {
1603 case U_SHAPE_LETTERS_SHAPE :
1604 if( (options&U_SHAPE_TASHKEEL_MASK)> 0
1605 && ((options&U_SHAPE_TASHKEEL_MASK) !=U_SHAPE_TASHKEEL_REPLACE_BY_TATWEEL)) {
1606 /* Call the shaping function with tashkeel flag == 2 for removal of tashkeel */
1607 destLength = shapeUnicode(tempbuffer,sourceLength,destCapacity,options,pErrorCode,2);
1608 }else {
1609 /* default Call the shaping function with tashkeel flag == 1 */
1610 destLength = shapeUnicode(tempbuffer,sourceLength,destCapacity,options,pErrorCode,1);
1611
1612 /*After shaping text check if user wants to remove tashkeel and replace it with tatweel*/
1613 if( (options&U_SHAPE_TASHKEEL_MASK) == U_SHAPE_TASHKEEL_REPLACE_BY_TATWEEL){
1614 destLength = handleTashkeelWithTatweel(tempbuffer,destLength,destCapacity,options,pErrorCode);
1615 }
1616 }
1617 break;
1618 case U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED :
1619 /* Call the shaping function with tashkeel flag == 0 */
1620 destLength = shapeUnicode(tempbuffer,sourceLength,destCapacity,options,pErrorCode,0);
1621 break;
1622
1623 case U_SHAPE_LETTERS_UNSHAPE :
1624 /* Call the deshaping function */
1625 destLength = deShapeUnicode(tempbuffer,sourceLength,destCapacity,options,pErrorCode);
1626 break;
1627 default :
1628 /* will never occur because of validity checks above */
1629 destLength = 0;
1630 break;
1631 }
1632
1633 /*
1634 * TODO: (markus 2002aug01)
1635 * For as long as we always preflight the outputSize above
1636 * we should U_ASSERT(outputSize==destLength)
1637 * except for the adjustment above before the tempbuffer allocation
1638 */
1639
1640 if((options&U_SHAPE_TEXT_DIRECTION_MASK) == U_SHAPE_TEXT_DIRECTION_LOGICAL) {
1641 countSpaces(tempbuffer,destLength,options,&spacesCountl,&spacesCountr);
1642 invertBuffer(tempbuffer,destLength,options,spacesCountl,spacesCountr);
1643 }
1644 uprv_memcpy(dest, tempbuffer, uprv_min(destLength, destCapacity)*U_SIZEOF_UCHAR);
1645
1646 if(tempbuffer!=buffer) {
1647 uprv_free(tempbuffer);
1648 }
1649
1650 if(destLength>destCapacity) {
1651 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
1652 return destLength;
1653 }
1654
1655 /* End of Arabic letter shaping part */
1656 } else {
1657 /*
1658 * No letter shaping:
1659 * just make sure the destination is large enough and copy the string.
1660 */
1661 if(destCapacity<sourceLength) {
1662 /* this catches preflighting, too */
1663 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
1664 return sourceLength;
1665 }
1666 uprv_memcpy(dest, source, sourceLength*U_SIZEOF_UCHAR);
1667 destLength=sourceLength;
1668 }
1669
1670 /*
1671 * Perform number shaping.
1672 * With UTF-16 or UTF-32, the length of the string is constant.
1673 * The easiest way to do this is to operate on the destination and
1674 * "shape" the digits in-place.
1675 */
1676 if((options&U_SHAPE_DIGITS_MASK)!=U_SHAPE_DIGITS_NOOP) {
1677 UChar digitBase;
1678 int32_t i;
1679
1680 /* select the requested digit group */
1681 switch(options&U_SHAPE_DIGIT_TYPE_MASK) {
1682 case U_SHAPE_DIGIT_TYPE_AN:
1683 digitBase=0x660; /* Unicode: "Arabic-Indic digits" */
1684 break;
1685 case U_SHAPE_DIGIT_TYPE_AN_EXTENDED:
1686 digitBase=0x6f0; /* Unicode: "Eastern Arabic-Indic digits (Persian and Urdu)" */
1687 break;
1688 default:
1689 /* will never occur because of validity checks above */
1690 digitBase=0;
1691 break;
1692 }
1693
1694 /* perform the requested operation */
1695 switch(options&U_SHAPE_DIGITS_MASK) {
1696 case U_SHAPE_DIGITS_EN2AN:
1697 /* add (digitBase-'0') to each European (ASCII) digit code point */
1698 digitBase-=0x30;
1699 for(i=0; i<destLength; ++i) {
1700 if(((uint32_t)dest[i]-0x30)<10) {
1701 dest[i]+=digitBase;
1702 }
1703 }
1704 break;
1705 case U_SHAPE_DIGITS_AN2EN:
1706 /* subtract (digitBase-'0') from each Arabic digit code point */
1707 for(i=0; i<destLength; ++i) {
1708 if(((uint32_t)dest[i]-(uint32_t)digitBase)<10) {
1709 dest[i]-=digitBase-0x30;
1710 }
1711 }
1712 break;
1713 case U_SHAPE_DIGITS_ALEN2AN_INIT_LR:
1714 _shapeToArabicDigitsWithContext(dest, destLength,
1715 digitBase,
1716 (UBool)((options&U_SHAPE_TEXT_DIRECTION_MASK)==U_SHAPE_TEXT_DIRECTION_LOGICAL),
1717 FALSE);
1718 break;
1719 case U_SHAPE_DIGITS_ALEN2AN_INIT_AL:
1720 _shapeToArabicDigitsWithContext(dest, destLength,
1721 digitBase,
1722 (UBool)((options&U_SHAPE_TEXT_DIRECTION_MASK)==U_SHAPE_TEXT_DIRECTION_LOGICAL),
1723 TRUE);
1724 break;
1725 default:
1726 /* will never occur because of validity checks above */
1727 break;
1728 }
1729 }
1730
1731 return u_terminateUChars(dest, destCapacity, destLength, pErrorCode);
1732 }
1733