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