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