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