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

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