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 79static UChar tailChar = OLD_TAIL_CHAR; 80static uint32_t uShapeLamalefBegin = U_SHAPE_LAMALEF_BEGIN; 81static uint32_t uShapeLamalefEnd = U_SHAPE_LAMALEF_END; 82static uint32_t uShapeTashkeelBegin = U_SHAPE_TASHKEEL_BEGIN; 83static uint32_t uShapeTashkeelEnd = U_SHAPE_TASHKEEL_END; 84static int spacesRelativeToTextBeginEnd = 0; 85 86static 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 103static 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 122static const UChar yehHamzaToYeh[] = 123{ 124/* isolated*/ 0xFEEF, 125/* final */ 0xFEF0 126}; 127 128static const uint8_t IrrelevantPos[] = { 129 0x0, 0x2, 0x4, 0x6, 130 0x8, 0xA, 0xC, 0xE 131}; 132 133 134static 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 146static 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 234static 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 256static 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 270static 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 286static 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 300static 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 */ 314static 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 */ 375static void 376invertBuffer(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 */ 394static U_INLINE UChar 395changeLamAlef(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 */ 415static UChar 416getLink(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 */ 437static void 438countSpaces(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 */ 457static U_INLINE int32_t 458isTashkeelChar(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 */ 466static U_INLINE int32_t 467isTashkeelCharFE(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 */ 475static U_INLINE int32_t 476isAlefChar(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 */ 484static U_INLINE int32_t 485isLamAlefChar(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 494static U_INLINE int32_t 495isTailChar(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 509static U_INLINE int32_t 510isSeenTailFamilyChar(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 523static U_INLINE int32_t 524isSeenFamilyChar(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 */ 538static U_INLINE int32_t 539isAlefMaksouraChar(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 */ 548static U_INLINE int32_t 549isYehHamzaChar(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 */ 564static U_INLINE int32_t 565isTashkeelOnTatweelChar(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 */ 583static U_INLINE int32_t 584isIsolatedTashkeelChar(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 605static int32_t 606calculateSize(const UChar *source, int32_t sourceLength, 607int32_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 */ 662static int32_t 663handleTashkeelWithTatweel(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 700static int32_t 701handleGeneratedSpaces(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 887static int32_t 888expandCompositCharAtBegin(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 944static int32_t 945expandCompositCharAtEnd(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 1011static int32_t 1012expandCompositCharAtNear(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 1064static int32_t 1065expandCompositChar(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 */ 1177static int32_t 1178shapeUnicode(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 */ 1345static int32_t 1346deShapeUnicode(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 1398U_CAPI int32_t U_EXPORT2 1399u_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} 1713