| /* | |
| ****************************************************************************** | |
| * | |
| * Copyright (C) 2000-2004, International Business Machines | |
| * Corporation and others. All Rights Reserved. | |
| * Copyright (C) 2007 Apple Inc. All rights reserved. | |
| * | |
| * Permission is hereby granted, free of charge, to any person obtaining a copy of this | |
| * software and associated documentation files (the "Software"), to deal in the Software | |
| * without restriction, including without limitation the rights to use, copy, modify, | |
| * merge, publish, distribute, and/or sell copies of the Software, and to permit persons | |
| * to whom the Software is furnished to do so, provided that the above copyright notice(s) | |
| * and this permission notice appear in all copies of the Software and that both the above | |
| * copyright notice(s) and this permission notice appear in supporting documentation. | |
| * | |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, | |
| * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR | |
| * PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER | |
| * OR HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR | |
| * CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR | |
| * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING | |
| * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | |
| * | |
| * Except as contained in this notice, the name of a copyright holder shall not be used in | |
| * advertising or otherwise to promote the sale, use or other dealings in this Software | |
| * without prior written authorization of the copyright holder. | |
| * | |
| ****************************************************************************** | |
| * | |
| * Arabic letter shaping implemented by Ayman Roshdy | |
| */ | |
| #include "config.h" | |
| #if USE(ATSUI) | |
| #include "ShapeArabic.h" | |
| #include <stdbool.h> | |
| #include <string.h> | |
| #include <unicode/utypes.h> | |
| #include <unicode/uchar.h> | |
| #include <unicode/ustring.h> | |
| #include <unicode/ushape.h> | |
| #include <wtf/Assertions.h> | |
| /* | |
| * ### TODO in general for letter shaping: | |
| * - the letter shaping code is UTF-16-unaware; needs update | |
| * + especially invertBuffer()?! | |
| * - needs to handle the "Arabic Tail" that is used in some legacy codepages | |
| * as a glyph fragment of wide-glyph letters | |
| * + IBM Unicode conversion tables map it to U+200B (ZWSP) | |
| * + IBM Egypt has proposed to encode the tail in Unicode among Arabic Presentation Forms | |
| */ | |
| /* definitions for Arabic letter shaping ------------------------------------ */ | |
| #define IRRELEVANT 4 | |
| #define LAMTYPE 16 | |
| #define ALEFTYPE 32 | |
| #define LINKR 1 | |
| #define LINKL 2 | |
| static const UChar IrrelevantPos[] = { | |
| 0x0, 0x2, 0x4, 0x6, | |
| 0x8, 0xA, 0xC, 0xE, | |
| }; | |
| static const UChar araLink[178]= | |
| { | |
| 1 + 32 + 256 * 0x11,/*0x0622*/ | |
| 1 + 32 + 256 * 0x13,/*0x0623*/ | |
| 1 + 256 * 0x15,/*0x0624*/ | |
| 1 + 32 + 256 * 0x17,/*0x0625*/ | |
| 1 + 2 + 256 * 0x19,/*0x0626*/ | |
| 1 + 32 + 256 * 0x1D,/*0x0627*/ | |
| 1 + 2 + 256 * 0x1F,/*0x0628*/ | |
| 1 + 256 * 0x23,/*0x0629*/ | |
| 1 + 2 + 256 * 0x25,/*0x062A*/ | |
| 1 + 2 + 256 * 0x29,/*0x062B*/ | |
| 1 + 2 + 256 * 0x2D,/*0x062C*/ | |
| 1 + 2 + 256 * 0x31,/*0x062D*/ | |
| 1 + 2 + 256 * 0x35,/*0x062E*/ | |
| 1 + 256 * 0x39,/*0x062F*/ | |
| 1 + 256 * 0x3B,/*0x0630*/ | |
| 1 + 256 * 0x3D,/*0x0631*/ | |
| 1 + 256 * 0x3F,/*0x0632*/ | |
| 1 + 2 + 256 * 0x41,/*0x0633*/ | |
| 1 + 2 + 256 * 0x45,/*0x0634*/ | |
| 1 + 2 + 256 * 0x49,/*0x0635*/ | |
| 1 + 2 + 256 * 0x4D,/*0x0636*/ | |
| 1 + 2 + 256 * 0x51,/*0x0637*/ | |
| 1 + 2 + 256 * 0x55,/*0x0638*/ | |
| 1 + 2 + 256 * 0x59,/*0x0639*/ | |
| 1 + 2 + 256 * 0x5D,/*0x063A*/ | |
| 0, 0, 0, 0, 0, /*0x063B-0x063F*/ | |
| 1 + 2, /*0x0640*/ | |
| 1 + 2 + 256 * 0x61,/*0x0641*/ | |
| 1 + 2 + 256 * 0x65,/*0x0642*/ | |
| 1 + 2 + 256 * 0x69,/*0x0643*/ | |
| 1 + 2 + 16 + 256 * 0x6D,/*0x0644*/ | |
| 1 + 2 + 256 * 0x71,/*0x0645*/ | |
| 1 + 2 + 256 * 0x75,/*0x0646*/ | |
| 1 + 2 + 256 * 0x79,/*0x0647*/ | |
| 1 + 256 * 0x7D,/*0x0648*/ | |
| 1 + 256 * 0x7F,/*0x0649*/ | |
| 1 + 2 + 256 * 0x81,/*0x064A*/ | |
| 4, 4, 4, 4, /*0x064B-0x064E*/ | |
| 4, 4, 4, 4, /*0x064F-0x0652*/ | |
| 4, 4, 4, 0, 0, /*0x0653-0x0657*/ | |
| 0, 0, 0, 0, /*0x0658-0x065B*/ | |
| 1 + 256 * 0x85,/*0x065C*/ | |
| 1 + 256 * 0x87,/*0x065D*/ | |
| 1 + 256 * 0x89,/*0x065E*/ | |
| 1 + 256 * 0x8B,/*0x065F*/ | |
| 0, 0, 0, 0, 0, /*0x0660-0x0664*/ | |
| 0, 0, 0, 0, 0, /*0x0665-0x0669*/ | |
| 0, 0, 0, 0, 0, 0, /*0x066A-0x066F*/ | |
| 4, /*0x0670*/ | |
| 0, /*0x0671*/ | |
| 1 + 32, /*0x0672*/ | |
| 1 + 32, /*0x0673*/ | |
| 0, /*0x0674*/ | |
| 1 + 32, /*0x0675*/ | |
| 1, 1, /*0x0676-0x0677*/ | |
| 1+2, /*0x0678*/ | |
| 1+2 + 256 * 0x16,/*0x0679*/ | |
| 1+2 + 256 * 0x0E,/*0x067A*/ | |
| 1+2 + 256 * 0x02,/*0x067B*/ | |
| 1+2, 1+2, /*0x067C-0x067D*/ | |
| 1+2 + 256 * 0x06,/*0x067E*/ | |
| 1+2 + 256 * 0x12,/*0x067F*/ | |
| 1+2 + 256 * 0x0A,/*0x0680*/ | |
| 1+2, 1+2, /*0x0681-0x0682*/ | |
| 1+2 + 256 * 0x26,/*0x0683*/ | |
| 1+2 + 256 * 0x22,/*0x0684*/ | |
| 1+2, /*0x0685*/ | |
| 1+2 + 256 * 0x2A,/*0x0686*/ | |
| 1+2 + 256 * 0x2E,/*0x0687*/ | |
| 1 + 256 * 0x38,/*0x0688*/ | |
| 1, 1, 1, /*0x0689-0x068B*/ | |
| 1 + 256 * 0x34,/*0x068C*/ | |
| 1 + 256 * 0x32,/*0x068D*/ | |
| 1 + 256 * 0x36,/*0x068E*/ | |
| 1, 1, /*0x068F-0x0690*/ | |
| 1 + 256 * 0x3C,/*0x0691*/ | |
| 1, 1, 1, 1, 1, 1, /*0x0692-0x0697*/ | |
| 1 + 256 * 0x3A,/*0x0698*/ | |
| 1, /*0x0699*/ | |
| 1+2, 1+2, 1+2, 1+2, 1+2, 1+2, /*0x069A-0x069F*/ | |
| 1+2, 1+2, 1+2, 1+2, /*0x06A0-0x06A3*/ | |
| 1+2 + 256 * 0x2E,/*0x06A4*/ | |
| 1+2, /*0x06A5*/ | |
| 1+2 + 256 * 0x1E,/*0x06A6*/ | |
| 1+2, 1+2, /*0x06A7-0x06A8*/ | |
| 1+2 + 256 * 0x3E,/*0x06A9*/ | |
| 1+2, 1+2, 1+2, /*0x06AA-0x06AC*/ | |
| 1+2 + 256 * 0x83,/*0x06AD*/ | |
| 1+2, /*0x06AE*/ | |
| 1+2 + 256 * 0x42,/*0x06AF*/ | |
| 1+2, /*0x06B0*/ | |
| 1+2 + 256 * 0x4A,/*0x06B1*/ | |
| 1+2, /*0x06B2*/ | |
| 1+2 + 256 * 0x46,/*0x06B3*/ | |
| 1+2, 1+2, 1+2, 1+2, 1+2, 1+2, /*0x06B4-0x06B9*/ | |
| 1+2, /*0x06BA*/ // FIXME: Seems to have a final form | |
| 1+2 + 256 * 0x50,/*0x06BB*/ | |
| 1+2, 1+2, /*0x06BC-0x06BD*/ | |
| 1+2 + 256 * 0x5A,/*0x06BE*/ | |
| 1+2, /*0x06BF*/ | |
| 1, /*0x06C0*/ | |
| 1+2 + 256 * 0x56,/*0x06C1*/ | |
| 1+2, /*0x06C2*/ | |
| 1, 1, /*0x06C3-0x06C4*/ | |
| 1 + 256 * 0x90,/*0x06C5*/ | |
| 1 + 256 * 0x89,/*0x06C6*/ | |
| 1 + 256 * 0x87,/*0x06C7*/ | |
| 1 + 256 * 0x8B,/*0x06C8*/ | |
| 1 + 256 * 0x92,/*0x06C9*/ | |
| 1, /*0x06CA*/ | |
| 1 + 256 * 0x8E,/*0x06CB*/ | |
| 1+2 + 256 * 0xAC,/*0x06CC*/ | |
| 1, /*0x06CD*/ | |
| 1+2, /*0x06CE*/ | |
| 1, /*0x06CF*/ | |
| 1+2 + 256 * 0x94,/*0x06D0*/ | |
| 1+2, /*0x06D1*/ | |
| 1 + 256 * 0x5E,/*0x06D2*/ | |
| 1 + 256 * 0x60 /*0x06D3*/ | |
| }; | |
| static const UChar presLink[141]= | |
| { | |
| 1 + 2, /*0xFE70*/ | |
| 1 + 2, /*0xFE71*/ | |
| 1 + 2, 0, 1+ 2, 0, 1+ 2, /*0xFE72-0xFE76*/ | |
| 1 + 2, /*0xFE77*/ | |
| 1+ 2, 1 + 2, 1+2, 1 + 2, /*0xFE78-0xFE81*/ | |
| 1+ 2, 1 + 2, 1+2, 1 + 2, /*0xFE82-0xFE85*/ | |
| 0, 0 + 32, 1 + 32, 0 + 32, /*0xFE86-0xFE89*/ | |
| 1 + 32, 0, 1, 0 + 32, /*0xFE8A-0xFE8D*/ | |
| 1 + 32, 0, 2, 1 + 2, /*0xFE8E-0xFE91*/ | |
| 1, 0 + 32, 1 + 32, 0, /*0xFE92-0xFE95*/ | |
| 2, 1 + 2, 1, 0, /*0xFE96-0xFE99*/ | |
| 1, 0, 2, 1 + 2, /*0xFE9A-0xFE9D*/ | |
| 1, 0, 2, 1 + 2, /*0xFE9E-0xFEA1*/ | |
| 1, 0, 2, 1 + 2, /*0xFEA2-0xFEA5*/ | |
| 1, 0, 2, 1 + 2, /*0xFEA6-0xFEA9*/ | |
| 1, 0, 2, 1 + 2, /*0xFEAA-0xFEAD*/ | |
| 1, 0, 1, 0, /*0xFEAE-0xFEB1*/ | |
| 1, 0, 1, 0, /*0xFEB2-0xFEB5*/ | |
| 1, 0, 2, 1+2, /*0xFEB6-0xFEB9*/ | |
| 1, 0, 2, 1+2, /*0xFEBA-0xFEBD*/ | |
| 1, 0, 2, 1+2, /*0xFEBE-0xFEC1*/ | |
| 1, 0, 2, 1+2, /*0xFEC2-0xFEC5*/ | |
| 1, 0, 2, 1+2, /*0xFEC6-0xFEC9*/ | |
| 1, 0, 2, 1+2, /*0xFECA-0xFECD*/ | |
| 1, 0, 2, 1+2, /*0xFECE-0xFED1*/ | |
| 1, 0, 2, 1+2, /*0xFED2-0xFED5*/ | |
| 1, 0, 2, 1+2, /*0xFED6-0xFED9*/ | |
| 1, 0, 2, 1+2, /*0xFEDA-0xFEDD*/ | |
| 1, 0, 2, 1+2, /*0xFEDE-0xFEE1*/ | |
| 1, 0 + 16, 2 + 16, 1 + 2 +16, /*0xFEE2-0xFEE5*/ | |
| 1 + 16, 0, 2, 1+2, /*0xFEE6-0xFEE9*/ | |
| 1, 0, 2, 1+2, /*0xFEEA-0xFEED*/ | |
| 1, 0, 2, 1+2, /*0xFEEE-0xFEF1*/ | |
| 1, 0, 1, 0, /*0xFEF2-0xFEF5*/ | |
| 1, 0, 2, 1+2, /*0xFEF6-0xFEF9*/ | |
| 1, 0, 1, 0, /*0xFEFA-0xFEFD*/ | |
| 1, 0, 1, 0, | |
| 1 | |
| }; | |
| static const UChar convertFEto06[] = | |
| { | |
| /***********0******1******2******3******4******5******6******7******8******9******A******B******C******D******E******F***/ | |
| /*FE7*/ 0x64B, 0x64B, 0x64C, 0x64C, 0x64D, 0x64D, 0x64E, 0x64E, 0x64F, 0x64F, 0x650, 0x650, 0x651, 0x651, 0x652, 0x652, | |
| /*FE8*/ 0x621, 0x622, 0x622, 0x623, 0x623, 0x624, 0x624, 0x625, 0x625, 0x626, 0x626, 0x626, 0x626, 0x627, 0x627, 0x628, | |
| /*FE9*/ 0x628, 0x628, 0x628, 0x629, 0x629, 0x62A, 0x62A, 0x62A, 0x62A, 0x62B, 0x62B, 0x62B, 0x62B, 0x62C, 0x62C, 0x62C, | |
| /*FEA*/ 0x62C, 0x62D, 0x62D, 0x62D, 0x62D, 0x62E, 0x62E, 0x62E, 0x62E, 0x62F, 0x62F, 0x630, 0x630, 0x631, 0x631, 0x632, | |
| /*FEB*/ 0x632, 0x633, 0x633, 0x633, 0x633, 0x634, 0x634, 0x634, 0x634, 0x635, 0x635, 0x635, 0x635, 0x636, 0x636, 0x636, | |
| /*FEC*/ 0x636, 0x637, 0x637, 0x637, 0x637, 0x638, 0x638, 0x638, 0x638, 0x639, 0x639, 0x639, 0x639, 0x63A, 0x63A, 0x63A, | |
| /*FED*/ 0x63A, 0x641, 0x641, 0x641, 0x641, 0x642, 0x642, 0x642, 0x642, 0x643, 0x643, 0x643, 0x643, 0x644, 0x644, 0x644, | |
| /*FEE*/ 0x644, 0x645, 0x645, 0x645, 0x645, 0x646, 0x646, 0x646, 0x646, 0x647, 0x647, 0x647, 0x647, 0x648, 0x648, 0x649, | |
| /*FEF*/ 0x649, 0x64A, 0x64A, 0x64A, 0x64A, 0x65C, 0x65C, 0x65D, 0x65D, 0x65E, 0x65E, 0x65F, 0x65F | |
| }; | |
| static const UChar shapeTable[4][4][4]= | |
| { | |
| { {0,0,0,0}, {0,0,0,0}, {0,1,0,3}, {0,1,0,1} }, | |
| { {0,0,2,2}, {0,0,1,2}, {0,1,1,2}, {0,1,1,3} }, | |
| { {0,0,0,0}, {0,0,0,0}, {0,1,0,3}, {0,1,0,3} }, | |
| { {0,0,1,2}, {0,0,1,2}, {0,1,1,2}, {0,1,1,3} } | |
| }; | |
| /* | |
| *Name : changeLamAlef | |
| *Function : Converts the Alef characters into an equivalent | |
| * LamAlef location in the 0x06xx Range, this is an | |
| * intermediate stage in the operation of the program | |
| * later it'll be converted into the 0xFExx LamAlefs | |
| * in the shaping function. | |
| */ | |
| static UChar | |
| changeLamAlef(UChar ch) { | |
| switch(ch) { | |
| case 0x0622 : | |
| return(0x065C); | |
| break; | |
| case 0x0623 : | |
| return(0x065D); | |
| break; | |
| case 0x0625 : | |
| return(0x065E); | |
| break; | |
| case 0x0627 : | |
| return(0x065F); | |
| break; | |
| default : | |
| return(0); | |
| break; | |
| } | |
| } | |
| /* | |
| *Name : specialChar | |
| *Function : Special Arabic characters need special handling in the shapeUnicode | |
| * function, this function returns 1 or 2 for these special characters | |
| */ | |
| static int32_t | |
| specialChar(UChar ch) { | |
| if( (ch>0x0621 && ch<0x0626)||(ch==0x0627)||(ch>0x062e && ch<0x0633)|| | |
| (ch>0x0647 && ch<0x064a)||(ch==0x0629) ) { | |
| return (1); | |
| } | |
| else | |
| if( ch>=0x064B && ch<= 0x0652 ) | |
| return (2); | |
| else | |
| if( (ch>=0x0653 && ch<= 0x0655) || ch == 0x0670 || | |
| (ch>=0xFE70 && ch<= 0xFE7F) ) | |
| return (3); | |
| else | |
| return (0); | |
| } | |
| /* | |
| *Name : getLink | |
| *Function : Resolves the link between the characters as | |
| * Arabic characters have four forms : | |
| * Isolated, Initial, Middle and Final Form | |
| */ | |
| static UChar | |
| getLink(UChar ch) { | |
| if(ch >= 0x0622 && ch <= 0x06D3) { | |
| return(araLink[ch-0x0622]); | |
| } else if(ch == 0x200D) { | |
| return(3); | |
| } else if(ch >= 0x206D && ch <= 0x206F) { | |
| return(4); | |
| } else if(ch >= 0xFE70 && ch <= 0xFEFC) { | |
| return(presLink[ch-0xFE70]); | |
| } else { | |
| return(0); | |
| } | |
| } | |
| /* | |
| *Name : isTashkeelChar | |
| *Function : Returns 1 for Tashkeel characters else return 0 | |
| */ | |
| static int32_t | |
| isTashkeelChar(UChar ch) { | |
| if( ch>=0x064B && ch<= 0x0652 ) | |
| return (1); | |
| else | |
| return (0); | |
| } | |
| /* | |
| *Name : shapeUnicode | |
| *Function : Converts an Arabic Unicode buffer in 06xx Range into a shaped | |
| * arabic Unicode buffer in FExx Range | |
| */ | |
| static int32_t | |
| shapeUnicode(UChar *dest, int32_t sourceLength, | |
| int32_t destSize, | |
| int tashkeelFlag) { | |
| int32_t i, iend; | |
| int32_t prevPos, lastPos,Nx, Nw; | |
| unsigned int Shape; | |
| int32_t flag; | |
| int32_t lamalef_found = 0; | |
| UChar prevLink = 0, lastLink = 0, currLink, nextLink = 0; | |
| UChar wLamalef; | |
| /* | |
| * Converts the input buffer from FExx Range into 06xx Range | |
| * to make sure that all characters are in the 06xx range | |
| * even the lamalef is converted to the special region in | |
| * the 06xx range | |
| */ | |
| for (i = 0; i < sourceLength; i++) { | |
| UChar inputChar = dest[i]; | |
| if ( (inputChar >= 0xFE70) && (inputChar <= 0xFEFC)) { | |
| dest[i] = convertFEto06 [ (inputChar - 0xFE70) ] ; | |
| } | |
| } | |
| /* sets the index to the end of the buffer, together with the step point to -1 */ | |
| i = 0; | |
| iend = sourceLength; | |
| /* | |
| * This function resolves the link between the characters . | |
| * Arabic characters have four forms : | |
| * Isolated Form, Initial Form, Middle Form and Final Form | |
| */ | |
| currLink = getLink(dest[i]); | |
| prevPos = i; | |
| lastPos = i; | |
| Nx = sourceLength + 2, Nw = 0; | |
| while (i != iend) { | |
| /* If high byte of currLink > 0 then more than one shape */ | |
| if ((currLink & 0xFF00) > 0 || isTashkeelChar(dest[i])) { | |
| Nw = i + 1; | |
| while (Nx >= sourceLength) { /* we need to know about next char */ | |
| if(Nw == iend) { | |
| nextLink = 0; | |
| Nx = -1; | |
| } else { | |
| nextLink = getLink(dest[Nw]); | |
| if((nextLink & IRRELEVANT) == 0) { | |
| Nx = Nw; | |
| } else { | |
| Nw = Nw + 1; | |
| } | |
| } | |
| } | |
| if ( ((currLink & ALEFTYPE) > 0) && ((lastLink & LAMTYPE) > 0) ) { | |
| lamalef_found = 1; | |
| wLamalef = changeLamAlef(dest[i]); /*get from 0x065C-0x065f */ | |
| if ( wLamalef != 0) { | |
| dest[i] = ' '; /* The default case is to drop the Alef and replace */ | |
| dest[lastPos] =wLamalef; /* it by a space. */ | |
| i=lastPos; | |
| } | |
| lastLink = prevLink; | |
| currLink = getLink(wLamalef); | |
| } | |
| /* | |
| * get the proper shape according to link ability of neighbors | |
| * and of character; depends on the order of the shapes | |
| * (isolated, initial, middle, final) in the compatibility area | |
| */ | |
| flag = specialChar(dest[i]); | |
| Shape = shapeTable[nextLink & (LINKR + LINKL)] | |
| [lastLink & (LINKR + LINKL)] | |
| [currLink & (LINKR + LINKL)]; | |
| if (flag == 1) { | |
| Shape = (Shape == 1 || Shape == 3) ? 1 : 0; | |
| } | |
| else | |
| if(flag == 2) { | |
| if( (lastLink & LINKL) && (nextLink & LINKR) && (tashkeelFlag == 1) && | |
| dest[i] != 0x064C && dest[i] != 0x064D ) { | |
| Shape = 1; | |
| if( (nextLink&ALEFTYPE) == ALEFTYPE && (lastLink&LAMTYPE) == LAMTYPE ) | |
| Shape = 0; | |
| } | |
| else { | |
| Shape = 0; | |
| } | |
| } | |
| if(flag == 2) { | |
| dest[i] = 0xFE70 + IrrelevantPos[(dest[i] - 0x064B)] + Shape; | |
| } | |
| else | |
| dest[i] = (UChar)((dest[i] < 0x0670 ? 0xFE70 : 0xFB50) + (currLink >> 8) + Shape); | |
| } | |
| /* move one notch forward */ | |
| if ((currLink & IRRELEVANT) == 0) { | |
| prevLink = lastLink; | |
| lastLink = currLink; | |
| prevPos = lastPos; | |
| lastPos = i; | |
| } | |
| i++; | |
| if (i == Nx) { | |
| currLink = nextLink; | |
| Nx = sourceLength + 2; | |
| } | |
| else if(i != iend) { | |
| currLink = getLink(dest[i]); | |
| } | |
| } | |
| destSize = sourceLength; | |
| return destSize; | |
| } | |
| int32_t shapeArabic(const UChar *source, int32_t sourceLength, UChar *dest, int32_t destCapacity, uint32_t options, UErrorCode *pErrorCode) { | |
| int32_t destLength; | |
| /* usual error checking */ | |
| if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { | |
| return 0; | |
| } | |
| /* make sure that no reserved options values are used; allow dest==NULL only for preflighting */ | |
| if( source==NULL || sourceLength<-1 || | |
| (dest==NULL && destCapacity!=0) || destCapacity<0 || | |
| options>=U_SHAPE_DIGIT_TYPE_RESERVED || | |
| (options&U_SHAPE_DIGITS_MASK)>=U_SHAPE_DIGITS_RESERVED | |
| ) { | |
| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; | |
| return 0; | |
| } | |
| /* determine the source length */ | |
| if(sourceLength==-1) { | |
| sourceLength=u_strlen(source); | |
| } | |
| if(sourceLength==0) { | |
| return 0; | |
| } | |
| /* check that source and destination do not overlap */ | |
| if( dest!=NULL && | |
| ((source<=dest && dest<source+sourceLength) || | |
| (dest<=source && source<dest+destCapacity)) | |
| ) { | |
| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; | |
| return 0; | |
| } | |
| if((options&U_SHAPE_LETTERS_MASK)!=U_SHAPE_LETTERS_NOOP) { | |
| int32_t outputSize = sourceLength; | |
| /* calculate destination size */ | |
| /* TODO: do we ever need to do this pure preflighting? */ | |
| ASSERT((options&U_SHAPE_LENGTH_MASK) != U_SHAPE_LENGTH_GROW_SHRINK); | |
| if(outputSize>destCapacity) { | |
| *pErrorCode=U_BUFFER_OVERFLOW_ERROR; | |
| return outputSize; | |
| } | |
| /* Start of Arabic letter shaping part */ | |
| memcpy(dest, source, sourceLength*U_SIZEOF_UCHAR); | |
| ASSERT((options&U_SHAPE_TEXT_DIRECTION_MASK) == U_SHAPE_TEXT_DIRECTION_LOGICAL); | |
| switch(options&U_SHAPE_LETTERS_MASK) { | |
| case U_SHAPE_LETTERS_SHAPE : | |
| /* Call the shaping function with tashkeel flag == 1 */ | |
| destLength = shapeUnicode(dest,sourceLength,destCapacity,1); | |
| break; | |
| case U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED : | |
| /* Call the shaping function with tashkeel flag == 0 */ | |
| destLength = shapeUnicode(dest,sourceLength,destCapacity,0); | |
| break; | |
| case U_SHAPE_LETTERS_UNSHAPE : | |
| ASSERT_NOT_REACHED(); | |
| break; | |
| default : | |
| /* will never occur because of validity checks above */ | |
| destLength = 0; | |
| break; | |
| } | |
| /* End of Arabic letter shaping part */ | |
| } else | |
| ASSERT_NOT_REACHED(); | |
| ASSERT((options & U_SHAPE_DIGITS_MASK) == U_SHAPE_DIGITS_NOOP); | |
| return sourceLength; | |
| } | |
| #endif // USE(ATSUI) |