WebCore:
[WebKit-https.git] / WebCore / platform / text / mac / ShapeArabic.c
1 /*
2 ******************************************************************************
3 *
4 *   Copyright (C) 2000-2004, International Business Machines
5 *   Corporation and others. All Rights Reserved.
6 *   Copyright (C) 2007 Apple Inc. All rights reserved.
7 *
8 *   Permission is hereby granted, free of charge, to any person obtaining a copy of this
9 *   software and associated documentation files (the "Software"), to deal in the Software
10 *   without restriction, including without limitation the rights to use, copy, modify,
11 *   merge, publish, distribute, and/or sell copies of the Software, and to permit persons
12 *   to whom the Software is furnished to do so, provided that the above copyright notice(s)
13 *   and this permission notice appear in all copies of the Software and that both the above
14 *   copyright notice(s) and this permission notice appear in supporting documentation.
15 *
16 *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
17 *   INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
18 *   PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER
19 *   OR HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR
20 *   CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
21 *   PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
22 *   OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
23 *
24 *   Except as contained in this notice, the name of a copyright holder shall not be used in
25 *   advertising or otherwise to promote the sale, use or other dealings in this Software
26 *   without prior written authorization of the copyright holder.
27 *
28 ******************************************************************************
29 *
30 *   Arabic letter shaping implemented by Ayman Roshdy
31 */
32
33 #include "config.h"
34 #include "ShapeArabic.h"
35
36 #include <unicode/utypes.h>
37 #include <unicode/uchar.h>
38 #include <unicode/ustring.h>
39 #include <unicode/ushape.h>
40 #include <wtf/Assertions.h>
41
42 /*
43  * ### TODO in general for letter shaping:
44  * - the letter shaping code is UTF-16-unaware; needs update
45  *   + especially invertBuffer()?!
46  * - needs to handle the "Arabic Tail" that is used in some legacy codepages
47  *   as a glyph fragment of wide-glyph letters
48  *   + IBM Unicode conversion tables map it to U+200B (ZWSP)
49  *   + IBM Egypt has proposed to encode the tail in Unicode among Arabic Presentation Forms
50  */
51
52 /* definitions for Arabic letter shaping ------------------------------------ */
53
54 #define IRRELEVANT 4
55 #define LAMTYPE    16
56 #define ALEFTYPE   32
57 #define LINKR      1
58 #define LINKL      2
59
60 static const UChar IrrelevantPos[] = {
61     0x0, 0x2, 0x4, 0x6,
62     0x8, 0xA, 0xC, 0xE,
63 };
64
65 static const UChar araLink[178]=
66 {
67   1           + 32 + 256 * 0x11,/*0x0622*/
68   1           + 32 + 256 * 0x13,/*0x0623*/
69   1                + 256 * 0x15,/*0x0624*/
70   1           + 32 + 256 * 0x17,/*0x0625*/
71   1 + 2            + 256 * 0x19,/*0x0626*/
72   1           + 32 + 256 * 0x1D,/*0x0627*/
73   1 + 2            + 256 * 0x1F,/*0x0628*/
74   1                + 256 * 0x23,/*0x0629*/
75   1 + 2            + 256 * 0x25,/*0x062A*/
76   1 + 2            + 256 * 0x29,/*0x062B*/
77   1 + 2            + 256 * 0x2D,/*0x062C*/
78   1 + 2            + 256 * 0x31,/*0x062D*/
79   1 + 2            + 256 * 0x35,/*0x062E*/
80   1                + 256 * 0x39,/*0x062F*/
81   1                + 256 * 0x3B,/*0x0630*/
82   1                + 256 * 0x3D,/*0x0631*/
83   1                + 256 * 0x3F,/*0x0632*/
84   1 + 2            + 256 * 0x41,/*0x0633*/
85   1 + 2            + 256 * 0x45,/*0x0634*/
86   1 + 2            + 256 * 0x49,/*0x0635*/
87   1 + 2            + 256 * 0x4D,/*0x0636*/
88   1 + 2            + 256 * 0x51,/*0x0637*/
89   1 + 2            + 256 * 0x55,/*0x0638*/
90   1 + 2            + 256 * 0x59,/*0x0639*/
91   1 + 2            + 256 * 0x5D,/*0x063A*/
92   0, 0, 0, 0, 0,                /*0x063B-0x063F*/
93   1 + 2,                        /*0x0640*/
94   1 + 2            + 256 * 0x61,/*0x0641*/
95   1 + 2            + 256 * 0x65,/*0x0642*/
96   1 + 2            + 256 * 0x69,/*0x0643*/
97   1 + 2       + 16 + 256 * 0x6D,/*0x0644*/
98   1 + 2            + 256 * 0x71,/*0x0645*/
99   1 + 2            + 256 * 0x75,/*0x0646*/
100   1 + 2            + 256 * 0x79,/*0x0647*/
101   1                + 256 * 0x7D,/*0x0648*/
102   1                + 256 * 0x7F,/*0x0649*/
103   1 + 2            + 256 * 0x81,/*0x064A*/
104   4, 4, 4, 4,                   /*0x064B-0x064E*/
105   4, 4, 4, 4,                   /*0x064F-0x0652*/
106   4, 4, 4, 0, 0,                /*0x0653-0x0657*/
107   0, 0, 0, 0,                   /*0x0658-0x065B*/
108   1                + 256 * 0x85,/*0x065C*/
109   1                + 256 * 0x87,/*0x065D*/
110   1                + 256 * 0x89,/*0x065E*/
111   1                + 256 * 0x8B,/*0x065F*/
112   0, 0, 0, 0, 0,                /*0x0660-0x0664*/
113   0, 0, 0, 0, 0,                /*0x0665-0x0669*/
114   0, 0, 0, 0, 0, 0,             /*0x066A-0x066F*/
115   4,                            /*0x0670*/
116   0,                            /*0x0671*/
117   1           + 32,             /*0x0672*/
118   1           + 32,             /*0x0673*/
119   0,                            /*0x0674*/
120   1           + 32,             /*0x0675*/
121   1, 1,                         /*0x0676-0x0677*/
122   1+2,                          /*0x0678*/
123   1+2              + 256 * 0x16,/*0x0679*/
124   1+2              + 256 * 0x0E,/*0x067A*/
125   1+2              + 256 * 0x02,/*0x067B*/
126   1+2, 1+2,                     /*0x067C-0x067D*/
127   1+2              + 256 * 0x06,/*0x067E*/
128   1+2              + 256 * 0x12,/*0x067F*/
129   1+2              + 256 * 0x0A,/*0x0680*/
130   1+2, 1+2,                     /*0x0681-0x0682*/
131   1+2              + 256 * 0x26,/*0x0683*/
132   1+2              + 256 * 0x22,/*0x0684*/
133   1+2,                          /*0x0685*/
134   1+2              + 256 * 0x2A,/*0x0686*/
135   1+2              + 256 * 0x2E,/*0x0687*/
136   1                + 256 * 0x38,/*0x0688*/
137   1, 1, 1,                      /*0x0689-0x068B*/
138   1                + 256 * 0x34,/*0x068C*/
139   1                + 256 * 0x32,/*0x068D*/
140   1                + 256 * 0x36,/*0x068E*/
141   1, 1,                         /*0x068F-0x0690*/
142   1                + 256 * 0x3C,/*0x0691*/
143   1, 1, 1, 1, 1, 1,             /*0x0692-0x0697*/
144   1                + 256 * 0x3A,/*0x0698*/
145   1,                            /*0x0699*/
146   1+2, 1+2, 1+2, 1+2, 1+2, 1+2, /*0x069A-0x069F*/
147   1+2, 1+2, 1+2, 1+2,           /*0x06A0-0x06A3*/
148   1+2              + 256 * 0x2E,/*0x06A4*/
149   1+2,                          /*0x06A5*/
150   1+2              + 256 * 0x1E,/*0x06A6*/
151   1+2, 1+2,                     /*0x06A7-0x06A8*/
152   1+2              + 256 * 0x3E,/*0x06A9*/
153   1+2, 1+2, 1+2,                /*0x06AA-0x06AC*/
154   1+2              + 256 * 0x83,/*0x06AD*/
155   1+2,                          /*0x06AE*/
156   1+2              + 256 * 0x42,/*0x06AF*/
157   1+2,                          /*0x06B0*/
158   1+2              + 256 * 0x4A,/*0x06B1*/
159   1+2,                          /*0x06B2*/
160   1+2              + 256 * 0x46,/*0x06B3*/
161   1+2, 1+2, 1+2, 1+2, 1+2, 1+2, /*0x06B4-0x06B9*/
162   1+2,                          /*0x06BA*/          // FIXME: Seems to have a final form
163   1+2              + 256 * 0x50,/*0x06BB*/
164   1+2, 1+2,                     /*0x06BC-0x06BD*/
165   1+2              + 256 * 0x5A,/*0x06BE*/
166   1+2,                          /*0x06BF*/
167   1,                            /*0x06C0*/
168   1+2              + 256 * 0x56,/*0x06C1*/
169   1+2,                          /*0x06C2*/
170   1, 1,                         /*0x06C3-0x06C4*/
171   1                + 256 * 0x90,/*0x06C5*/
172   1                + 256 * 0x89,/*0x06C6*/
173   1                + 256 * 0x87,/*0x06C7*/
174   1                + 256 * 0x8B,/*0x06C8*/
175   1                + 256 * 0x92,/*0x06C9*/
176   1,                            /*0x06CA*/
177   1                + 256 * 0x8E,/*0x06CB*/
178   1+2              + 256 * 0xAC,/*0x06CC*/
179   1,                            /*0x06CD*/
180   1+2,                          /*0x06CE*/
181   1,                            /*0x06CF*/
182   1+2              + 256 * 0x94,/*0x06D0*/
183   1+2,                          /*0x06D1*/
184   1                + 256 * 0x5E,/*0x06D2*/
185   1                + 256 * 0x60 /*0x06D3*/
186 };
187
188 static const UChar presLink[141]=
189 {
190   1 + 2,                        /*0xFE70*/
191   1 + 2,                        /*0xFE71*/
192   1 + 2, 0, 1+ 2, 0, 1+ 2,      /*0xFE72-0xFE76*/
193   1 + 2,                        /*0xFE77*/
194   1+ 2, 1 + 2, 1+2, 1 + 2,      /*0xFE78-0xFE81*/
195   1+ 2, 1 + 2, 1+2, 1 + 2,      /*0xFE82-0xFE85*/
196   0, 0 + 32, 1 + 32, 0 + 32,    /*0xFE86-0xFE89*/
197   1 + 32, 0, 1,  0 + 32,        /*0xFE8A-0xFE8D*/
198   1 + 32, 0, 2,  1 + 2,         /*0xFE8E-0xFE91*/
199   1, 0 + 32, 1 + 32, 0,         /*0xFE92-0xFE95*/
200   2, 1 + 2, 1, 0,               /*0xFE96-0xFE99*/
201   1, 0, 2, 1 + 2,               /*0xFE9A-0xFE9D*/
202   1, 0, 2, 1 + 2,               /*0xFE9E-0xFEA1*/
203   1, 0, 2, 1 + 2,               /*0xFEA2-0xFEA5*/
204   1, 0, 2, 1 + 2,               /*0xFEA6-0xFEA9*/
205   1, 0, 2, 1 + 2,               /*0xFEAA-0xFEAD*/
206   1, 0, 1, 0,                   /*0xFEAE-0xFEB1*/
207   1, 0, 1, 0,                   /*0xFEB2-0xFEB5*/
208   1, 0, 2, 1+2,                 /*0xFEB6-0xFEB9*/
209   1, 0, 2, 1+2,                 /*0xFEBA-0xFEBD*/
210   1, 0, 2, 1+2,                 /*0xFEBE-0xFEC1*/
211   1, 0, 2, 1+2,                 /*0xFEC2-0xFEC5*/
212   1, 0, 2, 1+2,                 /*0xFEC6-0xFEC9*/
213   1, 0, 2, 1+2,                 /*0xFECA-0xFECD*/
214   1, 0, 2, 1+2,                 /*0xFECE-0xFED1*/
215   1, 0, 2, 1+2,                 /*0xFED2-0xFED5*/
216   1, 0, 2, 1+2,                 /*0xFED6-0xFED9*/
217   1, 0, 2, 1+2,                 /*0xFEDA-0xFEDD*/
218   1, 0, 2, 1+2,                 /*0xFEDE-0xFEE1*/
219   1, 0 + 16, 2 + 16, 1 + 2 +16, /*0xFEE2-0xFEE5*/
220   1 + 16, 0, 2, 1+2,            /*0xFEE6-0xFEE9*/
221   1, 0, 2, 1+2,                 /*0xFEEA-0xFEED*/
222   1, 0, 2, 1+2,                 /*0xFEEE-0xFEF1*/
223   1, 0, 1, 0,                   /*0xFEF2-0xFEF5*/
224   1, 0, 2, 1+2,                 /*0xFEF6-0xFEF9*/
225   1, 0, 1, 0,                   /*0xFEFA-0xFEFD*/
226   1, 0, 1, 0,
227   1
228 };
229
230 static const UChar convertFEto06[] =
231 {
232 /***********0******1******2******3******4******5******6******7******8******9******A******B******C******D******E******F***/
233 /*FE7*/   0x64B, 0x64B, 0x64C, 0x64C, 0x64D, 0x64D, 0x64E, 0x64E, 0x64F, 0x64F, 0x650, 0x650, 0x651, 0x651, 0x652, 0x652,
234 /*FE8*/   0x621, 0x622, 0x622, 0x623, 0x623, 0x624, 0x624, 0x625, 0x625, 0x626, 0x626, 0x626, 0x626, 0x627, 0x627, 0x628,
235 /*FE9*/   0x628, 0x628, 0x628, 0x629, 0x629, 0x62A, 0x62A, 0x62A, 0x62A, 0x62B, 0x62B, 0x62B, 0x62B, 0x62C, 0x62C, 0x62C,
236 /*FEA*/   0x62C, 0x62D, 0x62D, 0x62D, 0x62D, 0x62E, 0x62E, 0x62E, 0x62E, 0x62F, 0x62F, 0x630, 0x630, 0x631, 0x631, 0x632,
237 /*FEB*/   0x632, 0x633, 0x633, 0x633, 0x633, 0x634, 0x634, 0x634, 0x634, 0x635, 0x635, 0x635, 0x635, 0x636, 0x636, 0x636,
238 /*FEC*/   0x636, 0x637, 0x637, 0x637, 0x637, 0x638, 0x638, 0x638, 0x638, 0x639, 0x639, 0x639, 0x639, 0x63A, 0x63A, 0x63A,
239 /*FED*/   0x63A, 0x641, 0x641, 0x641, 0x641, 0x642, 0x642, 0x642, 0x642, 0x643, 0x643, 0x643, 0x643, 0x644, 0x644, 0x644,
240 /*FEE*/   0x644, 0x645, 0x645, 0x645, 0x645, 0x646, 0x646, 0x646, 0x646, 0x647, 0x647, 0x647, 0x647, 0x648, 0x648, 0x649,
241 /*FEF*/   0x649, 0x64A, 0x64A, 0x64A, 0x64A, 0x65C, 0x65C, 0x65D, 0x65D, 0x65E, 0x65E, 0x65F, 0x65F
242 };
243
244 static const UChar shapeTable[4][4][4]=
245 {
246   { {0,0,0,0}, {0,0,0,0}, {0,1,0,3}, {0,1,0,1} },
247   { {0,0,2,2}, {0,0,1,2}, {0,1,1,2}, {0,1,1,3} },
248   { {0,0,0,0}, {0,0,0,0}, {0,1,0,3}, {0,1,0,3} },
249   { {0,0,1,2}, {0,0,1,2}, {0,1,1,2}, {0,1,1,3} }
250 };
251
252 /*
253  *Name     : changeLamAlef
254  *Function : Converts the Alef characters into an equivalent
255  *           LamAlef location in the 0x06xx Range, this is an
256  *           intermediate stage in the operation of the program
257  *           later it'll be converted into the 0xFExx LamAlefs
258  *           in the shaping function.
259  */
260 static UChar
261 changeLamAlef(UChar ch) {
262
263     switch(ch) {
264     case 0x0622 :
265         return(0x065C);
266         break;
267     case 0x0623 :
268         return(0x065D);
269         break;
270     case 0x0625 :
271         return(0x065E);
272         break;
273     case 0x0627 :
274         return(0x065F);
275         break;
276     default :
277         return(0);
278         break;
279     }
280 }
281
282 /*
283  *Name     : specialChar
284  *Function : Special Arabic characters need special handling in the shapeUnicode
285  *           function, this function returns 1 or 2 for these special characters
286  */
287 static int32_t
288 specialChar(UChar ch) {
289
290     if( (ch>0x0621 && ch<0x0626)||(ch==0x0627)||(ch>0x062e && ch<0x0633)||
291         (ch>0x0647 && ch<0x064a)||(ch==0x0629) ) {
292         return (1);
293     }
294     else
295     if( ch>=0x064B && ch<= 0x0652 )
296         return (2);
297     else
298     if( (ch>=0x0653 && ch<= 0x0655) || ch == 0x0670 ||
299         (ch>=0xFE70 && ch<= 0xFE7F) )
300         return (3);
301     else
302         return (0);
303 }
304
305 /*
306  *Name     : getLink
307  *Function : Resolves the link between the characters as
308  *           Arabic characters have four forms :
309  *           Isolated, Initial, Middle and Final Form
310  */
311 static UChar
312 getLink(UChar ch) {
313
314     if(ch >= 0x0622 && ch <= 0x06D3) {
315         return(araLink[ch-0x0622]);
316     } else if(ch == 0x200D) {
317         return(3);
318     } else if(ch >= 0x206D && ch <= 0x206F) {
319         return(4);
320     } else if(ch >= 0xFE70 && ch <= 0xFEFC) {
321         return(presLink[ch-0xFE70]);
322     } else {
323         return(0);
324     }
325 }
326
327 /*
328  *Name     : isTashkeelChar
329  *Function : Returns 1 for Tashkeel characters else return 0
330  */
331 static int32_t
332 isTashkeelChar(UChar ch) {
333
334     if( ch>=0x064B && ch<= 0x0652 )
335         return (1);
336     else
337         return (0);
338 }
339
340 /*
341  *Name     : shapeUnicode
342  *Function : Converts an Arabic Unicode buffer in 06xx Range into a shaped
343  *           arabic Unicode buffer in FExx Range
344  */
345 static int32_t
346 shapeUnicode(UChar *dest, int32_t sourceLength,
347              int32_t destSize,uint32_t options,
348              UErrorCode *pErrorCode,
349              int tashkeelFlag) {
350
351     int32_t          i, iend;
352     int32_t          prevPos, lastPos,Nx, Nw;
353     unsigned int     Shape;
354     int32_t          flag;
355     int32_t          lamalef_found = 0;
356     UChar            prevLink = 0, lastLink = 0, currLink, nextLink = 0;
357     UChar            wLamalef;
358
359     /*
360      * Converts the input buffer from FExx Range into 06xx Range
361      * to make sure that all characters are in the 06xx range
362      * even the lamalef is converted to the special region in
363      * the 06xx range
364      */
365     for (i = 0; i < sourceLength; i++) {
366         UChar inputChar = dest[i];
367         if ( (inputChar >= 0xFE70) && (inputChar <= 0xFEFC)) {
368             dest[i] = convertFEto06 [ (inputChar - 0xFE70) ] ;
369         }
370     }
371
372     /* sets the index to the end of the buffer, together with the step point to -1 */
373     i = 0;
374     iend = sourceLength;
375
376     /*
377      * This function resolves the link between the characters .
378      * Arabic characters have four forms :
379      * Isolated Form, Initial Form, Middle Form and Final Form
380      */
381     currLink = getLink(dest[i]);
382
383     prevPos = i;
384     lastPos = i;
385     Nx = sourceLength + 2, Nw = 0;
386
387     while (i != iend) {
388         /* If high byte of currLink > 0 then more than one shape */
389         if ((currLink & 0xFF00) > 0 || isTashkeelChar(dest[i])) {
390             Nw = i + 1;
391             while (Nx >= sourceLength) {         /* we need to know about next char */
392                 if(Nw == iend) {
393                     nextLink = 0;
394                     Nx = -1;
395                 } else {
396                     nextLink = getLink(dest[Nw]);
397                     if((nextLink & IRRELEVANT) == 0) {
398                         Nx = Nw;
399                     } else {
400                         Nw = Nw + 1;
401                     }
402                 }
403             }
404
405             if ( ((currLink & ALEFTYPE) > 0)  &&  ((lastLink & LAMTYPE) > 0) ) {
406                 lamalef_found = 1;
407                 wLamalef = changeLamAlef(dest[i]); /*get from 0x065C-0x065f */
408                 if ( wLamalef != 0) {
409                     dest[i] = ' ';               /* The default case is to drop the Alef and replace */
410                     dest[lastPos] =wLamalef;     /* it by a space.                                   */
411                     i=lastPos;
412                 }
413                 lastLink = prevLink;
414                 currLink = getLink(wLamalef);
415             }
416             /*
417              * get the proper shape according to link ability of neighbors
418              * and of character; depends on the order of the shapes
419              * (isolated, initial, middle, final) in the compatibility area
420              */
421              flag  = specialChar(dest[i]);
422
423              Shape = shapeTable[nextLink & (LINKR + LINKL)]
424                                [lastLink & (LINKR + LINKL)]
425                                [currLink & (LINKR + LINKL)];
426
427              if (flag == 1) {
428                  Shape = (Shape == 1 || Shape == 3) ? 1 : 0;
429              }
430              else
431              if(flag == 2) {
432                  if( (lastLink & LINKL) && (nextLink & LINKR) && (tashkeelFlag == 1) &&
433                       dest[i] != 0x064C && dest[i] != 0x064D ) {
434                      Shape = 1;
435                      if( (nextLink&ALEFTYPE) == ALEFTYPE && (lastLink&LAMTYPE) == LAMTYPE )
436                          Shape = 0;
437                  }
438                  else {
439                      Shape = 0;
440                  }
441              }
442
443              if(flag == 2) {
444                  dest[i] =  0xFE70 + IrrelevantPos[(dest[i] - 0x064B)] + Shape;
445              }
446              else
447                  dest[i] = (UChar)((dest[i] < 0x0670 ? 0xFE70 : 0xFB50) + (currLink >> 8) + Shape);
448         }
449
450         /* move one notch forward */
451         if ((currLink & IRRELEVANT) == 0) {
452               prevLink = lastLink;
453               lastLink = currLink;
454               prevPos = lastPos;
455               lastPos = i;
456         }
457
458         i++;
459         if (i == Nx) {
460             currLink = nextLink;
461             Nx = sourceLength + 2;
462         }
463         else if(i != iend) {
464             currLink = getLink(dest[i]);
465         }
466     }
467
468     destSize = sourceLength;
469
470     return destSize;
471 }
472
473 int32_t shapeArabic(const UChar *source, int32_t sourceLength, UChar *dest, int32_t destCapacity, uint32_t options, UErrorCode *pErrorCode) {
474     int32_t destLength;
475
476     /* usual error checking */
477     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
478         return 0;
479     }
480
481     /* make sure that no reserved options values are used; allow dest==NULL only for preflighting */
482     if( source==NULL || sourceLength<-1 ||
483         (dest==NULL && destCapacity!=0) || destCapacity<0 ||
484         options>=U_SHAPE_DIGIT_TYPE_RESERVED ||
485         (options&U_SHAPE_DIGITS_MASK)>=U_SHAPE_DIGITS_RESERVED
486     ) {
487         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
488         return 0;
489     }
490
491     /* determine the source length */
492     if(sourceLength==-1) {
493         sourceLength=u_strlen(source);
494     }
495     if(sourceLength==0) {
496         return 0;
497     }
498
499     /* check that source and destination do not overlap */
500     if( dest!=NULL &&
501         ((source<=dest && dest<source+sourceLength) ||
502          (dest<=source && source<dest+destCapacity))
503     ) {
504         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
505         return 0;
506     }
507
508     if((options&U_SHAPE_LETTERS_MASK)!=U_SHAPE_LETTERS_NOOP) {
509         int32_t outputSize = sourceLength;
510
511         /* calculate destination size */
512         /* TODO: do we ever need to do this pure preflighting? */
513         ASSERT((options&U_SHAPE_LENGTH_MASK) != U_SHAPE_LENGTH_GROW_SHRINK);
514
515         if(outputSize>destCapacity) {
516             *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
517             return outputSize;
518         }
519
520         /* Start of Arabic letter shaping part */
521         memcpy(dest, source, sourceLength*U_SIZEOF_UCHAR);
522
523         ASSERT((options&U_SHAPE_TEXT_DIRECTION_MASK) == U_SHAPE_TEXT_DIRECTION_LOGICAL);
524
525         switch(options&U_SHAPE_LETTERS_MASK) {
526         case U_SHAPE_LETTERS_SHAPE :
527             /* Call the shaping function with tashkeel flag == 1 */
528             destLength = shapeUnicode(dest,sourceLength,destCapacity,options,pErrorCode,1);
529             break;
530         case U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED :
531             /* Call the shaping function with tashkeel flag == 0 */
532             destLength = shapeUnicode(dest,sourceLength,destCapacity,options,pErrorCode,0);
533             break;
534         case U_SHAPE_LETTERS_UNSHAPE :
535             ASSERT_NOT_REACHED();
536             break;
537         default :
538             /* will never occur because of validity checks above */
539             destLength = 0;
540             break;
541         }
542
543         /* End of Arabic letter shaping part */
544     } else
545         ASSERT_NOT_REACHED();
546
547     ASSERT((options & U_SHAPE_DIGITS_MASK) == U_SHAPE_DIGITS_NOOP); 
548
549     return sourceLength;
550 }