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