src/third_party/icu/source/common/ushape.cpp

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