Merge "Fix bug #8115437 Need to remove ArabicShaping from Framework"

2 files changed, 0 insertions, 1998 deletions

diff --git a/icu4j/java/android/icu/text/ArabicShaping.java b/icu4j/java/android/icu/text/ArabicShaping.java
deleted file mode 100644
index 13e2175..0000000
--- a/icu4j/java/android/icu/text/ArabicShaping.java
+++ /dev/null
@@ -1,1947 +0,0 @@
-/*
-*******************************************************************************
-*   Copyright (C) 2001-2009, International Business Machines
-*   Corporation and others.  All Rights Reserved.
-*******************************************************************************
-*/
-
-/*
- * Ported with minor modifications from ICU4J 4.2's
- * com.ibm.icu.text.ArabicShaping class.
- */
-
-package android.icu.text;
-
-
-/**
- * Shape Arabic text on a character basis.
- *
- * <p>ArabicShaping performs basic operations for "shaping" Arabic text. It is most
- * useful for use with legacy data formats and legacy display technology
- * (simple terminals). All operations are performed on Unicode characters.</p>
- *
- * <p>Text-based shaping means that some character code points in the text are
- * replaced by others depending on the context. It transforms one kind of text
- * into another. In comparison, modern displays for Arabic text select
- * appropriate, context-dependent font glyphs for each text element, which means
- * that they transform text into a glyph vector.</p>
- *
- * <p>Text transformations are necessary when modern display technology is not
- * available or when text needs to be transformed to or from legacy formats that
- * use "shaped" characters. Since the Arabic script is cursive, connecting
- * adjacent letters to each other, computers select images for each letter based
- * on the surrounding letters. This usually results in four images per Arabic
- * letter: initial, middle, final, and isolated forms. In Unicode, on the other
- * hand, letters are normally stored abstract, and a display system is expected
- * to select the necessary glyphs. (This makes searching and other text
- * processing easier because the same letter has only one code.) It is possible
- * to mimic this with text transformations because there are characters in
- * Unicode that are rendered as letters with a specific shape
- * (or cursive connectivity). They were included for interoperability with
- * legacy systems and codepages, and for unsophisticated display systems.</p>
- *
- * <p>A second kind of text transformations is supported for Arabic digits:
- * For compatibility with legacy codepages that only include European digits,
- * it is possible to replace one set of digits by another, changing the
- * character code points. These operations can be performed for either
- * Arabic-Indic Digits (U+0660...U+0669) or Eastern (Extended) Arabic-Indic
- * digits (U+06f0...U+06f9).</p>
- *
- * <p>Some replacements may result in more or fewer characters (code points).
- * By default, this means that the destination buffer may receive text with a
- * length different from the source length. Some legacy systems rely on the
- * length of the text to be constant. They expect extra spaces to be added
- * or consumed either next to the affected character or at the end of the
- * text.</p>
- * @stable ICU 2.0
- *
- * @hide
- */
-public class ArabicShaping {
-    private final int options;
-    private boolean isLogical; // convenience
-    private boolean spacesRelativeToTextBeginEnd;
-    private char tailChar;
-
-    public static final ArabicShaping SHAPER = new ArabicShaping(
-            ArabicShaping.TEXT_DIRECTION_LOGICAL |
-            ArabicShaping.LENGTH_FIXED_SPACES_NEAR |
-            ArabicShaping.LETTERS_SHAPE |
-            ArabicShaping.DIGITS_NOOP);
-
-    /**
-     * Convert a range of text in the source array, putting the result
-     * into a range of text in the destination array, and return the number
-     * of characters written.
-     *
-     * @param source An array containing the input text
-     * @param sourceStart The start of the range of text to convert
-     * @param sourceLength The length of the range of text to convert
-     * @param dest The destination array that will receive the result.
-     *   It may be <code>NULL</code> only if  <code>destSize</code> is 0.
-     * @param destStart The start of the range of the destination buffer to use.
-     * @param destSize The size (capacity) of the destination buffer.
-     *   If <code>destSize</code> is 0, then no output is produced,
-     *   but the necessary buffer size is returned ("preflighting").  This
-     *   does not validate the text against the options, for example,
-     *   if letters are being unshaped, and spaces are being consumed
-     *   following lamalef, this will not detect a lamalef without a
-     *   corresponding space.  An error will be thrown when the actual
-     *   conversion is attempted.
-     * @return The number of chars written to the destination buffer.
-     *   If an error occurs, then no output was written, or it may be
-     *   incomplete.
-     * @throws ArabicShapingException if the text cannot be converted according to the options.
-     * @stable ICU 2.0
-     */
-    public int shape(char[] source, int sourceStart, int sourceLength,
-                     char[] dest, int destStart, int destSize) throws ArabicShapingException {
-        if (source == null) {
-            throw new IllegalArgumentException("source can not be null");
-        }
-        if (sourceStart < 0 || sourceLength < 0 || sourceStart + sourceLength > source.length) {
-            throw new IllegalArgumentException("bad source start (" + sourceStart +
-                                               ") or length (" + sourceLength +
-                                               ") for buffer of length " + source.length);
-        }
-        if (dest == null && destSize != 0) {
-            throw new IllegalArgumentException("null dest requires destSize == 0");
-        }
-        if ((destSize != 0) &&
-            (destStart < 0 || destSize < 0 || destStart + destSize > dest.length)) {
-            throw new IllegalArgumentException("bad dest start (" + destStart +
-                                               ") or size (" + destSize +
-                                               ") for buffer of length " + dest.length);
-        }
-        /* Validate input options */
-        if ( ((options&TASHKEEL_MASK) > 0) &&
-             !(((options & TASHKEEL_MASK)==TASHKEEL_BEGIN)  ||
-               ((options & TASHKEEL_MASK)==TASHKEEL_END )   ||
-               ((options & TASHKEEL_MASK)==TASHKEEL_RESIZE )||
-               ((options & TASHKEEL_MASK)==TASHKEEL_REPLACE_BY_TATWEEL)) ){
-            throw new IllegalArgumentException("Wrong Tashkeel argument");
-        }
-
-       ///CLOVER:OFF
-       //According to Steven Loomis, the code is unreachable when you OR all the constants within the if statements
-       if(((options&LAMALEF_MASK) > 0)&&
-              !(((options & LAMALEF_MASK)==LAMALEF_BEGIN)  ||
-                ((options & LAMALEF_MASK)==LAMALEF_END )   ||
-                ((options & LAMALEF_MASK)==LAMALEF_RESIZE )||
-                 ((options & LAMALEF_MASK)==LAMALEF_AUTO)  ||
-                 ((options & LAMALEF_MASK)==LAMALEF_NEAR))){
-           throw new IllegalArgumentException("Wrong Lam Alef argument");
-       }
-       ///CLOVER:ON
-
-       /* Validate Tashkeel (Tashkeel replacement options should be enabled in shaping mode only)*/
-       if(((options&TASHKEEL_MASK) > 0) && (options&LETTERS_MASK) == LETTERS_UNSHAPE) {
-            throw new IllegalArgumentException("Tashkeel replacement should not be enabled in deshaping mode ");
-       }
-       return internalShape(source, sourceStart, sourceLength, dest, destStart, destSize);
-    }
-
-    /**
-     * Convert a range of text in place.  This may only be used if the Length option
-     * does not grow or shrink the text.
-     *
-     * @param source An array containing the input text
-     * @param start The start of the range of text to convert
-     * @param length The length of the range of text to convert
-     * @throws ArabicShapingException if the text cannot be converted according to the options.
-     * @stable ICU 2.0
-     */
-    public void shape(char[] source, int start, int length) throws ArabicShapingException {
-        if ((options & LAMALEF_MASK) == LAMALEF_RESIZE) {
-            throw new ArabicShapingException("Cannot shape in place with length option resize.");
-        }
-        shape(source, start, length, source, start, length);
-    }
-
-    /**
-     * Convert a string, returning the new string.
-     *
-     * @param text the string to convert
-     * @return the converted string
-     * @throws ArabicShapingException if the string cannot be converted according to the options.
-     * @stable ICU 2.0
-     */
-    public String shape(String text) throws ArabicShapingException {
-        char[] src = text.toCharArray();
-        char[] dest = src;
-        if (((options & LAMALEF_MASK) == LAMALEF_RESIZE) &&
-            ((options & LETTERS_MASK) == LETTERS_UNSHAPE)) {
-
-            dest = new char[src.length * 2]; // max
-        }
-        int len = shape(src, 0, src.length, dest, 0, dest.length);
-
-        return new String(dest, 0, len);
-    }
-
-    /**
-     * Construct ArabicShaping using the options flags.
-     * The flags are as follows:<br>
-     * 'LENGTH' flags control whether the text can change size, and if not,
-     * how to maintain the size of the text when LamAlef ligatures are
-     * formed or broken.<br>
-     * 'TEXT_DIRECTION' flags control whether the text is read and written
-     * in visual order or in logical order.<br>
-     * 'LETTERS_SHAPE' flags control whether conversion is to or from
-     * presentation forms.<br>
-     * 'DIGITS' flags control whether digits are shaped, and whether from
-     * European to Arabic-Indic or vice-versa.<br>
-     * 'DIGIT_TYPE' flags control whether standard or extended Arabic-Indic
-     * digits are used when performing digit conversion.
-     * @stable ICU 2.0
-     */
-    public ArabicShaping(int options) {
-        this.options = options;
-        if ((options & DIGITS_MASK) > 0x80) {
-            throw new IllegalArgumentException("bad DIGITS options");
-        }
-
-        isLogical = ( (options & TEXT_DIRECTION_MASK) == TEXT_DIRECTION_LOGICAL );
-        /* Validate options */
-        spacesRelativeToTextBeginEnd = ( (options & SPACES_RELATIVE_TO_TEXT_MASK) == SPACES_RELATIVE_TO_TEXT_BEGIN_END );
-        if ( (options&SHAPE_TAIL_TYPE_MASK) == SHAPE_TAIL_NEW_UNICODE){
-            tailChar = NEW_TAIL_CHAR;
-        } else {
-            tailChar = OLD_TAIL_CHAR;
-        }
-    }
-
-    /* Seen Tail options */
-    /**
-     * Memory option: the result must have the same length as the source.
-     * Shaping mode: The SEEN family character will expand into two characters using space near
-     *               the SEEN family character(i.e. the space after the character).
-     *               if there are no spaces found, ArabicShapingException will be thrown
-     *
-     * De-shaping mode: Any Seen character followed by Tail character will be
-     *                  replaced by one cell Seen and a space will replace the Tail.
-     * Affects: Seen options
-     */
-    public static final int SEEN_TWOCELL_NEAR = 0x200000;
-
-    /** Bit mask for Seen memory options. */
-    public static final int SEEN_MASK = 0x700000;
-
-    /* YehHamza options */
-    /**
-     * Memory option: the result must have the same length as the source.
-     * Shaping mode: The YEHHAMZA character will expand into two characters using space near it
-     *              (i.e. the space after the character)
-     *               if there are no spaces found, ArabicShapingException will be thrown
-     *
-     * De-shaping mode: Any Yeh (final or isolated) character followed by Hamza character will be
-     *                  replaced by one cell YehHamza and space will replace the Hamza.
-     * Affects: YehHamza options
-     */
-    public static final int YEHHAMZA_TWOCELL_NEAR  = 0x1000000;
-
-
-    /** Bit mask for YehHamza memory options. */
-    public static final int YEHHAMZA_MASK = 0x3800000;
-
-    /* New Tashkeel options */
-    /**
-     * Memory option: the result must have the same length as the source.
-     * Shaping mode: Tashkeel characters will be replaced by spaces.
-     *               Spaces will be placed at beginning of the buffer
-     *
-     * De-shaping mode: N/A
-     * Affects: Tashkeel options
-     */
-    public static final int TASHKEEL_BEGIN = 0x40000;
-
-    /**
-     * Memory option: the result must have the same length as the source.
-     * Shaping mode: Tashkeel characters will be replaced by spaces.
-     *               Spaces will be placed at end of the buffer
-     *
-     * De-shaping mode: N/A
-     * Affects: Tashkeel options
-     */
-    public static final int TASHKEEL_END = 0x60000;
-
-    /**
-     * Memory option: allow the result to have a different length than the source.
-     * Shaping mode: Tashkeel characters will be removed, buffer length will shrink.
-     * De-shaping mode: N/A
-     *
-     * Affects: Tashkeel options
-     */
-    public static final int TASHKEEL_RESIZE = 0x80000;
-
-    /**
-     * Memory option: the result must have the same length as the source.
-     * Shaping mode: Tashkeel characters will be replaced by Tatweel if it is connected to adjacent
-     *               characters (i.e. shaped on Tatweel) or replaced by space if it is not connected.
-     *
-     * De-shaping mode: N/A
-     * Affects: YehHamza options
-     */
-    public static final int TASHKEEL_REPLACE_BY_TATWEEL = 0xC0000;
-
-    /** Bit mask for Tashkeel replacement with Space or Tatweel memory options. */
-    public static final int TASHKEEL_MASK  = 0xE0000;
-
-    /* Space location Control options */
-    /**
-     * This option effects the meaning of BEGIN and END options. if this option is not used the default
-     * for BEGIN and END will be as following:
-     * The Default (for both Visual LTR, Visual RTL and Logical Text)
-     *           1. BEGIN always refers to the start address of physical memory.
-     *           2. END always refers to the end address of physical memory.
-     *
-     * If this option is used it will swap the meaning of BEGIN and END only for Visual LTR text.
-     *
-     * The affect on BEGIN and END Memory Options will be as following:
-     *    A. BEGIN For Visual LTR text: This will be the beginning (right side) of the visual text
-     *       (corresponding to the physical memory address end, same as END in default behavior)
-     *    B. BEGIN For Logical text: Same as BEGIN in default behavior.
-     *    C. END For Visual LTR text: This will be the end (left side) of the visual text. (corresponding to
-     *      the physical memory address beginning, same as BEGIN in default behavior)
-     *    D. END For Logical text: Same as END in default behavior.
-     * Affects: All LamAlef BEGIN, END and AUTO options.
-     */
-    public static final int SPACES_RELATIVE_TO_TEXT_BEGIN_END = 0x4000000;
-
-    /** Bit mask for swapping BEGIN and END for Visual LTR text */
-    public static final int SPACES_RELATIVE_TO_TEXT_MASK = 0x4000000;
-
-    /**
-     * If this option is used, shaping will use the new Unicode code point for TAIL (i.e. 0xFE73).
-     * If this option is not specified (Default), old unofficial Unicode TAIL code point is used (i.e. 0x200B)
-     * De-shaping will not use this option as it will always search for both the new Unicode code point for the
-     * TAIL (i.e. 0xFE73) or the old unofficial Unicode TAIL code point (i.e. 0x200B) and de-shape the
-     * Seen-Family letter accordingly.
-     *
-     * Shaping Mode: Only shaping.
-     * De-shaping Mode: N/A.
-     * Affects: All Seen options
-     */
-    public static final int SHAPE_TAIL_NEW_UNICODE = 0x8000000;
-
-    /** Bit mask for new Unicode Tail option */
-    public static final int SHAPE_TAIL_TYPE_MASK = 0x8000000;
-
-    /**
-     * Memory option: allow the result to have a different length than the source.
-     * @stable ICU 2.0
-     */
-    public static final int LENGTH_GROW_SHRINK = 0;
-
-    /**
-     * Memory option: allow the result to have a different length than the source.
-     * Affects: LamAlef options
-     * This option is an alias to LENGTH_GROW_SHRINK
-     */
-    public static final int LAMALEF_RESIZE   = 0;
-
-    /**
-     * Memory option: the result must have the same length as the source.
-     * If more room is necessary, then try to consume spaces next to modified characters.
-     * @stable ICU 2.0
-     */
-    public static final int LENGTH_FIXED_SPACES_NEAR = 1;
-
-    /**
-     * Memory option: the result must have the same length as the source.
-     * If more room is necessary, then try to consume spaces next to modified characters.
-     * Affects: LamAlef options
-     * This option is an alias to LENGTH_FIXED_SPACES_NEAR
-     */
-    public static final int LAMALEF_NEAR = 1 ;
-
-    /**
-     * Memory option: the result must have the same length as the source.
-     * If more room is necessary, then try to consume spaces at the end of the text.
-     * @stable ICU 2.0
-     */
-    public static final int LENGTH_FIXED_SPACES_AT_END = 2;
-
-
-    /**
-     * Memory option: the result must have the same length as the source.
-     * If more room is necessary, then try to consume spaces at the end of the text.
-     * Affects: LamAlef options
-     * This option is an alias to LENGTH_FIXED_SPACES_AT_END
-     */
-    public static final int LAMALEF_END = 2;
-
-    /**
-     * Memory option: the result must have the same length as the source.
-     * If more room is necessary, then try to consume spaces at the beginning of the text.
-     * @stable ICU 2.0
-     */
-    public static final int LENGTH_FIXED_SPACES_AT_BEGINNING = 3;
-
-    /**
-     * Memory option: the result must have the same length as the source.
-     * If more room is necessary, then try to consume spaces at the beginning of the text.
-     * Affects: LamAlef options
-     * This option is an alias to LENGTH_FIXED_SPACES_AT_BEGINNING
-     */
-    public static final int LAMALEF_BEGIN = 3;
-
-    /**
-     * Memory option: the result must have the same length as the source.
-     * Shaping Mode: For each LAMALEF character found, expand LAMALEF using space at end.
-     *               If there is no space at end, use spaces at beginning of the buffer. If there
-     *               is no space at beginning of the buffer, use spaces at the near (i.e. the space
-     *               after the LAMALEF character).
-     *
-     * Deshaping Mode: Perform the same function as the flag equals LAMALEF_END.
-     * Affects: LamAlef options
-     */
-    public static final int LAMALEF_AUTO  = 0x10000;
-
-    /**
-     * Bit mask for memory options.
-     * @stable ICU 2.0
-     */
-    public static final int LENGTH_MASK = 0x10003;
-
-    /** Bit mask for LamAlef memory options. */
-
-    public static final int LAMALEF_MASK  = 0x10003;
-
-    /**
-     * Direction indicator: the source is in logical (keyboard) order.
-     * @stable ICU 2.0
-     */
-    public static final int TEXT_DIRECTION_LOGICAL = 0;
-
-    /**
-     * Direction indicator:the source is in visual RTL order,
-     * the rightmost displayed character stored first.
-     * This option is an alias to U_SHAPE_TEXT_DIRECTION_LOGICAL
-     */
-    public static final int TEXT_DIRECTION_VISUAL_RTL = 0;
-
-    /**
-     * Direction indicator: the source is in visual (display) order, that is,
-     * the leftmost displayed character is stored first.
-     * @stable ICU 2.0
-     */
-    public static final int TEXT_DIRECTION_VISUAL_LTR = 4;
-
-    /**
-     * Bit mask for direction indicators.
-     * @stable ICU 2.0
-     */
-    public static final int TEXT_DIRECTION_MASK = 4;
-
-
-    /**
-     * Letter shaping option: do not perform letter shaping.
-     * @stable ICU 2.0
-     */
-    public static final int LETTERS_NOOP = 0;
-
-    /**
-     * Letter shaping option: replace normative letter characters in the U+0600 (Arabic) block,
-     * by shaped ones in the U+FE70 (Presentation Forms B) block. Performs Lam-Alef ligature
-     * substitution.
-     * @stable ICU 2.0
-     */
-    public static final int LETTERS_SHAPE = 8;
-
-    /**
-     * Letter shaping option: replace shaped letter characters in the U+FE70 (Presentation Forms B) block
-     * by normative ones in the U+0600 (Arabic) block.  Converts Lam-Alef ligatures to pairs of Lam and
-     * Alef characters, consuming spaces if required.
-     * @stable ICU 2.0
-     */
-    public static final int LETTERS_UNSHAPE = 0x10;
-
-    /**
-     * Letter shaping option: replace normative letter characters in the U+0600 (Arabic) block,
-     * except for the TASHKEEL characters at U+064B...U+0652, by shaped ones in the U+Fe70
-     * (Presentation Forms B) block.  The TASHKEEL characters will always be converted to
-     * the isolated forms rather than to their correct shape.
-     * @stable ICU 2.0
-     */
-    public static final int LETTERS_SHAPE_TASHKEEL_ISOLATED = 0x18;
-
-    /**
-     * Bit mask for letter shaping options.
-     * @stable ICU 2.0
-     */
-    public static final int LETTERS_MASK = 0x18;
-
-
-    /**
-     * Digit shaping option: do not perform digit shaping.
-     * @stable ICU 2.0
-     */
-    public static final int DIGITS_NOOP = 0;
-
-    /**
-     * Digit shaping option: Replace European digits (U+0030...U+0039) by Arabic-Indic digits.
-     * @stable ICU 2.0
-     */
-    public static final int DIGITS_EN2AN = 0x20;
-
-    /**
-     * Digit shaping option: Replace Arabic-Indic digits by European digits (U+0030...U+0039).
-     * @stable ICU 2.0
-     */
-    public static final int DIGITS_AN2EN = 0x40;
-
-    /**
-     * Digit shaping option:
-     * Replace European digits (U+0030...U+0039) by Arabic-Indic digits
-     * if the most recent strongly directional character
-     * is an Arabic letter (its Bidi direction value is RIGHT_TO_LEFT_ARABIC).
-     * The initial state at the start of the text is assumed to be not an Arabic,
-     * letter, so European digits at the start of the text will not change.
-     * Compare to DIGITS_ALEN2AN_INIT_AL.
-     * @stable ICU 2.0
-     */
-    public static final int DIGITS_EN2AN_INIT_LR = 0x60;
-
-    /**
-     * Digit shaping option:
-     * Replace European digits (U+0030...U+0039) by Arabic-Indic digits
-     * if the most recent strongly directional character
-     * is an Arabic letter (its Bidi direction value is RIGHT_TO_LEFT_ARABIC).
-     * The initial state at the start of the text is assumed to be an Arabic,
-     * letter, so European digits at the start of the text will change.
-     * Compare to DIGITS_ALEN2AN_INT_LR.
-     * @stable ICU 2.0
-     */
-    public static final int DIGITS_EN2AN_INIT_AL = 0x80;
-
-    /** Not a valid option value. */
-    //private static final int DIGITS_RESERVED = 0xa0;
-
-    /**
-     * Bit mask for digit shaping options.
-     * @stable ICU 2.0
-     */
-    public static final int DIGITS_MASK = 0xe0;
-
-    /**
-     * Digit type option: Use Arabic-Indic digits (U+0660...U+0669).
-     * @stable ICU 2.0
-     */
-    public static final int DIGIT_TYPE_AN = 0;
-
-    /**
-     * Digit type option: Use Eastern (Extended) Arabic-Indic digits (U+06f0...U+06f9).
-     * @stable ICU 2.0
-     */
-    public static final int DIGIT_TYPE_AN_EXTENDED = 0x100;
-
-    /**
-     * Bit mask for digit type options.
-     * @stable ICU 2.0
-     */
-    public static final int DIGIT_TYPE_MASK = 0x0100; // 0x3f00?
-
-    /**
-     * some constants
-     */
-    private static final char HAMZAFE_CHAR       = '\ufe80';
-    private static final char HAMZA06_CHAR       = '\u0621';
-    private static final char YEH_HAMZA_CHAR     = '\u0626';
-    private static final char YEH_HAMZAFE_CHAR   = '\uFE89';
-    private static final char LAMALEF_SPACE_SUB  = '\uffff';
-    private static final char TASHKEEL_SPACE_SUB = '\ufffe';
-    private static final char LAM_CHAR      = '\u0644';
-    private static final char SPACE_CHAR    = '\u0020';
-    private static final char SPACE_CHAR_FOR_LAMALEF = '\ufeff'; // XXX: tweak for TextLine use
-    private static final char SHADDA_CHAR   = '\uFE7C';
-    private static final char TATWEEL_CHAR  = '\u0640';
-    private static final char SHADDA_TATWEEL_CHAR = '\uFE7D';
-    private static final char NEW_TAIL_CHAR = '\uFE73';
-    private static final char OLD_TAIL_CHAR = '\u200B';
-    private static final int SHAPE_MODE      = 0;
-    private static final int DESHAPE_MODE    = 1;
-
-    /**
-     * @stable ICU 2.0
-     */
-    public boolean equals(Object rhs) {
-        return rhs != null &&
-            rhs.getClass() == ArabicShaping.class &&
-            options == ((ArabicShaping)rhs).options;
-    }
-
-    /**
-     * @stable ICU 2.0
-     */
-     ///CLOVER:OFF
-    public int hashCode() {
-        return options;
-    }
-
-    /**
-     * @stable ICU 2.0
-     */
-    public String toString() {
-        StringBuffer buf = new StringBuffer(super.toString());
-        buf.append('[');
-
-        switch (options & LAMALEF_MASK) {
-        case LAMALEF_RESIZE: buf.append("LamAlef resize"); break;
-        case LAMALEF_NEAR: buf.append("LamAlef spaces at near"); break;
-        case LAMALEF_BEGIN: buf.append("LamAlef spaces at begin"); break;
-        case LAMALEF_END: buf.append("LamAlef spaces at end"); break;
-        case LAMALEF_AUTO: buf.append("lamAlef auto"); break;
-        }
-        switch (options & TEXT_DIRECTION_MASK) {
-        case TEXT_DIRECTION_LOGICAL: buf.append(", logical"); break;
-        case TEXT_DIRECTION_VISUAL_LTR: buf.append(", visual"); break;
-        }
-        switch (options & LETTERS_MASK) {
-        case LETTERS_NOOP: buf.append(", no letter shaping"); break;
-        case LETTERS_SHAPE: buf.append(", shape letters"); break;
-        case LETTERS_SHAPE_TASHKEEL_ISOLATED: buf.append(", shape letters tashkeel isolated"); break;
-        case LETTERS_UNSHAPE: buf.append(", unshape letters"); break;
-        }
-        switch (options & SEEN_MASK) {
-        case SEEN_TWOCELL_NEAR: buf.append(", Seen at near"); break;
-        }
-        switch (options & YEHHAMZA_MASK) {
-        case YEHHAMZA_TWOCELL_NEAR: buf.append(", Yeh Hamza at near"); break;
-        }
-        switch (options & TASHKEEL_MASK) {
-        case TASHKEEL_BEGIN: buf.append(", Tashkeel at begin"); break;
-        case TASHKEEL_END: buf.append(", Tashkeel at end"); break;
-        case TASHKEEL_REPLACE_BY_TATWEEL: buf.append(", Tashkeel replace with tatweel"); break;
-        case TASHKEEL_RESIZE: buf.append(", Tashkeel resize"); break;
-        }
-
-        switch (options & DIGITS_MASK) {
-        case DIGITS_NOOP: buf.append(", no digit shaping"); break;
-        case DIGITS_EN2AN: buf.append(", shape digits to AN"); break;
-        case DIGITS_AN2EN: buf.append(", shape digits to EN"); break;
-        case DIGITS_EN2AN_INIT_LR: buf.append(", shape digits to AN contextually: default EN"); break;
-        case DIGITS_EN2AN_INIT_AL: buf.append(", shape digits to AN contextually: default AL"); break;
-        }
-        switch (options & DIGIT_TYPE_MASK) {
-        case DIGIT_TYPE_AN: buf.append(", standard Arabic-Indic digits"); break;
-        case DIGIT_TYPE_AN_EXTENDED: buf.append(", extended Arabic-Indic digits"); break;
-        }
-        buf.append("]");
-
-        return buf.toString();
-    }
-    ///CLOVER:ON
-
-    //
-    // ported api
-    //
-
-    private static final int IRRELEVANT = 4;
-    private static final int LAMTYPE = 16;
-    private static final int ALEFTYPE = 32;
-
-    private static final int LINKR = 1;
-    private static final int LINKL = 2;
-    private static final int LINK_MASK = 3;
-
-    private static final int irrelevantPos[] = {
-        0x0, 0x2, 0x4, 0x6, 0x8, 0xA, 0xC, 0xE
-    };
-
-/*
-    private static final char convertLamAlef[] =  {
-        '\u0622', // FEF5
-        '\u0622', // FEF6
-        '\u0623', // FEF7
-        '\u0623', // FEF8
-        '\u0625', // FEF9
-        '\u0625', // FEFA
-        '\u0627', // FEFB
-        '\u0627'  // FEFC
-    };
-*/
-
-    private static final int tailFamilyIsolatedFinal[] = {
-        /* FEB1 */ 1,
-        /* FEB2 */ 1,
-        /* FEB3 */ 0,
-        /* FEB4 */ 0,
-        /* FEB5 */ 1,
-        /* FEB6 */ 1,
-        /* FEB7 */ 0,
-        /* FEB8 */ 0,
-        /* FEB9 */ 1,
-        /* FEBA */ 1,
-        /* FEBB */ 0,
-        /* FEBC */ 0,
-        /* FEBD */ 1,
-        /* FEBE */ 1
-    };
-
-    private static final int tashkeelMedial[] = {
-        /* FE70 */ 0,
-        /* FE71 */ 1,
-        /* FE72 */ 0,
-        /* FE73 */ 0,
-        /* FE74 */ 0,
-        /* FE75 */ 0,
-        /* FE76 */ 0,
-        /* FE77 */ 1,
-        /* FE78 */ 0,
-        /* FE79 */ 1,
-        /* FE7A */ 0,
-        /* FE7B */ 1,
-        /* FE7C */ 0,
-        /* FE7D */ 1,
-        /* FE7E */ 0,
-        /* FE7F */ 1
-    };
-
-    private static final char yehHamzaToYeh[] =
-    {
-    /* isolated*/ 0xFEEF,
-    /* final   */ 0xFEF0
-    };
-
-    private static final char convertNormalizedLamAlef[] = {
-        '\u0622', // 065C
-        '\u0623', // 065D
-        '\u0625', // 065E
-        '\u0627', // 065F
-    };
-
-    private static final int[] araLink = {
-        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, 1+2, 1+2, 1+2, 1+2, 1+2,   /*0x0678-0x067D*/
-        1+2, 1+2, 1+2, 1+2, 1+2, 1+2,   /*0x067E-0x0683*/
-        1+2, 1+2, 1+2, 1+2,             /*0x0684-0x0687*/
-        1, 1, 1, 1, 1, 1, 1, 1, 1, 1,   /*0x0688-0x0691*/
-        1, 1, 1, 1, 1, 1, 1, 1,         /*0x0692-0x0699*/
-        1+2, 1+2, 1+2, 1+2, 1+2, 1+2,   /*0x069A-0x06A3*/
-        1+2, 1+2, 1+2, 1+2,             /*0x069A-0x06A3*/
-        1+2, 1+2, 1+2, 1+2, 1+2, 1+2,   /*0x06A4-0x06AD*/
-        1+2, 1+2, 1+2, 1+2,             /*0x06A4-0x06AD*/
-        1+2, 1+2, 1+2, 1+2, 1+2, 1+2,   /*0x06AE-0x06B7*/
-        1+2, 1+2, 1+2, 1+2,             /*0x06AE-0x06B7*/
-        1+2, 1+2, 1+2, 1+2, 1+2, 1+2,   /*0x06B8-0x06BF*/
-        1+2, 1+2,                       /*0x06B8-0x06BF*/
-        1,                              /*0x06C0*/
-        1+2,                            /*0x06C1*/
-        1, 1, 1, 1, 1, 1, 1, 1, 1, 1,   /*0x06C2-0x06CB*/
-        1+2,                            /*0x06CC*/
-        1,                              /*0x06CD*/
-        1+2, 1+2, 1+2, 1+2,             /*0x06CE-0x06D1*/
-        1, 1                            /*0x06D2-0x06D3*/
-    };
-
-    private static final int[] presLink = {
-        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
-    };
-
-    private static int[] 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
-    };
-
-    private static final int shapeTable[][][] = {
-        { {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} }
-    };
-
-    /*
-     * This function shapes European digits to Arabic-Indic digits
-     * in-place, writing over the input characters.  Data is in visual
-     * order.
-     */
-    private void shapeToArabicDigitsWithContext(char[] dest,
-                                                int start,
-                                                int length,
-                                                char digitBase,
-                                                boolean lastStrongWasAL) {
-        digitBase -= '0'; // move common adjustment out of loop
-
-        for(int i = start + length; --i >= start;) {
-            char ch = dest[i];
-            switch (Character.getDirectionality(ch)) {
-            case Character.DIRECTIONALITY_LEFT_TO_RIGHT:
-            case Character.DIRECTIONALITY_RIGHT_TO_LEFT:
-                lastStrongWasAL = false;
-                break;
-            case Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC:
-                lastStrongWasAL = true;
-                break;
-            case Character.DIRECTIONALITY_EUROPEAN_NUMBER:
-                if (lastStrongWasAL && ch <= '\u0039') {
-                    dest[i] = (char)(ch + digitBase);
-                }
-                break;
-            default:
-                break;
-            }
-        }
-    }
-
-    /*
-     * Name    : invertBuffer
-     * Function: This function inverts the buffer, it's used
-     *           in case the user specifies the buffer to be
-     *           TEXT_DIRECTION_LOGICAL
-     */
-    private static void invertBuffer(char[] buffer,
-                                     int start,
-                                     int length) {
-
-        for(int i = start, j = start + length - 1; i < j; i++, --j) {
-            char temp = buffer[i];
-            buffer[i] = buffer[j];
-            buffer[j] = temp;
-        }
-    }
-
-    /*
-     * 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.
-     */
-    private static char changeLamAlef(char ch) {
-        switch(ch) {
-        case '\u0622': return '\u065C';
-        case '\u0623': return '\u065D';
-        case '\u0625': return '\u065E';
-        case '\u0627': return '\u065F';
-        default:  return '\u0000'; // not a lamalef
-        }
-    }
-
-    /*
-     * Name    : specialChar
-     * Function: Special Arabic characters need special handling in the shapeUnicode
-     *           function, this function returns 1 or 2 for these special characters
-     */
-    private static int specialChar(char ch) {
-        if ((ch > '\u0621' && ch < '\u0626') ||
-            (ch == '\u0627') ||
-            (ch > '\u062E' && ch < '\u0633') ||
-            (ch > '\u0647' && ch < '\u064A') ||
-            (ch == '\u0629')) {
-            return 1;
-        } else if (ch >= '\u064B' && ch<= '\u0652') {
-            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
-     */
-    private static int getLink(char ch) {
-        if (ch >= '\u0622' && ch <= '\u06D3') {
-            return araLink[ch - '\u0622'];
-        } else if (ch == '\u200D') {
-            return 3;
-        } else if (ch >= '\u206D' && ch <= '\u206F') {
-            return 4;
-        } else if (ch >= '\uFE70' && ch <= '\uFEFC') {
-            return presLink[ch - '\uFE70'];
-        } else {
-            return 0;
-        }
-    }
-
-    /*
-     * Name    : countSpaces
-     * Function: Counts the number of spaces
-     *           at each end of the logical buffer
-     */
-    private static int countSpacesLeft(char[] dest,
-                                       int start,
-                                       int count) {
-        for (int i = start, e = start + count; i < e; ++i) {
-            if (dest[i] != SPACE_CHAR) {
-                return i - start;
-            }
-        }
-        return count;
-    }
-
-    private static int countSpacesRight(char[] dest,
-                                        int start,
-                                        int count) {
-
-        for (int i = start + count; --i >= start;) {
-            if (dest[i] != SPACE_CHAR) {
-                return start + count - 1 - i;
-            }
-        }
-        return count;
-    }
-
-    /*
-     * Name    : isTashkeelChar
-     * Function: Returns true for Tashkeel characters else return false
-     */
-    private static boolean isTashkeelChar(char ch) {
-        return ( ch >='\u064B' && ch <= '\u0652' );
-    }
-
-    /*
-     *Name     : isSeenTailFamilyChar
-     *Function : returns 1 if the character is a seen family isolated character
-     *           in the FE range otherwise returns 0
-     */
-
-    private static int isSeenTailFamilyChar(char ch) {
-        if (ch >= 0xfeb1 && ch < 0xfebf){
-             return tailFamilyIsolatedFinal [ch - 0xFEB1];
-        } else {
-             return 0;
-        }
-    }
-
-     /* Name     : isSeenFamilyChar
-      * Function : returns 1 if the character is a seen family character in the Unicode
-      *            06 range otherwise returns 0
-     */
-
-    private static int isSeenFamilyChar(char  ch){
-        if (ch >= 0x633 && ch <= 0x636){
-            return 1;
-        }else {
-            return 0;
-        }
-    }
-
-    /*
-     *Name     : isTailChar
-     *Function : returns true if the character matches one of the tail characters
-     *           (0xfe73 or 0x200b) otherwise returns false
-     */
-
-    private static boolean isTailChar(char ch) {
-        if(ch == OLD_TAIL_CHAR || ch == NEW_TAIL_CHAR){
-                return true;
-        }else{
-                return false;
-        }
-    }
-
-    /*
-     *Name     : isAlefMaksouraChar
-     *Function : returns true if the character is a Alef Maksoura Final or isolated
-     *           otherwise returns false
-     */
-    private static boolean isAlefMaksouraChar(char ch) {
-        return ( (ch == 0xFEEF) || ( ch == 0xFEF0) || (ch == 0x0649));
-    }
-
-    /*
-     * Name     : isYehHamzaChar
-     * Function : returns true if the character is a yehHamza isolated or yehhamza
-     *            final is found otherwise returns false
-     */
-    private static boolean isYehHamzaChar(char ch) {
-        if((ch==0xFE89)||(ch==0xFE8A)){
-            return true;
-        }else{
-            return false;
-        }
-    }
-
-    /*
-     *Name     : isTashkeelCharFE
-     *Function : Returns true for Tashkeel characters in FE range else return false
-     */
-
-    private static boolean isTashkeelCharFE(char ch) {
-        return ( ch!=0xFE75 &&(ch>=0xFE70 && ch<= 0xFE7F) );
-    }
-
-    /*
-     * Name: isTashkeelOnTatweelChar
-     * Function: Checks if the Tashkeel Character is on Tatweel or not,if the
-     *           Tashkeel on tatweel (FE range), it returns 1 else if the
-     *           Tashkeel with shadda on tatweel (FC range)return 2 otherwise
-     *           returns 0
-     */
-    private static int isTashkeelOnTatweelChar(char ch){
-        if (ch >= 0xfe70 && ch <= 0xfe7f && ch != NEW_TAIL_CHAR && ch != 0xFE75 && ch != SHADDA_TATWEEL_CHAR)
-        {
-            return tashkeelMedial [ch - 0xFE70];
-        } else if( (ch >= 0xfcf2 && ch <= 0xfcf4) || (ch == SHADDA_TATWEEL_CHAR)) {
-            return 2;
-        } else {
-            return 0;
-        }
-    }
-
-    /*
-     * Name: isIsolatedTashkeelChar
-     * Function: Checks if the Tashkeel Character is in the isolated form
-     *           (i.e. Unicode FE range) returns 1 else if the Tashkeel
-     *           with shadda is in the isolated form (i.e. Unicode FC range)
-     *           returns 1 otherwise returns 0
-     */
-    private static int isIsolatedTashkeelChar(char ch){
-        if (ch >= 0xfe70 && ch <= 0xfe7f && ch != NEW_TAIL_CHAR && ch != 0xFE75){
-            return (1 - tashkeelMedial [ch - 0xFE70]);
-        } else if(ch >= 0xfc5e && ch <= 0xfc63){
-            return 1;
-        } else{
-            return 0;
-        }
-    }
-
-    /*
-     * Name    : isAlefChar
-     * Function: Returns 1 for Alef characters else return 0
-     */
-    private static boolean isAlefChar(char ch) {
-        return ch == '\u0622' || ch == '\u0623' || ch == '\u0625' || ch == '\u0627';
-    }
-
-    /*
-     * Name    : isLamAlefChar
-     * Function: Returns true for LamAlef characters else return false
-     */
-    private static boolean isLamAlefChar(char ch) {
-        return ch >= '\uFEF5' && ch <= '\uFEFC';
-    }
-
-    private static boolean isNormalizedLamAlefChar(char ch) {
-        return ch >= '\u065C' && ch <= '\u065F';
-    }
-
-    /*
-     * Name    : calculateSize
-     * Function: This function calculates the destSize to be used in preflighting
-     *           when the destSize is equal to 0
-     */
-    private int calculateSize(char[] source,
-                              int sourceStart,
-                              int sourceLength) {
-
-        int destSize = sourceLength;
-
-        switch (options & LETTERS_MASK) {
-        case LETTERS_SHAPE:
-        case LETTERS_SHAPE_TASHKEEL_ISOLATED:
-            if (isLogical) {
-                for (int i = sourceStart, e = sourceStart + sourceLength - 1; i < e; ++i) {
-                    if ((source[i] == LAM_CHAR && isAlefChar(source[i+1])) || isTashkeelCharFE(source[i])){
-                        --destSize;
-                    }
-                }
-            } else { // visual
-                for(int i = sourceStart + 1, e = sourceStart + sourceLength; i < e; ++i) {
-                    if ((source[i] == LAM_CHAR && isAlefChar(source[i-1])) || isTashkeelCharFE(source[i])) {
-                        --destSize;
-                    }
-                }
-            }
-            break;
-
-        case LETTERS_UNSHAPE:
-            for(int i = sourceStart, e = sourceStart + sourceLength; i < e; ++i) {
-                if (isLamAlefChar(source[i])) {
-                    destSize++;
-                }
-            }
-            break;
-
-        default:
-            break;
-        }
-
-        return destSize;
-    }
-
-
-    /*
-     * Name    : countSpaceSub
-     * Function: Counts number of times the subChar appears in the array
-     */
-    public static int countSpaceSub(char [] dest,int length, char subChar){
-        int i = 0;
-        int count = 0;
-        while (i < length) {
-          if (dest[i] == subChar) {
-              count++;
-              }
-          i++;
-        }
-        return count;
-    }
-
-    /*
-     * Name    : shiftArray
-     * Function: Shifts characters to replace space sub characters
-     */
-    public static void shiftArray(char [] dest,int start, int e, char subChar){
-        int w = e;
-        int r = e;
-        while (--r >= start) {
-          char ch = dest[r];
-          if (ch != subChar) {
-            --w;
-            if (w != r) {
-              dest[w] = ch;
-            }
-          }
-        }
-   }
-
-    /*
-     * Name    : flipArray
-     * Function: inverts array, so that start becomes end and vice versa
-     */
-      public static int flipArray(char [] dest, int start, int e, int w){
-        int r;
-        if (w > start) {
-        // shift, assume small buffer size so don't use arraycopy
-          r = w;
-          w = start;
-          while (r < e) {
-            dest[w++] = dest[r++];
-           }
-         } else {
-             w = e;
-         }
-        return w;
-      }
-
-    /*
-     * Name     : handleTashkeelWithTatweel
-     * Function : Replaces Tashkeel as following:
-     *            Case 1 :if the Tashkeel on tatweel, replace it with Tatweel.
-     *            Case 2 :if the Tashkeel aggregated with Shadda on Tatweel, replace
-     *                   it with Shadda on Tatweel.
-     *            Case 3: if the Tashkeel is isolated replace it with Space.
-     *
-     */
-    private static int handleTashkeelWithTatweel(char[] dest, int sourceLength) {
-                     int i;
-                     for(i = 0; i < sourceLength; i++){
-                         if((isTashkeelOnTatweelChar(dest[i]) == 1)){
-                             dest[i] = TATWEEL_CHAR;
-                        }else if((isTashkeelOnTatweelChar(dest[i]) == 2)){
-                             dest[i] = SHADDA_TATWEEL_CHAR;
-                        }else if((isIsolatedTashkeelChar(dest[i])==1) && dest[i] != SHADDA_CHAR){
-                             dest[i] = SPACE_CHAR;
-                        }
-                     }
-                     return sourceLength;
-    }
-
-    /*
-     *Name     : handleGeneratedSpaces
-     *Function : The shapeUnicode function converts Lam + Alef into LamAlef + space,
-     *           and Tashkeel to space.
-     *           handleGeneratedSpaces function puts these generated spaces
-     *           according to the options the user specifies. LamAlef and Tashkeel
-     *           spaces can be replaced at begin, at end, at near or decrease the
-     *           buffer size.
-     *
-     *           There is also Auto option for LamAlef and tashkeel, which will put
-     *           the spaces at end of the buffer (or end of text if the user used
-     *           the option SPACES_RELATIVE_TO_TEXT_BEGIN_END).
-     *
-     *           If the text type was visual_LTR and the option
-     *           SPACES_RELATIVE_TO_TEXT_BEGIN_END was selected the END
-     *           option will place the space at the beginning of the buffer and
-     *           BEGIN will place the space at the end of the buffer.
-     */
-  private int handleGeneratedSpaces(char[] dest,
-            int start,
-            int length) {
-
-      int lenOptionsLamAlef = options & LAMALEF_MASK;
-      int lenOptionsTashkeel = options & TASHKEEL_MASK;
-      boolean lamAlefOn = false;
-      boolean tashkeelOn = false;
-
-      if (!isLogical & !spacesRelativeToTextBeginEnd) {
-          switch (lenOptionsLamAlef) {
-          case LAMALEF_BEGIN: lenOptionsLamAlef = LAMALEF_END; break;
-          case LAMALEF_END: lenOptionsLamAlef = LAMALEF_BEGIN; break;
-          default: break;
-         }
-          switch (lenOptionsTashkeel){
-          case TASHKEEL_BEGIN: lenOptionsTashkeel = TASHKEEL_END; break;
-          case TASHKEEL_END: lenOptionsTashkeel = TASHKEEL_BEGIN; break;
-          default: break;
-          }
-        }
-
-
-      if (lenOptionsLamAlef == LAMALEF_NEAR) {
-          for (int i = start, e = i + length; i < e; ++i) {
-              if (dest[i] == LAMALEF_SPACE_SUB) {
-                  dest[i] = SPACE_CHAR_FOR_LAMALEF;
-              }
-          }
-
-      } else {
-
-          final int e = start + length;
-          int wL = countSpaceSub(dest, length, LAMALEF_SPACE_SUB);
-          int wT = countSpaceSub(dest, length, TASHKEEL_SPACE_SUB);
-
-          if (lenOptionsLamAlef == LAMALEF_END){
-            lamAlefOn = true;
-          }
-          if (lenOptionsTashkeel == TASHKEEL_END){
-            tashkeelOn = true;
-          }
-
-
-          if (lamAlefOn && (lenOptionsLamAlef == LAMALEF_END)) {
-            shiftArray(dest, start, e, LAMALEF_SPACE_SUB);
-            while (wL > start) {
-                dest[--wL] = SPACE_CHAR;
-            }
-          }
-
-          if (tashkeelOn && (lenOptionsTashkeel == TASHKEEL_END)){
-            shiftArray(dest, start, e, TASHKEEL_SPACE_SUB);
-            while (wT > start) {
-                 dest[--wT] = SPACE_CHAR;
-            }
-          }
-
-          lamAlefOn = false;
-          tashkeelOn = false;
-
-          if (lenOptionsLamAlef == LAMALEF_RESIZE){
-            lamAlefOn = true;
-          }
-          if (lenOptionsTashkeel == TASHKEEL_RESIZE){
-            tashkeelOn = true;
-          }
-
-          if (lamAlefOn && (lenOptionsLamAlef == LAMALEF_RESIZE)){
-              shiftArray(dest, start, e, LAMALEF_SPACE_SUB);
-              wL = flipArray(dest,start,e, wL);
-              length = wL - start;
-          }
-          if (tashkeelOn && (lenOptionsTashkeel == TASHKEEL_RESIZE)) {
-              shiftArray(dest, start, e, TASHKEEL_SPACE_SUB);
-              wT = flipArray(dest,start,e, wT);
-              length = wT - start;
-          }
-
-          lamAlefOn = false;
-          tashkeelOn = false;
-
-          if ((lenOptionsLamAlef == LAMALEF_BEGIN) ||
-              (lenOptionsLamAlef == LAMALEF_AUTO)){
-                lamAlefOn = true;
-          }
-          if (lenOptionsTashkeel == TASHKEEL_BEGIN){
-                tashkeelOn = true;
-          }
-
-          if (lamAlefOn && ((lenOptionsLamAlef == LAMALEF_BEGIN)||
-                            (lenOptionsLamAlef == LAMALEF_AUTO))) { // spaces at beginning
-              shiftArray(dest, start, e, LAMALEF_SPACE_SUB);
-               wL = flipArray(dest,start,e, wL);
-                  while (wL < e) {
-                      dest[wL++] = SPACE_CHAR;
-                  }
-              }
-              if(tashkeelOn && (lenOptionsTashkeel == TASHKEEL_BEGIN)){
-               shiftArray(dest, start, e, TASHKEEL_SPACE_SUB);
-               wT = flipArray(dest,start,e, wT);
-                  while (wT < e) {
-                      dest[wT++] = SPACE_CHAR;
-                  }
-              }
-           }
-
-      return length;
-  }
-
-
-  /*
-   *Name     :expandCompositCharAtBegin
-   *Function :Expands the LamAlef character to Lam and Alef consuming the required
-   *         space from beginning of the buffer. If the text type was visual_LTR
-   *         and the option SPACES_RELATIVE_TO_TEXT_BEGIN_END was selected
-   *         the spaces will be located at end of buffer.
-   *         If there are no spaces to expand the LamAlef, an exception is thrown.
-*/
- private boolean expandCompositCharAtBegin(char[] dest,int start, int length,
-                            int lacount) {
-     boolean spaceNotFound = false;
-
-     if (lacount > countSpacesRight(dest, start, length)) {
-         spaceNotFound = true;
-         return spaceNotFound;
-     }
-     for (int r = start + length - lacount, w = start + length; --r >= start;) {
-         char ch = dest[r];
-         if (isNormalizedLamAlefChar(ch)) {
-             dest[--w] = LAM_CHAR;
-             dest[--w] = convertNormalizedLamAlef[ch - '\u065C'];
-         } else {
-             dest[--w] = ch;
-         }
-     }
-     return spaceNotFound;
-
-  }
-
-  /*
-   *Name     : expandCompositCharAtEnd
-   *Function : Expands the LamAlef character to Lam and Alef consuming the
-   *           required space from end of the buffer. If the text type was
-   *           Visual LTR and the option SPACES_RELATIVE_TO_TEXT_BEGIN_END
-   *           was used, the spaces will be consumed from begin of buffer. If
-   *           there are no spaces to expand the LamAlef, an exception is thrown.
-   */
-
-  private boolean  expandCompositCharAtEnd(char[] dest,int start, int length,
-                          int lacount){
-      boolean spaceNotFound = false;
-
-      if (lacount > countSpacesLeft(dest, start, length)) {
-          spaceNotFound = true;
-          return spaceNotFound;
-      }
-      for (int r = start + lacount, w = start, e = start + length; r < e; ++r) {
-          char ch = dest[r];
-          if (isNormalizedLamAlefChar(ch)) {
-              dest[w++] = convertNormalizedLamAlef[ch - '\u065C'];
-              dest[w++] = LAM_CHAR;
-          } else {
-              dest[w++] = ch;
-          }
-      }
-      return spaceNotFound;
-  }
-
-  /*
-   *Name     : expandCompositCharAtNear
-   *Function : Expands the LamAlef character into Lam + Alef, YehHamza character
-   *           into Yeh + Hamza, SeenFamily character into SeenFamily character
-   *           + Tail, while consuming the space next to the character.
-   */
-
-  private boolean expandCompositCharAtNear(char[] dest,int start, int length,
-                                       int yehHamzaOption, int seenTailOption, int lamAlefOption){
-
-      boolean spaceNotFound = false;
-
-
-
-      if (isNormalizedLamAlefChar(dest[start])) {
-          spaceNotFound = true;
-          return spaceNotFound;
-      }
-      for (int i = start + length; --i >=start;) {
-          char ch = dest[i];
-          if (lamAlefOption == 1 && isNormalizedLamAlefChar(ch)) {
-              if (i>start &&dest[i-1] == SPACE_CHAR) {
-                  dest[i] = LAM_CHAR;
-                  dest[--i] = convertNormalizedLamAlef[ch - '\u065C'];
-              } else {
-                  spaceNotFound = true;
-                  return spaceNotFound;
-              }
-          }else if(seenTailOption == 1 && isSeenTailFamilyChar(ch) == 1){
-              if(i>start &&dest[i-1] == SPACE_CHAR){
-                  dest[i-1] = tailChar;
-              } else{
-                  spaceNotFound = true;
-                  return spaceNotFound;
-              }
-          }else if(yehHamzaOption == 1 && isYehHamzaChar(ch)){
-
-               if(i>start &&dest[i-1] == SPACE_CHAR){
-                  dest[i] = yehHamzaToYeh[ch - YEH_HAMZAFE_CHAR];
-                  dest[i-1] = HAMZAFE_CHAR;
-              }else{
-                  spaceNotFound = true;
-                  return spaceNotFound;
-                }
-
-
-          }
-      }
-      return false;
-
-  }
-
-    /*
-     * Name    : expandCompositChar
-     * Function: LamAlef needs special handling as the LamAlef is
-     *           one character while expanding it will give two
-     *           characters Lam + Alef, so we need to expand the LamAlef
-     *           in near or far spaces according to the options the user
-     *           specifies or increase the buffer size.
-     *           Dest has enough room for the expansion if we are growing.
-     *           lamalef are normalized to the 'special characters'
-     */
-    private int expandCompositChar(char[] dest,
-                              int start,
-                              int length,
-                              int lacount,
-                              int shapingMode) throws ArabicShapingException {
-
-        int lenOptionsLamAlef = options & LAMALEF_MASK;
-        int lenOptionsSeen = options & SEEN_MASK;
-        int lenOptionsYehHamza = options & YEHHAMZA_MASK;
-        boolean spaceNotFound = false;
-
-        if (!isLogical && !spacesRelativeToTextBeginEnd) {
-            switch (lenOptionsLamAlef) {
-            case LAMALEF_BEGIN: lenOptionsLamAlef = LAMALEF_END; break;
-            case LAMALEF_END: lenOptionsLamAlef = LAMALEF_BEGIN; break;
-            default: break;
-            }
-        }
-
-        if(shapingMode == 1){
-            if(lenOptionsLamAlef == LAMALEF_AUTO){
-                if(isLogical){
-                    spaceNotFound = expandCompositCharAtEnd(dest, start, length, lacount);
-                    if(spaceNotFound){
-                        spaceNotFound = expandCompositCharAtBegin(dest, start, length, lacount);
-                    }
-                    if(spaceNotFound){
-                        spaceNotFound = expandCompositCharAtNear(dest, start, length,0,0,1);
-                    }
-                    if(spaceNotFound){
-                        throw new ArabicShapingException("No spacefor lamalef");
-                    }
-                }else{
-                    spaceNotFound = expandCompositCharAtBegin(dest, start, length, lacount);
-                    if(spaceNotFound){
-                        spaceNotFound = expandCompositCharAtEnd(dest, start, length, lacount);
-                    }
-                    if(spaceNotFound){
-                        spaceNotFound = expandCompositCharAtNear(dest, start, length,0,0,1);
-                    }
-                    if(spaceNotFound){
-                        throw new ArabicShapingException("No spacefor lamalef");
-                    }
-                }
-            }else if(lenOptionsLamAlef == LAMALEF_END){
-                spaceNotFound = expandCompositCharAtEnd(dest, start, length, lacount);
-                if(spaceNotFound){
-                    throw new ArabicShapingException("No spacefor lamalef");
-                }
-            }else if(lenOptionsLamAlef == LAMALEF_BEGIN){
-                spaceNotFound = expandCompositCharAtBegin(dest, start, length, lacount);
-                if(spaceNotFound){
-                    throw new ArabicShapingException("No spacefor lamalef");
-                }
-            }else if(lenOptionsLamAlef == LAMALEF_NEAR){
-                spaceNotFound = expandCompositCharAtNear(dest, start, length,0,0,1);
-                if(spaceNotFound){
-                    throw new ArabicShapingException("No spacefor lamalef");
-            }
-            }else if(lenOptionsLamAlef == LAMALEF_RESIZE){
-                for (int r = start + length, w = r + lacount; --r >= start;) {
-                    char ch = dest[r];
-                    if (isNormalizedLamAlefChar(ch)) {
-                        dest[--w] = '\u0644';
-                        dest[--w] = convertNormalizedLamAlef[ch - '\u065C'];
-                    } else {
-                        dest[--w] = ch;
-                    }
-                }
-                length += lacount;
-            }
-            }else{
-                if(lenOptionsSeen == SEEN_TWOCELL_NEAR){
-                spaceNotFound = expandCompositCharAtNear(dest, start, length,0,1,0);
-                if(spaceNotFound){
-                    throw new ArabicShapingException("No space for Seen tail expansion");
-                }
-            }
-            if(lenOptionsYehHamza == YEHHAMZA_TWOCELL_NEAR){
-                spaceNotFound = expandCompositCharAtNear(dest, start, length,1,0,0);
-                if(spaceNotFound){
-                    throw new ArabicShapingException("No space for YehHamza expansion");
-                }
-            }
-            }
-        return length;
-    }
-
-
-    /* Convert the input buffer from FExx Range into 06xx Range
-     * to put all characters into the 06xx range
-     * even the lamalef is converted to the special region in
-     * the 06xx range.  Return the number of lamalef chars found.
-     */
-    private int normalize(char[] dest, int start, int length) {
-        int lacount = 0;
-        for (int i = start, e = i + length; i < e; ++i) {
-            char ch = dest[i];
-            if (ch >= '\uFE70' && ch <= '\uFEFC') {
-                if (isLamAlefChar(ch)) {
-                    ++lacount;
-                }
-                dest[i] = (char)convertFEto06[ch - '\uFE70'];
-            }
-        }
-        return lacount;
-    }
-
-    /*
-     * Name    : deshapeNormalize
-     * Function: Convert the input buffer from FExx Range into 06xx Range
-     *           even the lamalef is converted to the special region in the 06xx range.
-     *           According to the options the user enters, all seen family characters
-     *           followed by a tail character are merged to seen tail family character and
-     *           any yeh followed by a hamza character are merged to yehhamza character.
-     *           Method returns the number of lamalef chars found.
-     */
-    private int deshapeNormalize(char[] dest, int start, int length) {
-        int lacount = 0;
-        int yehHamzaComposeEnabled = 0;
-        int seenComposeEnabled = 0;
-
-        yehHamzaComposeEnabled = ((options&YEHHAMZA_MASK) == YEHHAMZA_TWOCELL_NEAR) ? 1 : 0;
-        seenComposeEnabled = ((options&SEEN_MASK) == SEEN_TWOCELL_NEAR)? 1 : 0;
-
-        for (int i = start, e = i + length; i < e; ++i) {
-            char ch = dest[i];
-
-        if( (yehHamzaComposeEnabled == 1) && ((ch == HAMZA06_CHAR) || (ch == HAMZAFE_CHAR))
-               && (i < (length - 1)) && isAlefMaksouraChar(dest[i+1] )) {
-                dest[i] = SPACE_CHAR;
-                dest[i+1] = YEH_HAMZA_CHAR;
-       } else if ( (seenComposeEnabled == 1) && (isTailChar(ch)) && (i< (length - 1))
-                       && (isSeenTailFamilyChar(dest[i+1])==1) ) {
-               dest[i] = SPACE_CHAR;
-       }
-       else if (ch >= '\uFE70' && ch <= '\uFEFC') {
-                if (isLamAlefChar(ch)) {
-                    ++lacount;
-                }
-                dest[i] = (char)convertFEto06[ch - '\uFE70'];
-            }
-        }
-        return lacount;
-    }
-
-    /*
-     * Name    : shapeUnicode
-     * Function: Converts an Arabic Unicode buffer in 06xx Range into a shaped
-     *           arabic Unicode buffer in FExx Range
-     */
-    private int shapeUnicode(char[] dest,
-                             int start,
-                             int length,
-                             int destSize,
-                             int tashkeelFlag)throws ArabicShapingException {
-
-        int lamalef_count = normalize(dest, start, length);
-
-        // resolve the link between the characters.
-        // Arabic characters have four forms: Isolated, Initial, Medial and Final.
-        // Tashkeel characters have two, isolated or medial, and sometimes only isolated.
-        // tashkeelFlag == 0: shape normally, 1: shape isolated, 2: don't shape
-
-        boolean lamalef_found = false, seenfam_found = false;
-        boolean yehhamza_found = false, tashkeel_found = false;
-        int i = start + length - 1;
-        int currLink = getLink(dest[i]);
-        int nextLink = 0;
-        int prevLink = 0;
-        int lastLink = 0;
-        //int prevPos = i;
-        int lastPos = i;
-        int nx = -2;
-        int nw = 0;
-
-        while (i >= 0) {
-            // If high byte of currLink > 0 then there might be more than one shape
-            if ((currLink & '\uFF00') > 0 || isTashkeelChar(dest[i])) {
-                nw = i - 1;
-                nx = -2;
-                while (nx < 0) { // we need to know about next char
-                    if (nw == -1) {
-                        nextLink = 0;
-                        nx = Integer.MAX_VALUE;
-                    } else {
-                        nextLink = getLink(dest[nw]);
-                        if ((nextLink & IRRELEVANT) == 0) {
-                            nx = nw;
-                        } else {
-                            --nw;
-                        }
-                    }
-                }
-
-                if (((currLink & ALEFTYPE) > 0) && ((lastLink & LAMTYPE) > 0)) {
-                    lamalef_found = true;
-                    char wLamalef = changeLamAlef(dest[i]); // get from 0x065C-0x065f
-                    if (wLamalef != '\u0000') {
-                        // replace alef by marker, it will be removed later
-                        dest[i] = '\uffff';
-                        dest[lastPos] = wLamalef;
-                        i = lastPos;
-                    }
-
-                    lastLink = prevLink;
-                    currLink = getLink(wLamalef); // requires '\u0000', unfortunately
-                }
-                if ((i > 0) && (dest[i-1] == SPACE_CHAR))
-                {
-                    if ( isSeenFamilyChar(dest[i]) == 1){
-                        seenfam_found = true;
-                    } else if (dest[i] == YEH_HAMZA_CHAR) {
-                        yehhamza_found = true;
-                    }
-                }
-                else if(i==0){
-                    if ( isSeenFamilyChar(dest[i]) == 1){
-                        seenfam_found = true;
-                    } else if (dest[i] == YEH_HAMZA_CHAR) {
-                        yehhamza_found = true;
-                    }
-                }
-
-
-                // 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
-
-                int flag = specialChar(dest[i]);
-
-                int shape = shapeTable[nextLink & LINK_MASK]
-                    [lastLink & LINK_MASK]
-                    [currLink & LINK_MASK];
-
-                if (flag == 1) {
-                    shape &= 0x1;
-                } else if (flag == 2) {
-                    if (tashkeelFlag == 0 &&
-                        ((lastLink & LINKL) != 0) &&
-                        ((nextLink & LINKR) != 0) &&
-                        dest[i] != '\u064C' &&
-                        dest[i] != '\u064D' &&
-                        !((nextLink & ALEFTYPE) == ALEFTYPE &&
-                          (lastLink & LAMTYPE) == LAMTYPE)) {
-
-                        shape = 1;
-                    } else {
-                        shape = 0;
-                    }
-                }
-                if (flag == 2) {
-                    if (tashkeelFlag == 2) {
-                        dest[i] = TASHKEEL_SPACE_SUB;
-                        tashkeel_found = true;
-                    }
-                    else{
-                        dest[i] = (char)('\uFE70' + irrelevantPos[dest[i] - '\u064B'] + shape);
-                    }
-                    // else leave tashkeel alone
-                } else {
-                    dest[i] = (char)('\uFE70' + (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 = -2;
-            } else if (i != -1) {
-                currLink = getLink(dest[i]);
-            }
-        }
-
-        // If we found a lam/alef pair in the buffer
-        // call handleGeneratedSpaces to remove the spaces that were added
-
-        destSize = length;
-        if (lamalef_found || tashkeel_found) {
-            destSize = handleGeneratedSpaces(dest, start, length);
-        }
-        if (seenfam_found || yehhamza_found){
-            destSize = expandCompositChar(dest, start, destSize, lamalef_count, SHAPE_MODE);
-        }
-        return destSize;
-    }
-
-    /*
-     * Name    : deShapeUnicode
-     * Function: Converts an Arabic Unicode buffer in FExx Range into unshaped
-     *           arabic Unicode buffer in 06xx Range
-     */
-    private int deShapeUnicode(char[] dest,
-                               int start,
-                               int length,
-                               int destSize) throws ArabicShapingException {
-
-        int lamalef_count = deshapeNormalize(dest, start, length);
-
-        // If there was a lamalef in the buffer call expandLamAlef
-        if (lamalef_count != 0) {
-            // need to adjust dest to fit expanded buffer... !!!
-            destSize = expandCompositChar(dest, start, length, lamalef_count,DESHAPE_MODE);
-        } else {
-            destSize = length;
-        }
-
-        return destSize;
-    }
-
-    private int internalShape(char[] source,
-                              int sourceStart,
-                              int sourceLength,
-                              char[] dest,
-                              int destStart,
-                              int destSize) throws ArabicShapingException {
-
-        if (sourceLength == 0) {
-            return 0;
-        }
-
-        if (destSize == 0) {
-            if (((options & LETTERS_MASK) != LETTERS_NOOP) &&
-                ((options & LAMALEF_MASK) == LAMALEF_RESIZE)) {
-
-                return calculateSize(source, sourceStart, sourceLength);
-            } else {
-                return sourceLength; // by definition
-            }
-        }
-
-        // always use temp buffer
-        char[] temp = new char[sourceLength * 2]; // all lamalefs requiring expansion
-        System.arraycopy(source, sourceStart, temp, 0, sourceLength);
-
-        if (isLogical) {
-            invertBuffer(temp, 0, sourceLength);
-        }
-
-        int outputSize = sourceLength;
-
-        switch (options & LETTERS_MASK) {
-        case LETTERS_SHAPE_TASHKEEL_ISOLATED:
-            outputSize = shapeUnicode(temp, 0, sourceLength, destSize, 1);
-            break;
-
-        case LETTERS_SHAPE:
-            if( ((options&TASHKEEL_MASK)> 0) &&
-                ((options&TASHKEEL_MASK) !=TASHKEEL_REPLACE_BY_TATWEEL)) {
-                   /* Call the shaping function with tashkeel flag == 2 for removal of tashkeel */
-                outputSize = shapeUnicode(temp, 0, sourceLength, destSize, 2);
-                }else {
-                   //default Call the shaping function with tashkeel flag == 1 */
-                    outputSize = shapeUnicode(temp, 0, sourceLength, destSize, 0);
-
-                   /*After shaping text check if user wants to remove tashkeel and replace it with tatweel*/
-                   if( (options&TASHKEEL_MASK) == TASHKEEL_REPLACE_BY_TATWEEL){
-                       outputSize = handleTashkeelWithTatweel(temp,sourceLength);
-                   }
-               }
-            break;
-
-        case LETTERS_UNSHAPE:
-            outputSize = deShapeUnicode(temp, 0, sourceLength, destSize);
-            break;
-
-        default:
-            break;
-        }
-
-        if (outputSize > destSize) {
-            throw new ArabicShapingException("not enough room for result data");
-        }
-
-        if ((options & DIGITS_MASK) != DIGITS_NOOP) {
-            char digitBase = '\u0030'; // European digits
-            switch (options & DIGIT_TYPE_MASK) {
-            case DIGIT_TYPE_AN:
-                digitBase = '\u0660';  // Arabic-Indic digits
-                break;
-
-            case DIGIT_TYPE_AN_EXTENDED:
-                digitBase = '\u06f0';  // Eastern Arabic-Indic digits (Persian and Urdu)
-                break;
-
-            default:
-                break;
-            }
-
-            switch (options & DIGITS_MASK) {
-            case DIGITS_EN2AN:
-                {
-                    int digitDelta = digitBase - '\u0030';
-                    for (int i = 0; i < outputSize; ++i) {
-                        char ch = temp[i];
-                        if (ch <= '\u0039' && ch >= '\u0030') {
-                            temp[i] += digitDelta;
-                        }
-                    }
-                }
-                break;
-
-            case DIGITS_AN2EN:
-                {
-                    char digitTop = (char)(digitBase + 9);
-                    int digitDelta = '\u0030' - digitBase;
-                    for (int i = 0; i < outputSize; ++i) {
-                        char ch = temp[i];
-                        if (ch <= digitTop && ch >= digitBase) {
-                            temp[i] += digitDelta;
-                        }
-                    }
-                }
-                break;
-
-            case DIGITS_EN2AN_INIT_LR:
-                shapeToArabicDigitsWithContext(temp, 0, outputSize, digitBase, false);
-                break;
-
-            case DIGITS_EN2AN_INIT_AL:
-                shapeToArabicDigitsWithContext(temp, 0, outputSize, digitBase, true);
-                break;
-
-            default:
-                break;
-            }
-        }
-
-        if (isLogical) {
-            invertBuffer(temp, 0, outputSize);
-        }
-
-        System.arraycopy(temp, 0, dest, destStart, outputSize);
-
-        return outputSize;
-    }
-
-    private static class ArabicShapingException extends RuntimeException {
-        ArabicShapingException(String msg) {
-            super(msg);
-        }
-    }
-}
diff --git a/icu4j/license.html b/icu4j/license.html
deleted file mode 100644
index b905ddf..0000000
--- a/icu4j/license.html
+++ /dev/null
@@ -1,51 +0,0 @@
-<html>
-
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii"></meta>
-<title>ICU License - ICU 1.8.1 and later</title>
-</head>
-
-<body BGCOLOR="#ffffff">
-<h2>ICU License - ICU 1.8.1 and later</h2>
-
-<p>COPYRIGHT AND PERMISSION NOTICE</p>
-
-<p>
-Copyright (c) 1995-2006 International Business Machines Corporation and others
-</p>
-<p>
-All rights reserved.
-</p>
-<p>
-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.
-</p>
-<p>
-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.
-</p>
-<p>
-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.
-</p>
-
-<hr>
-<p><small>
-All trademarks and registered trademarks mentioned herein are the property of their respective owners.
-</small></p>
-</body>
-</html>