PersianShaping
40 removals
| Words removed | 69 |
| Total words | 9036 |
| Words removed (%) | 0.76 |
1756 lines
137 additions
| Words added | 513 |
| Total words | 9480 |
| Words added (%) | 5.41 |
1841 lines
// © 2016 and later: Unicode, Inc. and others.
//© 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html#License
//License & terms of use: http://www.unicode.org/copyright.html#License
/*
/*
*******************************************************************************
*******************************************************************************
* Copyright (C) 2001-2012, International Business Machines
* Copyright (C) 2001-2012, International Business Machines
* Corporation and others. All Rights Reserved.
* Corporation and others. All Rights Reserved.
*******************************************************************************
*******************************************************************************
*/
*/
import com.ibm.icu.impl.UBiDiProps;
import com.ibm.icu.impl.UBiDiProps;
import com.ibm.icu.lang.UCharacterDirection;
import com.ibm.icu.lang.UCharacterDirection;
import com.ibm.icu.text.ArabicShapingException;
/**
/**
* Shape Arabic text on a character basis.
* Shape Persian text on a character basis. - Edited by soheil rahsaz
*
*
* <p>ArabicShaping performs basic operations for "shaping" Arabic text. It is most
* <p>PersianShaping performs basic operations for "shaping" Arabic text. It is most
* useful for use with legacy data formats and legacy display technology
* useful for use with legacy data formats and legacy display technology
* (simple terminals). All operations are performed on Unicode characters.</p>
* (simple terminals). All operations are performed on Unicode characters.</p>
*
*
* <p>Text-based shaping means that some character code points in the text are
* <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
* replaced by others depending on the context. It transforms one kind of text
* into another. In comparison, modern displays for Arabic text select
* into another. In comparison, modern displays for Arabic text select
* appropriate, context-dependent font glyphs for each text element, which means
* appropriate, context-dependent font glyphs for each text element, which means
* that they transform text into a glyph vector.</p>
* that they transform text into a glyph vector.</p>
*
*
* <p>Text transformations are necessary when modern display technology is not
* <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
* available or when text needs to be transformed to or from legacy formats that
* use "shaped" characters. Since the Arabic script is cursive, connecting
* use "shaped" characters. Since the Arabic script is cursive, connecting
* adjacent letters to each other, computers select images for each letter based
* adjacent letters to each other, computers select images for each letter based
* on the surrounding letters. This usually results in four images per Arabic
* on the surrounding letters. This usually results in four images per Arabic
* letter: initial, middle, final, and isolated forms. In Unicode, on the other
* letter: initial, middle, final, and isolated forms. In Unicode, on the other
* hand, letters are normally stored abstract, and a display system is expected
* hand, letters are normally stored abstract, and a display system is expected
* to select the necessary glyphs. (This makes searching and other text
* to select the necessary glyphs. (This makes searching and other text
* processing easier because the same letter has only one code.) It is possible
* processing easier because the same letter has only one code.) It is possible
* to mimic this with text transformations because there are characters in
* to mimic this with text transformations because there are characters in
* Unicode that are rendered as letters with a specific shape
* Unicode that are rendered as letters with a specific shape
* (or cursive connectivity). They were included for interoperability with
* (or cursive connectivity). They were included for interoperability with
* legacy systems and codepages, and for unsophisticated display systems.</p>
* legacy systems and codepages, and for unsophisticated display systems.</p>
*
*
* <p>A second kind of text transformations is supported for Arabic digits:
* <p>A second kind of text transformations is supported for Arabic digits:
* For compatibility with legacy codepages that only include European digits,
* For compatibility with legacy codepages that only include European digits,
* it is possible to replace one set of digits by another, changing the
* it is possible to replace one set of digits by another, changing the
* character code points. These operations can be performed for either
* character code points. These operations can be performed for either
* Arabic-Indic Digits (U+0660...U+0669) or Eastern (Extended) Arabic-Indic
* Arabic-Indic Digits (U+0660...U+0669) or Eastern (Extended) Arabic-Indic
* digits (U+06f0...U+06f9).</p>
* digits (U+06f0...U+06f9).</p>
*
*
* <p>Some replacements may result in more or fewer characters (code points).
* <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
* 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 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
* 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
* or consumed either next to the affected character or at the end of the
* text.</p>
* text.</p>
* @stable ICU 2.0
* @stable ICU 2.0
* @author Edited: Soheil Rahsaz
*/
*/
public final class ArabicShaping {
public final class PersianShaping {
private final int options;
private final int options;
private boolean isLogical; // convenience
private boolean isLogical; // convenience
private boolean spacesRelativeToTextBeginEnd;
private boolean spacesRelativeToTextBeginEnd;
private char tailChar;
private char tailChar;
/**
/**
* Convert a range of text in the source array, putting the result
* 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
* into a range of text in the destination array, and return the number
* of characters written.
* of characters written.
*
*
* @param source An array containing the input text
* @param source An array containing the input text
* @param sourceStart The start of the range of text to convert
* @param sourceStart The start of the range of text to convert
* @param sourceLength The length 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.
* @param dest The destination array that will receive the result.
* It may be <code>NULL</code> only if <code>destSize</code> is 0.
* 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 destStart The start of the range of the destination buffer to use.
* @param destSize The size (capacity) of the destination buffer.
* @param destSize The size (capacity) of the destination buffer.
* If <code>destSize</code> is 0, then no output is produced,
* If <code>destSize</code> is 0, then no output is produced,
* but the necessary buffer size is returned ("preflighting"). This
* but the necessary buffer size is returned ("preflighting"). This
* does not validate the text against the options, for example,
* does not validate the text against the options, for example,
* if letters are being unshaped, and spaces are being consumed
* if letters are being unshaped, and spaces are being consumed
* following lamalef, this will not detect a lamalef without a
* following lamalef, this will not detect a lamalef without a
* corresponding space. An error will be thrown when the actual
* corresponding space. An error will be thrown when the actual
* conversion is attempted.
* conversion is attempted.
* @return The number of chars written to the destination buffer.
* @return The number of chars written to the destination buffer.
* If an error occurs, then no output was written, or it may be
* If an error occurs, then no output was written, or it may be
* incomplete.
* incomplete.
* @throws ArabicShapingException if the text cannot be converted according to the options.
* @throws ArabicShapingException if the text cannot be converted according to the options.
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public int shape(char[] source, int sourceStart, int sourceLength,
public int shape(char[] source, int sourceStart, int sourceLength,
char[] dest, int destStart, int destSize) throws ArabicShapingException {
char[] dest, int destStart, int destSize) throws ArabicShapingException {
if (source == null) {
if (source == null) {
throw new IllegalArgumentException("source can not be null");
throw new IllegalArgumentException("source can not be null");
}
}
if (sourceStart < 0 || sourceLength < 0 || sourceStart + sourceLength > source.length) {
if (sourceStart < 0 || sourceLength < 0 || sourceStart + sourceLength > source.length) {
throw new IllegalArgumentException("bad source start (" + sourceStart +
throw new IllegalArgumentException("bad source start (" + sourceStart +
") or length (" + sourceLength +
") or length (" + sourceLength +
") for buffer of length " + source.length);
") for buffer of length " + source.length);
}
}
if (dest == null && destSize != 0) {
if (dest == null && destSize != 0) {
throw new IllegalArgumentException("null dest requires destSize == 0");
throw new IllegalArgumentException("null dest requires destSize == 0");
}
}
if ((destSize != 0) &&
if ((destSize != 0) &&
(destStart < 0 || destSize < 0 || destStart + destSize > dest.length)) {
(destStart < 0 || destSize < 0 || destStart + destSize > dest.length)) {
throw new IllegalArgumentException("bad dest start (" + destStart +
throw new IllegalArgumentException("bad dest start (" + destStart +
") or size (" + destSize +
") or size (" + destSize +
") for buffer of length " + dest.length);
") for buffer of length " + dest.length);
}
}
/* Validate input options */
/* Validate input options */
if ( ((options&TASHKEEL_MASK) != 0) &&
if ( ((options&TASHKEEL_MASK) != 0) &&
!(((options & TASHKEEL_MASK)==TASHKEEL_BEGIN) ||
!(((options & TASHKEEL_MASK)==TASHKEEL_BEGIN) ||
((options & TASHKEEL_MASK)==TASHKEEL_END) ||
((options & TASHKEEL_MASK)==TASHKEEL_END) ||
((options & TASHKEEL_MASK)==TASHKEEL_RESIZE) ||
((options & TASHKEEL_MASK)==TASHKEEL_RESIZE) ||
((options & TASHKEEL_MASK)==TASHKEEL_REPLACE_BY_TATWEEL))) {
((options & TASHKEEL_MASK)==TASHKEEL_REPLACE_BY_TATWEEL))) {
throw new IllegalArgumentException("Wrong Tashkeel argument");
throw new IllegalArgumentException("Wrong Tashkeel argument");
}
}
///CLOVER:OFF
///CLOVER:OFF
//According to Steven Loomis, the code is unreachable when you OR all the constants within the if statements
//According to Steven Loomis, the code is unreachable when you OR all the constants within the if statements
if(((options&LAMALEF_MASK) != 0) &&
if(((options&LAMALEF_MASK) != 0) &&
!(((options & LAMALEF_MASK)==LAMALEF_BEGIN) ||
!(((options & LAMALEF_MASK)==LAMALEF_BEGIN) ||
((options & LAMALEF_MASK)==LAMALEF_END) ||
((options & LAMALEF_MASK)==LAMALEF_END) ||
((options & LAMALEF_MASK)==LAMALEF_RESIZE) ||
((options & LAMALEF_MASK)==LAMALEF_RESIZE) ||
((options & LAMALEF_MASK)==LAMALEF_AUTO) ||
((options & LAMALEF_MASK)==LAMALEF_AUTO) ||
((options & LAMALEF_MASK)==LAMALEF_NEAR))) {
((options & LAMALEF_MASK)==LAMALEF_NEAR))) {
throw new IllegalArgumentException("Wrong Lam Alef argument");
throw new IllegalArgumentException("Wrong Lam Alef argument");
}
}
///CLOVER:ON
///CLOVER:ON
/* Validate Tashkeel (Tashkeel replacement options should be enabled in shaping mode only)*/
/* Validate Tashkeel (Tashkeel replacement options should be enabled in shaping mode only)*/
if(((options&TASHKEEL_MASK) != 0) && (options&LETTERS_MASK) == LETTERS_UNSHAPE) {
if(((options&TASHKEEL_MASK) != 0) && (options&LETTERS_MASK) == LETTERS_UNSHAPE) {
throw new IllegalArgumentException("Tashkeel replacement should not be enabled in deshaping mode ");
throw new IllegalArgumentException("Tashkeel replacement should not be enabled in deshaping mode ");
}
}
return internalShape(source, sourceStart, sourceLength, dest, destStart, destSize);
return internalShape(source, sourceStart, sourceLength, dest, destStart, destSize);
}
}
/**
/**
* Convert a range of text in place. This may only be used if the Length option
* Convert a range of text in place. This may only be used if the Length option
* does not grow or shrink the text.
* does not grow or shrink the text.
*
*
* @param source An array containing the input text
* @param source An array containing the input text
* @param start The start of the range of text to convert
* @param start The start of the range of text to convert
* @param length The length 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.
* @throws ArabicShapingException if the text cannot be converted according to the options.
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public void shape(char[] source, int start, int length) throws ArabicShapingException {
public void shape(char[] source, int start, int length) throws ArabicShapingException {
if ((options & LAMALEF_MASK) == LAMALEF_RESIZE) {
if ((options & LAMALEF_MASK) == LAMALEF_RESIZE) {
throw new ArabicShapingException("Cannot shape in place with length option resize.");
throw new ArabicShapingException("Cannot shape in place with length option resize.");
}
}
shape(source, start, length, source, start, length);
shape(source, start, length, source, start, length);
}
}
/**
/**
* Convert a string, returning the new string.
* Convert a string, returning the new string.
*
*
* @param text the string to convert
* @param text the string to convert
* @return the converted string
* @return the converted string
* @throws ArabicShapingException if the string cannot be converted according to the options.
* @throws ArabicShapingException if the string cannot be converted according to the options.
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public String shape(String text) throws ArabicShapingException {
public String shape(String text) throws ArabicShapingException {
char[] src = text.toCharArray();
char[] src = text.toCharArray();
char[] dest = src;
char[] dest = src;
if (((options & LAMALEF_MASK) == LAMALEF_RESIZE) &&
if (((options & LAMALEF_MASK) == LAMALEF_RESIZE) &&
((options & LETTERS_MASK) == LETTERS_UNSHAPE)) {
((options & LETTERS_MASK) == LETTERS_UNSHAPE)) {
dest = new char[src.length * 2]; // max
dest = new char[src.length * 2]; // max
}
}
int len = shape(src, 0, src.length, dest, 0, dest.length);
int len = shape(src, 0, src.length, dest, 0, dest.length);
return new String(dest, 0, len);
return new String(dest, 0, len);
}
}
/**
/**
* Construct ArabicShaping using the options flags.
* Construct PersianShaping using the options flags.
* The flags are as follows:<br>
* The flags are as follows:<br>
* 'LENGTH' flags control whether the text can change size, and if not,
* 'LENGTH' flags control whether the text can change size, and if not,
* how to maintain the size of the text when LamAlef ligatures are
* how to maintain the size of the text when LamAlef ligatures are
* formed or broken.<br>
* formed or broken.<br>
* 'TEXT_DIRECTION' flags control whether the text is read and written
* 'TEXT_DIRECTION' flags control whether the text is read and written
* in visual order or in logical order.<br>
* in visual order or in logical order.<br>
* 'LETTERS_SHAPE' flags control whether conversion is to or from
* 'LETTERS_SHAPE' flags control whether conversion is to or from
* presentation forms.<br>
* presentation forms.<br>
* 'DIGITS' flags control whether digits are shaped, and whether from
* 'DIGITS' flags control whether digits are shaped, and whether from
* European to Arabic-Indic or vice-versa.<br>
* European to Arabic-Indic or vice-versa.<br>
* 'DIGIT_TYPE' flags control whether standard or extended Arabic-Indic
* 'DIGIT_TYPE' flags control whether standard or extended Arabic-Indic
* digits are used when performing digit conversion.
* digits are used when performing digit conversion.
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public ArabicShaping(int options) {
public PersianShaping(int options) {
this.options = options;
this.options = options;
if ((options & DIGITS_MASK) > 0x80) {
if ((options & DIGITS_MASK) > 0x80) {
throw new IllegalArgumentException("bad DIGITS options");
throw new IllegalArgumentException("bad DIGITS options");
}
}
isLogical = ( (options & TEXT_DIRECTION_MASK) == TEXT_DIRECTION_LOGICAL );
isLogical = ( (options & TEXT_DIRECTION_MASK) == TEXT_DIRECTION_LOGICAL );
/* Validate options */
/* Validate options */
spacesRelativeToTextBeginEnd = ( (options & SPACES_RELATIVE_TO_TEXT_MASK) == SPACES_RELATIVE_TO_TEXT_BEGIN_END );
spacesRelativeToTextBeginEnd = ( (options & SPACES_RELATIVE_TO_TEXT_MASK) == SPACES_RELATIVE_TO_TEXT_BEGIN_END );
if ( (options&SHAPE_TAIL_TYPE_MASK) == SHAPE_TAIL_NEW_UNICODE){
if ( (options&SHAPE_TAIL_TYPE_MASK) == SHAPE_TAIL_NEW_UNICODE){
tailChar = NEW_TAIL_CHAR;
tailChar = NEW_TAIL_CHAR;
} else {
} else {
tailChar = OLD_TAIL_CHAR;
tailChar = OLD_TAIL_CHAR;
}
}
}
}
/* Seen Tail options */
/* Seen Tail options */
/**
/**
* Memory option: the result must have the same length as the source.
* 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
* 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).
* the SEEN family character(i.e. the space after the character).
* if there are no spaces found, ArabicShapingException will be thrown
* if there are no spaces found, ArabicShapingException will be thrown
*
*
* De-shaping mode: Any Seen character followed by Tail character will be
* De-shaping mode: Any Seen character followed by Tail character will be
* replaced by one cell Seen and a space will replace the Tail.
* replaced by one cell Seen and a space will replace the Tail.
* Affects: Seen options
* Affects: Seen options
* @stable ICU 4.2
* @stable ICU 4.2
*/
*/
public static final int SEEN_TWOCELL_NEAR = 0x200000;
public static final int SEEN_TWOCELL_NEAR = 0x200000;
/** Bit mask for Seen memory options.
/** Bit mask for Seen memory options.
* @stable ICU 4.2
* @stable ICU 4.2
*/
*/
public static final int SEEN_MASK = 0x700000;
public static final int SEEN_MASK = 0x700000;
/* YehHamza options */
/* YehHamza options */
/**
/**
* Memory option: the result must have the same length as the source.
* 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
* Shaping mode: The YEHHAMZA character will expand into two characters using space near it
* (i.e. the space after the character)
* (i.e. the space after the character)
* if there are no spaces found, ArabicShapingException will be thrown
* 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
* 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.
* replaced by one cell YehHamza and space will replace the Hamza.
* Affects: YehHamza options
* Affects: YehHamza options
* @stable ICU 4.2
* @stable ICU 4.2
*/
*/
public static final int YEHHAMZA_TWOCELL_NEAR = 0x1000000;
public static final int YEHHAMZA_TWOCELL_NEAR = 0x1000000;
/** Bit mask for YehHamza memory options.
/** Bit mask for YehHamza memory options.
* @stable ICU 4.2
* @stable ICU 4.2
*/
*/
public static final int YEHHAMZA_MASK = 0x3800000;
public static final int YEHHAMZA_MASK = 0x3800000;
/* New Tashkeel options */
/* New Tashkeel options */
/**
/**
* Memory option: the result must have the same length as the source.
* Memory option: the result must have the same length as the source.
* Shaping mode: Tashkeel characters will be replaced by spaces.
* Shaping mode: Tashkeel characters will be replaced by spaces.
* Spaces will be placed at beginning of the buffer
* Spaces will be placed at beginning of the buffer
*
*
* De-shaping mode: N/A
* De-shaping mode: N/A
* Affects: Tashkeel options
* Affects: Tashkeel options
* @stable ICU 4.2
* @stable ICU 4.2
*/
*/
public static final int TASHKEEL_BEGIN = 0x40000;
public static final int TASHKEEL_BEGIN = 0x40000;
/**
/**
* Memory option: the result must have the same length as the source.
* Memory option: the result must have the same length as the source.
* Shaping mode: Tashkeel characters will be replaced by spaces.
* Shaping mode: Tashkeel characters will be replaced by spaces.
* Spaces will be placed at end of the buffer
* Spaces will be placed at end of the buffer
*
*
* De-shaping mode: N/A
* De-shaping mode: N/A
* Affects: Tashkeel options
* Affects: Tashkeel options
* @stable ICU 4.2
* @stable ICU 4.2
*/
*/
public static final int TASHKEEL_END = 0x60000;
public static final int TASHKEEL_END = 0x60000;
/**
/**
* Memory option: allow the result to have a different length than the source.
* Memory option: allow the result to have a different length than the source.
* Shaping mode: Tashkeel characters will be removed, buffer length will shrink.
* Shaping mode: Tashkeel characters will be removed, buffer length will shrink.
* De-shaping mode: N/A
* De-shaping mode: N/A
*
*
* Affects: Tashkeel options
* Affects: Tashkeel options
* @stable ICU 4.2
* @stable ICU 4.2
*/
*/
public static final int TASHKEEL_RESIZE = 0x80000;
public static final int TASHKEEL_RESIZE = 0x80000;
/**
/**
* Memory option: the result must have the same length as the source.
* 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
* 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.
* characters (i.e. shaped on Tatweel) or replaced by space if it is not connected.
*
*
* De-shaping mode: N/A
* De-shaping mode: N/A
* Affects: YehHamza options
* Affects: YehHamza options
* @stable ICU 4.2
* @stable ICU 4.2
*/
*/
public static final int TASHKEEL_REPLACE_BY_TATWEEL = 0xC0000;
public static final int TASHKEEL_REPLACE_BY_TATWEEL = 0xC0000;
/** Bit mask for Tashkeel replacement with Space or Tatweel memory options.
/** Bit mask for Tashkeel replacement with Space or Tatweel memory options.
* @stable ICU 4.2
* @stable ICU 4.2
*/
*/
public static final int TASHKEEL_MASK = 0xE0000;
public static final int TASHKEEL_MASK = 0xE0000;
/* Space location Control options */
/* Space location Control options */
/**
/**
* This option effects the meaning of BEGIN and END options. if this option is not used the default
* 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:
* for BEGIN and END will be as following:
* The Default (for both Visual LTR, Visual RTL and Logical Text)
* The Default (for both Visual LTR, Visual RTL and Logical Text)
* 1. BEGIN always refers to the start address of physical memory.
* 1. BEGIN always refers to the start address of physical memory.
* 2. END always refers to the end 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.
* 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:
* 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
* 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)
* (corresponding to the physical memory address end, same as END in default behavior)
* B. BEGIN For Logical text: Same as BEGIN 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
* 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)
* the physical memory address beginning, same as BEGIN in default behavior)
* D. END For Logical text: Same as END in default behavior.
* D. END For Logical text: Same as END in default behavior.
* Affects: All LamAlef BEGIN, END and AUTO options.
* Affects: All LamAlef BEGIN, END and AUTO options.
* @stable ICU 4.2
* @stable ICU 4.2
*/
*/
public static final int SPACES_RELATIVE_TO_TEXT_BEGIN_END = 0x4000000;
public static final int SPACES_RELATIVE_TO_TEXT_BEGIN_END = 0x4000000;
/** Bit mask for swapping BEGIN and END for Visual LTR text
/** Bit mask for swapping BEGIN and END for Visual LTR text
* @stable ICU 4.2
* @stable ICU 4.2
*/
*/
public static final int SPACES_RELATIVE_TO_TEXT_MASK = 0x4000000;
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 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)
* 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
* 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
* TAIL (i.e. 0xFE73) or the old unofficial Unicode TAIL code point (i.e. 0x200B) and de-shape the
* Seen-Family letter accordingly.
* Seen-Family letter accordingly.
*
*
* Shaping Mode: Only shaping.
* Shaping Mode: Only shaping.
* De-shaping Mode: N/A.
* De-shaping Mode: N/A.
* Affects: All Seen options
* Affects: All Seen options
* @stable ICU 4.2
* @stable ICU 4.2
*/
*/
public static final int SHAPE_TAIL_NEW_UNICODE = 0x8000000;
public static final int SHAPE_TAIL_NEW_UNICODE = 0x8000000;
/** Bit mask for new Unicode Tail option
/** Bit mask for new Unicode Tail option
* @stable ICU 4.2
* @stable ICU 4.2
*/
*/
public static final int SHAPE_TAIL_TYPE_MASK = 0x8000000;
public static final int SHAPE_TAIL_TYPE_MASK = 0x8000000;
/**
/**
* Memory option: allow the result to have a different length than the source.
* Memory option: allow the result to have a different length than the source.
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public static final int LENGTH_GROW_SHRINK = 0;
public static final int LENGTH_GROW_SHRINK = 0;
/**
/**
* Memory option: allow the result to have a different length than the source.
* Memory option: allow the result to have a different length than the source.
* Affects: LamAlef options
* Affects: LamAlef options
* This option is an alias to LENGTH_GROW_SHRINK
* This option is an alias to LENGTH_GROW_SHRINK
* @stable ICU 4.2
* @stable ICU 4.2
*/
*/
public static final int LAMALEF_RESIZE = 0;
public static final int LAMALEF_RESIZE = 0;
/**
/**
* Memory option: the result must have the same length as the source.
* 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.
* If more room is necessary, then try to consume spaces next to modified characters.
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public static final int LENGTH_FIXED_SPACES_NEAR = 1;
public static final int LENGTH_FIXED_SPACES_NEAR = 1;
/**
/**
* Memory option: the result must have the same length as the source.
* 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.
* If more room is necessary, then try to consume spaces next to modified characters.
* Affects: LamAlef options
* Affects: LamAlef options
* This option is an alias to LENGTH_FIXED_SPACES_NEAR
* This option is an alias to LENGTH_FIXED_SPACES_NEAR
* @stable ICU 4.2
* @stable ICU 4.2
*/
*/
public static final int LAMALEF_NEAR = 1 ;
public static final int LAMALEF_NEAR = 1 ;
/**
/**
* Memory option: the result must have the same length as the source.
* 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.
* If more room is necessary, then try to consume spaces at the end of the text.
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public static final int LENGTH_FIXED_SPACES_AT_END = 2;
public static final int LENGTH_FIXED_SPACES_AT_END = 2;
/**
/**
* Memory option: the result must have the same length as the source.
* 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.
* If more room is necessary, then try to consume spaces at the end of the text.
* Affects: LamAlef options
* Affects: LamAlef options
* This option is an alias to LENGTH_FIXED_SPACES_AT_END
* This option is an alias to LENGTH_FIXED_SPACES_AT_END
* @stable ICU 4.2
* @stable ICU 4.2
*/
*/
public static final int LAMALEF_END = 2;
public static final int LAMALEF_END = 2;
/**
/**
* Memory option: the result must have the same length as the source.
* 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.
* If more room is necessary, then try to consume spaces at the beginning of the text.
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public static final int LENGTH_FIXED_SPACES_AT_BEGINNING = 3;
public static final int LENGTH_FIXED_SPACES_AT_BEGINNING = 3;
/**
/**
* Memory option: the result must have the same length as the source.
* 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.
* If more room is necessary, then try to consume spaces at the beginning of the text.
* Affects: LamAlef options
* Affects: LamAlef options
* This option is an alias to LENGTH_FIXED_SPACES_AT_BEGINNING
* This option is an alias to LENGTH_FIXED_SPACES_AT_BEGINNING
* @stable ICU 4.2
* @stable ICU 4.2
*/
*/
public static final int LAMALEF_BEGIN = 3;
public static final int LAMALEF_BEGIN = 3;
/**
/**
* Memory option: the result must have the same length as the source.
* 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.
* 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
* 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
* is no space at beginning of the buffer, use spaces at the near (i.e. the space
* after the LAMALEF character).
* after the LAMALEF character).
*
*
* Deshaping Mode: Perform the same function as the flag equals LAMALEF_END.
* Deshaping Mode: Perform the same function as the flag equals LAMALEF_END.
* Affects: LamAlef options
* Affects: LamAlef options
* @stable ICU 4.2
* @stable ICU 4.2
*/
*/
public static final int LAMALEF_AUTO = 0x10000;
public static final int LAMALEF_AUTO = 0x10000;
/**
/**
* Bit mask for memory options.
* Bit mask for memory options.
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public static final int LENGTH_MASK = 0x10003;
public static final int LENGTH_MASK = 0x10003;
/** Bit mask for LamAlef memory options.
/** Bit mask for LamAlef memory options.
* @stable ICU 4.2
* @stable ICU 4.2
*/
*/
public static final int LAMALEF_MASK = 0x10003;
public static final int LAMALEF_MASK = 0x10003;
/**
/**
* Direction indicator: the source is in logical (keyboard) order.
* Direction indicator: the source is in logical (keyboard) order.
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public static final int TEXT_DIRECTION_LOGICAL = 0;
public static final int TEXT_DIRECTION_LOGICAL = 0;
/**
/**
* Direction indicator:the source is in visual RTL order,
* Direction indicator:the source is in visual RTL order,
* the rightmost displayed character stored first.
* the rightmost displayed character stored first.
* This option is an alias to U_SHAPE_TEXT_DIRECTION_LOGICAL
* This option is an alias to U_SHAPE_TEXT_DIRECTION_LOGICAL
* @stable ICU 4.2
* @stable ICU 4.2
*/
*/
public static final int TEXT_DIRECTION_VISUAL_RTL = 0;
public static final int TEXT_DIRECTION_VISUAL_RTL = 0;
/**
/**
* Direction indicator: the source is in visual (display) order, that is,
* Direction indicator: the source is in visual (display) order, that is,
* the leftmost displayed character is stored first.
* the leftmost displayed character is stored first.
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public static final int TEXT_DIRECTION_VISUAL_LTR = 4;
public static final int TEXT_DIRECTION_VISUAL_LTR = 4;
/**
/**
* Bit mask for direction indicators.
* Bit mask for direction indicators.
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public static final int TEXT_DIRECTION_MASK = 4;
public static final int TEXT_DIRECTION_MASK = 4;
/**
/**
* Letter shaping option: do not perform letter shaping.
* Letter shaping option: do not perform letter shaping.
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public static final int LETTERS_NOOP = 0;
public static final int LETTERS_NOOP = 0;
/**
/**
* Letter shaping option: replace normative letter characters in the U+0600 (Arabic) block,
* 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
* by shaped ones in the U+FE70 (Presentation Forms B) block. Performs Lam-Alef ligature
* substitution.
* substitution.
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public static final int LETTERS_SHAPE = 8;
public static final int LETTERS_SHAPE = 8;
/**
/**
* Letter shaping option: replace shaped letter characters in the U+FE70 (Presentation Forms B) block
* 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
* by normative ones in the U+0600 (Arabic) block. Converts Lam-Alef ligatures to pairs of Lam and
* Alef characters, consuming spaces if required.
* Alef characters, consuming spaces if required.
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public static final int LETTERS_UNSHAPE = 0x10;
public static final int LETTERS_UNSHAPE = 0x10;
/**
/**
* Letter shaping option: replace normative letter characters in the U+0600 (Arabic) block,
* 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
* 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
* (Presentation Forms B) block. The TASHKEEL characters will always be converted to
* the isolated forms rather than to their correct shape.
* the isolated forms rather than to their correct shape.
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public static final int LETTERS_SHAPE_TASHKEEL_ISOLATED = 0x18;
public static final int LETTERS_SHAPE_TASHKEEL_ISOLATED = 0x18;
/**
/**
* Bit mask for letter shaping options.
* Bit mask for letter shaping options.
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public static final int LETTERS_MASK = 0x18;
public static final int LETTERS_MASK = 0x18;
/**
/**
* Digit shaping option: do not perform digit shaping.
* Digit shaping option: do not perform digit shaping.
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public static final int DIGITS_NOOP = 0;
public static final int DIGITS_NOOP = 0;
/**
/**
* Digit shaping option: Replace European digits (U+0030...U+0039) by Arabic-Indic digits.
* Digit shaping option: Replace European digits (U+0030...U+0039) by Arabic-Indic digits.
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public static final int DIGITS_EN2AN = 0x20;
public static final int DIGITS_EN2AN = 0x20;
/**
/**
* Digit shaping option: Replace Arabic-Indic digits by European digits (U+0030...U+0039).
* Digit shaping option: Replace Arabic-Indic digits by European digits (U+0030...U+0039).
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public static final int DIGITS_AN2EN = 0x40;
public static final int DIGITS_AN2EN = 0x40;
/**
/**
* Digit shaping option:
* Digit shaping option:
* Replace European digits (U+0030...U+0039) by Arabic-Indic digits
* Replace European digits (U+0030...U+0039) by Arabic-Indic digits
* if the most recent strongly directional character
* if the most recent strongly directional character
* is an Arabic letter (its Bidi direction value is RIGHT_TO_LEFT_ARABIC).
* 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,
* 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.
* letter, so European digits at the start of the text will not change.
* Compare to DIGITS_ALEN2AN_INIT_AL.
* Compare to DIGITS_ALEN2AN_INIT_AL.
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public static final int DIGITS_EN2AN_INIT_LR = 0x60;
public static final int DIGITS_EN2AN_INIT_LR = 0x60;
/**
/**
* Digit shaping option:
* Digit shaping option:
* Replace European digits (U+0030...U+0039) by Arabic-Indic digits
* Replace European digits (U+0030...U+0039) by Arabic-Indic digits
* if the most recent strongly directional character
* if the most recent strongly directional character
* is an Arabic letter (its Bidi direction value is RIGHT_TO_LEFT_ARABIC).
* 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,
* 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.
* letter, so European digits at the start of the text will change.
* Compare to DIGITS_ALEN2AN_INT_LR.
* Compare to DIGITS_ALEN2AN_INT_LR.
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public static final int DIGITS_EN2AN_INIT_AL = 0x80;
public static final int DIGITS_EN2AN_INIT_AL = 0x80;
/** Not a valid option value. */
/** Not a valid option value. */
//private static final int DIGITS_RESERVED = 0xa0;
//private static final int DIGITS_RESERVED = 0xa0;
/**
/**
* Bit mask for digit shaping options.
* Bit mask for digit shaping options.
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public static final int DIGITS_MASK = 0xe0;
public static final int DIGITS_MASK = 0xe0;
/**
/**
* Digit type option: Use Arabic-Indic digits (U+0660...U+0669).
* Digit type option: Use Arabic-Indic digits (U+0660...U+0669).
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public static final int DIGIT_TYPE_AN = 0;
public static final int DIGIT_TYPE_AN = 0;
/**
/**
* Digit type option: Use Eastern (Extended) Arabic-Indic digits (U+06f0...U+06f9).
* Digit type option: Use Eastern (Extended) Arabic-Indic digits (U+06f0...U+06f9).
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public static final int DIGIT_TYPE_AN_EXTENDED = 0x100;
public static final int DIGIT_TYPE_AN_EXTENDED = 0x100;
/**
/**
* Bit mask for digit type options.
* Bit mask for digit type options.
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
public static final int DIGIT_TYPE_MASK = 0x0100; // 0x3f00?
public static final int DIGIT_TYPE_MASK = 0x0100; // 0x3f00?
/**
/**
* some constants
* some constants
*/
*/
private static final char HAMZAFE_CHAR = '\ufe80';
private static final char HAMZAFE_CHAR = '\ufe80';
private static final char HAMZA06_CHAR = '\u0621';
private static final char HAMZA06_CHAR = '\u0621';
private static final char YEH_HAMZA_CHAR = '\u0626';
private static final char YEH_HAMZA_CHAR = '\u0626';
private static final char YEH_HAMZAFE_CHAR = '\uFE89';
private static final char YEH_HAMZAFE_CHAR = '\uFE89';
private static final char LAMALEF_SPACE_SUB = '\uffff';
private static final char LAMALEF_SPACE_SUB = '\uffff';
private static final char TASHKEEL_SPACE_SUB = '\ufffe';
private static final char TASHKEEL_SPACE_SUB = '\ufffe';
private static final char LAM_CHAR = '\u0644';
private static final char LAM_CHAR = '\u0644';
private static final char SPACE_CHAR = '\u0020';
private static final char SPACE_CHAR = '\u0020';
private static final char SHADDA_CHAR = '\uFE7C';
private static final char SHADDA_CHAR = '\uFE7C';
private static final char SHADDA06_CHAR = '\u0651';
private static final char SHADDA06_CHAR = '\u0651';
private static final char TATWEEL_CHAR = '\u0640';
private static final char TATWEEL_CHAR = '\u0640';
private static final char SHADDA_TATWEEL_CHAR = '\uFE7D';
private static final char SHADDA_TATWEEL_CHAR = '\uFE7D';
private static final char NEW_TAIL_CHAR = '\uFE73';
private static final char NEW_TAIL_CHAR = '\uFE73';
private static final char OLD_TAIL_CHAR = '\u200B';
private static final char OLD_TAIL_CHAR = '\u200B';
private static final int SHAPE_MODE = 0;
private static final int SHAPE_MODE = 0;
private static final int DESHAPE_MODE = 1;
private static final int DESHAPE_MODE = 1;
/**
/**
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
@Override
@Override
public boolean equals(Object rhs) {
public boolean equals(Object rhs) {
return rhs != null &&
return rhs != null &&
rhs.getClass() == ArabicShaping.class &&
rhs.getClass() == PersianShaping.class &&
options == ((ArabicShaping)rhs).options;
options == ((PersianShaping)rhs).options;
}
}
/**
/**
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
///CLOVER:OFF
///CLOVER:OFF
@Override
@Override
public int hashCode() {
public int hashCode() {
return options;
return options;
}
}
/**
/**
* @stable ICU 2.0
* @stable ICU 2.0
*/
*/
@Override
@Override
public String toString() {
public String toString() {
StringBuilder buf = new StringBuilder(super.toString());
StringBuilder buf = new StringBuilder(super.toString());
buf.append('[');
buf.append('[');
switch (options & LAMALEF_MASK) {
switch (options & LAMALEF_MASK) {
case LAMALEF_RESIZE: buf.append("LamAlef resize"); break;
case LAMALEF_RESIZE: buf.append("LamAlef resize"); break;
case LAMALEF_NEAR: buf.append("LamAlef spaces at near"); break;
case LAMALEF_NEAR: buf.append("LamAlef spaces at near"); break;
case LAMALEF_BEGIN: buf.append("LamAlef spaces at begin"); break;
case LAMALEF_BEGIN: buf.append("LamAlef spaces at begin"); break;
case LAMALEF_END: buf.append("LamAlef spaces at end"); break;
case LAMALEF_END: buf.append("LamAlef spaces at end"); break;
case LAMALEF_AUTO: buf.append("lamAlef auto"); break;
case LAMALEF_AUTO: buf.append("lamAlef auto"); break;
}
}
switch (options & TEXT_DIRECTION_MASK) {
switch (options & TEXT_DIRECTION_MASK) {
case TEXT_DIRECTION_LOGICAL: buf.append(", logical"); break;
case TEXT_DIRECTION_LOGICAL: buf.append(", logical"); break;
case TEXT_DIRECTION_VISUAL_LTR: buf.append(", visual"); break;
case TEXT_DIRECTION_VISUAL_LTR: buf.append(", visual"); break;
}
}
switch (options & LETTERS_MASK) {
switch (options & LETTERS_MASK) {
case LETTERS_NOOP: buf.append(", no letter shaping"); break;
case LETTERS_NOOP: buf.append(", no letter shaping"); break;
case LETTERS_SHAPE: buf.append(", shape letters"); break;
case LETTERS_SHAPE: buf.append(", shape letters"); break;
case LETTERS_SHAPE_TASHKEEL_ISOLATED: buf.append(", shape letters tashkeel isolated"); break;
case LETTERS_SHAPE_TASHKEEL_ISOLATED: buf.append(", shape letters tashkeel isolated"); break;
case LETTERS_UNSHAPE: buf.append(", unshape letters"); break;
case LETTERS_UNSHAPE: buf.append(", unshape letters"); break;
}
}
switch (options & SEEN_MASK) {
switch (options & SEEN_MASK) {
case SEEN_TWOCELL_NEAR: buf.append(", Seen at near"); break;
case SEEN_TWOCELL_NEAR: buf.append(", Seen at near"); break;
}
}
switch (options & YEHHAMZA_MASK) {
switch (options & YEHHAMZA_MASK) {
case YEHHAMZA_TWOCELL_NEAR: buf.append(", Yeh Hamza at near"); break;
case YEHHAMZA_TWOCELL_NEAR: buf.append(", Yeh Hamza at near"); break;
}
}
switch (options & TASHKEEL_MASK) {
switch (options & TASHKEEL_MASK) {
case TASHKEEL_BEGIN: buf.append(", Tashkeel at begin"); break;
case TASHKEEL_BEGIN: buf.append(", Tashkeel at begin"); break;
case TASHKEEL_END: buf.append(", Tashkeel at end"); break;
case TASHKEEL_END: buf.append(", Tashkeel at end"); break;
case TASHKEEL_REPLACE_BY_TATWEEL: buf.append(", Tashkeel replace with tatweel"); break;
case TASHKEEL_REPLACE_BY_TATWEEL: buf.append(", Tashkeel replace with tatweel"); break;
case TASHKEEL_RESIZE: buf.append(", Tashkeel resize"); break;
case TASHKEEL_RESIZE: buf.append(", Tashkeel resize"); break;
}
}
switch (options & DIGITS_MASK) {
switch (options & DIGITS_MASK) {
case DIGITS_NOOP: buf.append(", no digit shaping"); break;
case DIGITS_NOOP: buf.append(", no digit shaping"); break;
case DIGITS_EN2AN: buf.append(", shape digits to AN"); break;
case DIGITS_EN2AN: buf.append(", shape digits to AN"); break;
case DIGITS_AN2EN: buf.append(", shape digits to EN"); 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_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;
case DIGITS_EN2AN_INIT_AL: buf.append(", shape digits to AN contextually: default AL"); break;
}
}
switch (options & DIGIT_TYPE_MASK) {
switch (options & DIGIT_TYPE_MASK) {
case DIGIT_TYPE_AN: buf.append(", standard Arabic-Indic digits"); break;
case DIGIT_TYPE_AN: buf.append(", standard Arabic-Indic digits"); break;
case DIGIT_TYPE_AN_EXTENDED: buf.append(", extended Arabic-Indic digits"); break;
case DIGIT_TYPE_AN_EXTENDED: buf.append(", extended Arabic-Indic digits"); break;
}
}
buf.append("]");
buf.append("]");
return buf.toString();
return buf.toString();
}
}
///CLOVER:ON
///CLOVER:ON
//
//
// ported api
// ported api
//
//
private static final int IRRELEVANT = 4;
private static final int IRRELEVANT = 4;
private static final int LAMTYPE = 16;
private static final int LAMTYPE = 16;
private static final int ALEFTYPE = 32;
private static final int ALEFTYPE = 32;
private static final int LINKR = 1;
private static final int LINKR = 1;
private static final int LINKL = 2;
private static final int LINKL = 2;
private static final int LINK_MASK = 3;
private static final int LINK_MASK = 3;
private static final int irrelevantPos[] = {
private static final int irrelevantPos[] = {
0x0, 0x2, 0x4, 0x6, 0x8, 0xA, 0xC, 0xE
0x0, 0x2, 0x4, 0x6, 0x8, 0xA, 0xC, 0xE
};
};
/*
/*
private static final char convertLamAlef[] = {
private static final char convertLamAlef[] = {
'\u0622', // FEF5
'\u0622', // FEF5
'\u0622', // FEF6
'\u0622', // FEF6
'\u0623', // FEF7
'\u0623', // FEF7
'\u0623', // FEF8
'\u0623', // FEF8
'\u0625', // FEF9
'\u0625', // FEF9
'\u0625', // FEFA
'\u0625', // FEFA
'\u0627', // FEFB
'\u0627', // FEFB
'\u0627' // FEFC
'\u0627' // FEFC
};
};
*/
*/
private static final int tailFamilyIsolatedFinal[] = {
private static final int tailFamilyIsolatedFinal[] = {
/* FEB1 */ 1,
/* FEB1 */ 1,
/* FEB2 */ 1,
/* FEB2 */ 1,
/* FEB3 */ 0,
/* FEB3 */ 0,
/* FEB4 */ 0,
/* FEB4 */ 0,
/* FEB5 */ 1,
/* FEB5 */ 1,
/* FEB6 */ 1,
/* FEB6 */ 1,
/* FEB7 */ 0,
/* FEB7 */ 0,
/* FEB8 */ 0,
/* FEB8 */ 0,
/* FEB9 */ 1,
/* FEB9 */ 1,
/* FEBA */ 1,
/* FEBA */ 1,
/* FEBB */ 0,
/* FEBB */ 0,
/* FEBC */ 0,
/* FEBC */ 0,
/* FEBD */ 1,
/* FEBD */ 1,
/* FEBE */ 1
/* FEBE */ 1
};
};
private static final int tashkeelMedial[] = {
private static final int tashkeelMedial[] = {
/* FE70 */ 0,
/* FE70 */ 0,
/* FE71 */ 1,
/* FE71 */ 1,
/* FE72 */ 0,
/* FE72 */ 0,
/* FE73 */ 0,
/* FE73 */ 0,
/* FE74 */ 0,
/* FE74 */ 0,
/* FE75 */ 0,
/* FE75 */ 0,
/* FE76 */ 0,
/* FE76 */ 0,
/* FE77 */ 1,
/* FE77 */ 1,
/* FE78 */ 0,
/* FE78 */ 0,
/* FE79 */ 1,
/* FE79 */ 1,
/* FE7A */ 0,
/* FE7A */ 0,
/* FE7B */ 1,
/* FE7B */ 1,
/* FE7C */ 0,
/* FE7C */ 0,
/* FE7D */ 1,
/* FE7D */ 1,
/* FE7E */ 0,
/* FE7E */ 0,
/* FE7F */ 1
/* FE7F */ 1
};
};
private static final char yehHamzaToYeh[] =
private static final char yehHamzaToYeh[] =
{
{
/* isolated*/ 0xFEEF,
/* isolated*/ 0xFEEF,
/* final */ 0xFEF0
/* final */ 0xFEF0
};
};
private static final char convertNormalizedLamAlef[] = {
private static final char convertNormalizedLamAlef[] = {
'\u0622', // 065C
'\u0622', // 065C
'\u0623', // 065D
'\u0623', // 065D
'\u0625', // 065E
'\u0625', // 065E
'\u0627', // 065F
'\u0627', // 065F
};
};
private static final int[] araLink = {
private static final int[] araLink = {
1 + 32 + 256 * 0x11, /*0x0622*/
1 + 32 + 256 * 0x11, /*0x0622*/
1 + 32 + 256 * 0x13, /*0x0623*/
1 + 32 + 256 * 0x13, /*0x0623*/
1 + 256 * 0x15, /*0x0624*/
1 + 256 * 0x15, /*0x0624*/
1 + 32 + 256 * 0x17, /*0x0625*/
1 + 32 + 256 * 0x17, /*0x0625*/
1 + 2 + 256 * 0x19, /*0x0626*/
1 + 2 + 256 * 0x19, /*0x0626*/
1 + 32 + 256 * 0x1D, /*0x0627*/
1 + 32 + 256 * 0x1D, /*0x0627*/
1 + 2 + 256 * 0x1F, /*0x0628*/
1 + 2 + 256 * 0x1F, /*0x0628*/
1 + 256 * 0x23, /*0x0629*/
1 + 256 * 0x23, /*0x0629*/
1 + 2 + 256 * 0x25, /*0x062A*/
1 + 2 + 256 * 0x25, /*0x062A*/
1 + 2 + 256 * 0x29, /*0x062B*/
1 + 2 + 256 * 0x29, /*0x062B*/
1 + 2 + 256 * 0x2D, /*0x062C*/
1 + 2 + 256 * 0x2D, /*0x062C*/
1 + 2 + 256 * 0x31, /*0x062D*/
1 + 2 + 256 * 0x31, /*0x062D*/
1 + 2 + 256 * 0x35, /*0x062E*/
1 + 2 + 256 * 0x35, /*0x062E*/
1 + 256 * 0x39, /*0x062F*/
1 + 256 * 0x39, /*0x062F*/
1 + 256 * 0x3B, /*0x0630*/
1 + 256 * 0x3B, /*0x0630*/
1 + 256 * 0x3D, /*0x0631*/
1 + 256 * 0x3D, /*0x0631*/
1 + 256 * 0x3F, /*0x0632*/
1 + 256 * 0x3F, /*0x0632*/
1 + 2 + 256 * 0x41, /*0x0633*/
1 + 2 + 256 * 0x41, /*0x0633*/
1 + 2 + 256 * 0x45, /*0x0634*/
1 + 2 + 256 * 0x45, /*0x0634*/
1 + 2 + 256 * 0x49, /*0x0635*/
1 + 2 + 256 * 0x49, /*0x0635*/
1 + 2 + 256 * 0x4D, /*0x0636*/
1 + 2 + 256 * 0x4D, /*0x0636*/
1 + 2 + 256 * 0x51, /*0x0637*/
1 + 2 + 256 * 0x51, /*0x0637*/
1 + 2 + 256 * 0x55, /*0x0638*/
1 + 2 + 256 * 0x55, /*0x0638*/
1 + 2 + 256 * 0x59, /*0x0639*/
1 + 2 + 256 * 0x59, /*0x0639*/
1 + 2 + 256 * 0x5D, /*0x063A*/
1 + 2 + 256 * 0x5D, /*0x063A*/
0, 0, 0, 0, 0, /*0x063B-0x063F*/
0, 0, 0, 0, 0, /*0x063B-0x063F*/
1 + 2, /*0x0640*/
1 + 2, /*0x0640*/
1 + 2 + 256 * 0x61, /*0x0641*/
1 + 2 + 256 * 0x61, /*0x0641*/
1 + 2 + 256 * 0x65, /*0x0642*/
1 + 2 + 256 * 0x65, /*0x0642*/
1 + 2 + 256 * 0x69, /*0x0643*/
1 + 2 + 256 * 0x69, /*0x0643*/
1 + 2 + 16 + 256 * 0x6D, /*0x0644*/
1 + 2 + 16 + 256 * 0x6D, /*0x0644*/
1 + 2 + 256 * 0x71, /*0x0645*/
1 + 2 + 256 * 0x71, /*0x0645*/
1 + 2 + 256 * 0x75, /*0x0646*/
1 + 2 + 256 * 0x75, /*0x0646*/
1 + 2 + 256 * 0x79, /*0x0647*/
1 + 2 + 256 * 0x79, /*0x0647*/
1 + 256 * 0x7D, /*0x0648*/
1 + 256 * 0x7D, /*0x0648*/
1 + 256 * 0x7F, /*0x0649*/
1 + 256 * 0x7F, /*0x0649*/
1 + 2 + 256 * 0x81, /*0x064A*/
1 + 2 + 256 * 0x81, /*0x064A*/
4, 4, 4, 4, /*0x064B-0x064E*/
4, 4, 4, 4, /*0x064B-0x064E*/
4, 4, 4, 4, /*0x064F-0x0652*/
4, 4, 4, 4, /*0x064F-0x0652*/
4, 4, 4, 0, 0, /*0x0653-0x0657*/
4, 4, 4, 0, 0, /*0x0653-0x0657*/
0, 0, 0, 0, /*0x0658-0x065B*/
0, 0, 0, 0, /*0x0658-0x065B*/
1 + 256 * 0x85, /*0x065C*/
1 + 256 * 0x85, /*0x065C*/
1 + 256 * 0x87, /*0x065D*/
1 + 256 * 0x87, /*0x065D*/
1 + 256 * 0x89, /*0x065E*/
1 + 256 * 0x89, /*0x065E*/
1 + 256 * 0x8B, /*0x065F*/
1 + 256 * 0x8B, /*0x065F*/
0, 0, 0, 0, 0, /*0x0660-0x0664*/
0, 0, 0, 0, 0, /*0x0660-0x0664*/
0, 0, 0, 0, 0, /*0x0665-0x0669*/
0, 0, 0, 0, 0, /*0x0665-0x0669*/
0, 0, 0, 0, 0, 0, /*0x066A-0x066F*/
0, 0, 0, 0, 0, 0, /*0x066A-0x066F*/
4, /*0x0670*/
4, /*0x0670*/
0, /*0x0671*/
1 + 32 - 256 * 0x320, /*0x0671*/
1 + 32, /*0x0672*/
1 + 32, /*0x0672*/
1 + 32, /*0x0673*/
1 + 32, /*0x0673*/
0, /*0x0674*/
0, /*0x0674*/
1 + 32, /*0x0675*/
1 + 32, /*0x0675*/
1, 1, /*0x0676-0x0677*/
1, 1, /*0x0676-0x0677*/
1+2, 1+2, 1+2, 1+2, 1+2, 1+2, /*0x0678-0x067D*/
1+2, /*0x0678*/
1+2, 1+2, 1+2, 1+2, 1+2, 1+2, /*0x067E-0x0683*/
1+2 - 256 * 0x30A, /*0x0679*/
1+2, 1+2, 1+2, 1+2, /*0x0684-0x0687*/
1+2 - 256 * 0x312, /*0x067A*/
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /*0x0688-0x0691*/
1+2 - 256 * 0x31E, /*0x067B*/
1, 1, 1, 1, 1, 1, 1, 1, /*0x0692-0x0699*/
1+2, 1+2, /*0x067C-0x067D*/
1+2, 1+2, 1+2, 1+2, 1+2, 1+2, /*0x069A-0x06A3*/
1+2 - 256 * 0x31A, /*0x067E*/
1+2, 1+2, 1+2, 1+2, /*0x069A-0x06A3*/
1+2 - 256 * 0x30E, /*0x067F*/
1+2, 1+2, 1+2, 1+2, 1+2, 1+2, /*0x06A4-0x06AD*/
1+2 - 256 * 0x316, /*0x0680*/
1+2, 1+2, 1+2, 1+2, /*0x06A4-0x06AD*/
1+2, 1+2, /*0x0681-0x0682*/
1+2, 1+2, 1+2, 1+2, 1+2, 1+2, /*0x06AE-0x06B7*/
1+2 - 256 * 0x2FA, /*0x0683*/
1+2, 1+2, 1+2, 1+2, /*0x06AE-0x06B7*/
1+2 - 256 * 0x2FE, /*0x0684*/
1+2, 1+2, 1+2, 1+2, 1+2, 1+2, /*0x06B8-0x06BF*/
1+2, /*0x685*/
1+2, 1+2, /*0x06B8-0x06BF*/
1+2 - 256 * 0x2F6, /*0x0686*/
1, /*0x06C0*/
1+2 - 256 * 0x2F2, /*0x0687*/
1+2, /*0x06C1*/
1 - 256 * 0x2E8, /*0x0688*/
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /*0x06C2-0x06CB*/
1, 1, 1, /*0x0689-068B*/
1+2, /*0x06CC*/
1 - 256 * 0x2EC, /*0x068C*/
1 - 256 * 0x2EE, /*0x068D*/
1 - 256 * 0x2EA, /*0x068E*/
1, 1, /*0x068F-0x0690*/
1 - 256 * 0x2E4, /*0x0691*/
1, 1, 1, 1, 1, 1, /*0x0692-0x697*/
1 - 256 * 0x2E6, /*0x698*/
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 * 0x306, /*0x06A4*/
1+2, /*0x06A5*/
1+2 - 256 * 0x302, /*0x06A6*/
1+2, 1+2, /*0x06A7-0x06A8*/
1+2 - 256 * 0x2E2, /*0x06A9*/
1+2, 1+2, 1+2, /*0x06AA-0x06AC*/
1+2 - 256 * 0x29D, /*0x06AD*/
1+2, /*0x06AE*/
1+2 - 256 * 0x2DE, /*0x06AF*/
1+2, /*0x06B0*/
1+2 - 256 * 0x2D6, /*0x06B1*/
1+2, /*0x06B2*/
1+2 - 256 * 0x2DA, /*0x06B3*/
1+2, 1+2, 1+2, 1+2, /*0x06B4-0x06B7*/
1+2, 1+2, /*0x06B8-0x06B9*/
1 - 256 * 0x2D2, /*0x06BA note: In UCD it is Dual joining but in Arabic PF-A there are only R glyphs*/
1+2 - 256 * 0x2D0, /*0x06BB*/
1+2, 1+2, /*0x06BC-0x06BD*/
1+2 - 256 * 0x2C6, /*0x06BE*/
1+2, /*0x06BF*/
1 - 256 * 0x2CC, /*0x06C0*/
1+2 - 256 * 0x2CA, /*0x06C1*/
1, 1, 1, /*0x06C2-0x06C4*/
1 - 256 * 0x290, /*0x06C5*/
1 - 256 * 0x297, /*0x06C6*/
1 - 256 * 0x299, /*0x06C7*/
1 - 256 * 0x295, /*0x06C8*/
1 - 256 * 0x28E, /*0x06C9*/
1, /*0x06CA*/
1 - 256 * 0x292, /*0x06CB*/
1+2 - 256 * 0x274, /*0x06CC*/
1, /*0x06CD*/
1, /*0x06CD*/
1+2, 1+2, 1+2, 1+2, /*0x06CE-0x06D1*/
1+2, 1+2, /*0x06CE-0x06CF*/
1, 1 /*0x06D2-0x06D3*/
1+2 - 256 * 0x28C, /*0x06D0*/
1+2, /*0x06D1*/
1 - 256 * 0x2C2, /*0x06D2*/
1 - 256 * 0x2C0 /*0x06D3*/
};
private static final int[] presALink = {
1 + 32, 1 + 32, /*0xFB50-0xFB51*/
1+2, 1+2, 1+2, 1+2, /*0xFB52-0xFB55*/
1+2, 1+2, 1+2, 1+2, /*0xFB56-0xFB59*/
1+2, 1+2, 1+2, 1+2, /*0xFB5A-0xFB5D*/
1+2, 1+2, 1+2, 1+2, /*0xFB5E-0xFB61*/
1+2, 1+2, 1+2, 1+2, /*0xFB62-0xFB65*/
1+2, 1+2, 1+2, 1+2, /*0xFB66-0xFB69*/
1+2, 1+2, 1+2, 1+2, /*0xFB6A-0xFB6D*/
1+2, 1+2, 1+2, 1+2, /*0xFB6E-0xFB71*/
1+2, 1+2, 1+2, 1+2, /*0xFB72-0xFB75*/
1+2, 1+2, 1+2, 1+2, /*0xFB76-0xFB79*/
1+2, 1+2, 1+2, 1+2, /*0xFB7A-0xFB7D*/
1+2, 1+2, 1+2, 1+2, /*0xFB7E-0xFB81*/
1, 1, 1, 1, 1, 1, 1, 1, /*0xFB82-0xFB89*/
1, 1, 1, 1, /*0xFB8A-0xFB8D*/
1+2, 1+2, 1+2, 1+2, /*0xFB8E-0xFB91*/
1+2, 1+2, 1+2, 1+2, /*0xFB92-0xFB95*/
1+2, 1+2, 1+2, 1+2, /*0xFB96-0xFB99*/
1+2, 1+2, 1+2, 1+2, /*0xFB9A-0xFB9D*/
1, 1, /*0xFB9E-0xFB9F*/
1+2, 1+2, 1+2, 1+2, /*0xFBA0-0xFBA3*/
1, 1, /*0xFBA4-0xFBA5*/
1+2, 1+2, 1+2, 1+2, /*0xFBA6-0xFBA9*/
1+2, 1+2, 1+2, 1+2, /*0xFBAA-0xFBAD*/
1, 1, 1, 1, /*0xFBAE-0xFBB1*/
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /*0xFBB2-0xFBBB*/
0, 0, 0, 0, 0, 0, /*0xFBBC-0xFBC1*/
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /*0xFBC2-0xFBCB*/
0, 0, 0, 0, 0, 0, 0, /*0xFBCC-0xFBD2*/
1+2, 1+2, 1+2, 1+2, /*0xFBD3-0xFBD6*/
1, 1, 1, 1, 1, 1, /*0xFBD7-0xFBDC*/
1, /*0xFBDD*/
1, 1, 1, 1, 1, 1, /*0xFBDE-0xFBE3*/
1+2, 1+2, 1+2, 1+2, /*0xFBE4-0xFBE7*/
1, 1 /*0xFBE8-0xFBE9*/
};
};
private static final int[] presLink = {
private static final int[] presBLink = {
1 + 2, /*0xFE70*/
1 + 2, /*0xFE70*/
1 + 2, /*0xFE71*/
1 + 2, /*0xFE71*/
1 + 2, 0, 1+ 2, 0, 1+ 2, /*0xFE72-0xFE76*/
1 + 2, 0, 1+ 2, 0, 1+ 2, /*0xFE72-0xFE76*/
1 + 2, /*0xFE77*/
1 + 2, /*0xFE77*/
1+ 2, 1 + 2, 1+2, 1 + 2, /*0xFE78-0xFE81*/
1+ 2, 1 + 2, 1+2, 1 + 2, /*0xFE78-0xFE81*/
1+ 2, 1 + 2, 1+2, 1 + 2, /*0xFE82-0xFE85*/
1+ 2, 1 + 2, 1+2, 1 + 2, /*0xFE82-0xFE85*/
0, 0 + 32, 1 + 32, 0 + 32, /*0xFE86-0xFE89*/
0, 0 + 32, 1 + 32, 0 + 32, /*0xFE86-0xFE89*/
1 + 32, 0, 1, 0 + 32, /*0xFE8A-0xFE8D*/
1 + 32, 0, 1, 0 + 32, /*0xFE8A-0xFE8D*/
1 + 32, 0, 2, 1 + 2, /*0xFE8E-0xFE91*/
1 + 32, 0, 2, 1 + 2, /*0xFE8E-0xFE91*/
1, 0 + 32, 1 + 32, 0, /*0xFE92-0xFE95*/
1, 0 + 32, 1 + 32, 0, /*0xFE92-0xFE95*/
2, 1 + 2, 1, 0, /*0xFE96-0xFE99*/
2, 1 + 2, 1, 0, /*0xFE96-0xFE99*/
1, 0, 2, 1 + 2, /*0xFE9A-0xFE9D*/
1, 0, 2, 1 + 2, /*0xFE9A-0xFE9D*/
1, 0, 2, 1 + 2, /*0xFE9E-0xFEA1*/
1, 0, 2, 1 + 2, /*0xFE9E-0xFEA1*/
1, 0, 2, 1 + 2, /*0xFEA2-0xFEA5*/
1, 0, 2, 1 + 2, /*0xFEA2-0xFEA5*/
1, 0, 2, 1 + 2, /*0xFEA6-0xFEA9*/
1, 0, 2, 1 + 2, /*0xFEA6-0xFEA9*/
1, 0, 2, 1 + 2, /*0xFEAA-0xFEAD*/
1, 0, 2, 1 + 2, /*0xFEAA-0xFEAD*/
1, 0, 1, 0, /*0xFEAE-0xFEB1*/
1, 0, 1, 0, /*0xFEAE-0xFEB1*/
1, 0, 1, 0, /*0xFEB2-0xFEB5*/
1, 0, 1, 0, /*0xFEB2-0xFEB5*/
1, 0, 2, 1+2, /*0xFEB6-0xFEB9*/
1, 0, 2, 1+2, /*0xFEB6-0xFEB9*/
1, 0, 2, 1+2, /*0xFEBA-0xFEBD*/
1, 0, 2, 1+2, /*0xFEBA-0xFEBD*/
1, 0, 2, 1+2, /*0xFEBE-0xFEC1*/
1, 0, 2, 1+2, /*0xFEBE-0xFEC1*/
1, 0, 2, 1+2, /*0xFEC2-0xFEC5*/
1, 0, 2, 1+2, /*0xFEC2-0xFEC5*/
1, 0, 2, 1+2, /*0xFEC6-0xFEC9*/
1, 0, 2, 1+2, /*0xFEC6-0xFEC9*/
1, 0, 2, 1+2, /*0xFECA-0xFECD*/
1, 0, 2, 1+2, /*0xFECA-0xFECD*/
1, 0, 2, 1+2, /*0xFECE-0xFED1*/
1, 0, 2, 1+2, /*0xFECE-0xFED1*/
1, 0, 2, 1+2, /*0xFED2-0xFED5*/
1, 0, 2, 1+2, /*0xFED2-0xFED5*/
1, 0, 2, 1+2, /*0xFED6-0xFED9*/
1, 0, 2, 1+2, /*0xFED6-0xFED9*/
1, 0, 2, 1+2, /*0xFEDA-0xFEDD*/
1, 0, 2, 1+2, /*0xFEDA-0xFEDD*/
1, 0, 2, 1+2, /*0xFEDE-0xFEE1*/
1, 0, 2, 1+2, /*0xFEDE-0xFEE1*/
1, 0 + 16, 2 + 16, 1 + 2 +16, /*0xFEE2-0xFEE5*/
1, 0 + 16, 2 + 16, 1 + 2 +16, /*0xFEE2-0xFEE5*/
1 + 16, 0, 2, 1+2, /*0xFEE6-0xFEE9*/
1 + 16, 0, 2, 1+2, /*0xFEE6-0xFEE9*/
1, 0, 2, 1+2, /*0xFEEA-0xFEED*/
1, 0, 2, 1+2, /*0xFEEA-0xFEED*/
1, 0, 2, 1+2, /*0xFEEE-0xFEF1*/
1, 0, 2, 1+2, /*0xFEEE-0xFEF1*/
1, 0, 1, 0, /*0xFEF2-0xFEF5*/
1, 0, 1, 0, /*0xFEF2-0xFEF5*/
1, 0, 2, 1+2, /*0xFEF6-0xFEF9*/
1, 0, 2, 1+2, /*0xFEF6-0xFEF9*/
1, 0, 1, 0, /*0xFEFA-0xFEFD*/
1, 0, 1, 0, /*0xFEFA-0xFEFD*/
1, 0, 1, 0,
1, 0, 1, 0,
1
1
};
};
private static int[] convertFEto06 = {
private static int[] convertFEto06 = {
/***********0******1******2******3******4******5******6******7******8******9******A******B******C******D******E******F***/
/***********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,
/*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,
/*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,
/*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,
/*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,
/*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,
/*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,
/*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,
/*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
/*FEF*/ 0x649, 0x64A, 0x64A, 0x64A, 0x64A, 0x65C, 0x65C, 0x65D, 0x65D, 0x65E, 0x65E, 0x65F, 0x65F
};
};
private static final int shapeTable[][][] = {
private static final int shapeTable[][][] = {
{ {0,0,0,0}, {0,0,0,0}, {0,1,0,3}, {0,1,0,1} },
{ {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,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,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} }
{ {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
* This function shapes European digits to Arabic-Indic digits
* in-place, writing over the input characters. Data is in visual
* in-place, writing over the input characters. Data is in visual
* order.
* order.
*/
*/
@SuppressWarnings("deprecation")
private void shapeToArabicDigitsWithContext(char[] dest,
private void shapeToArabicDigitsWithContext(char[] dest,
int start,
int start,
int length,
int length,
char digitBase,
char digitBase,
boolean lastStrongWasAL) {
boolean lastStrongWasAL) {
UBiDiProps bdp=UBiDiProps.INSTANCE;
UBiDiProps bdp=UBiDiProps.INSTANCE;
digitBase -= '0'; // move common adjustment out of loop
digitBase -= '0'; // move common adjustment out of loop
for(int i = start + length; --i >= start;) {
for(int i = start + length; --i >= start;) {
char ch = dest[i];
char ch = dest[i];
switch (bdp.getClass(ch)) {
switch (bdp.getClass(ch)) {
case UCharacterDirection.LEFT_TO_RIGHT:
case UCharacterDirection.LEFT_TO_RIGHT:
case UCharacterDirection.RIGHT_TO_LEFT:
case UCharacterDirection.RIGHT_TO_LEFT:
lastStrongWasAL = false;
lastStrongWasAL = false;
break;
break;
case UCharacterDirection.RIGHT_TO_LEFT_ARABIC:
case UCharacterDirection.RIGHT_TO_LEFT_ARABIC:
lastStrongWasAL = true;
lastStrongWasAL = true;
break;
break;
case UCharacterDirection.EUROPEAN_NUMBER:
case UCharacterDirection.EUROPEAN_NUMBER:
if (lastStrongWasAL && ch <= '\u0039') {
if (lastStrongWasAL && ch <= '\u0039') {
dest[i] = (char)(ch + digitBase);
dest[i] = (char)(ch + digitBase);
}
}
break;
break;
default:
default:
break;
break;
}
}
}
}
}
}
/*
/*
* Name : invertBuffer
* Name : invertBuffer
* Function: This function inverts the buffer, it's used
* Function: This function inverts the buffer, it's used
* in case the user specifies the buffer to be
* in case the user specifies the buffer to be
* TEXT_DIRECTION_LOGICAL
* TEXT_DIRECTION_LOGICAL
*/
*/
private static void invertBuffer(char[] buffer,
private static void invertBuffer(char[] buffer,
int start,
int start,
int length) {
int length) {
for(int i = start, j = start + length - 1; i < j; i++, --j) {
for(int i = start, j = start + length - 1; i < j; i++, --j) {
char temp = buffer[i];
char temp = buffer[i];
buffer[i] = buffer[j];
buffer[i] = buffer[j];
buffer[j] = temp;
buffer[j] = temp;
}
}
}
}
/*
/*
* Name : changeLamAlef
* Name : changeLamAlef
* Function: Converts the Alef characters into an equivalent
* Function: Converts the Alef characters into an equivalent
* LamAlef location in the 0x06xx Range, this is an
* LamAlef location in the 0x06xx Range, this is an
* intermediate stage in the operation of the program
* intermediate stage in the operation of the program
* later it'll be converted into the 0xFExx LamAlefs
* later it'll be converted into the 0xFExx LamAlefs
* in the shaping function.
* in the shaping function.
*/
*/
private static char changeLamAlef(char ch) {
private static char changeLamAlef(char ch) {
switch(ch) {
switch(ch) {
case '\u0622': return '\u065C';
case '\u0622': return '\u065C';
case '\u0623': return '\u065D';
case '\u0623': return '\u065D';
case '\u0625': return '\u065E';
case '\u0625': return '\u065E';
case '\u0627': return '\u065F';
case '\u0627': return '\u065F';
default: return '\u0000'; // not a lamalef
default: return '\u0000'; // not a lamalef
}
}
}
}
/*
/*
* Name : specialChar
* Name : specialChar
* Function: Special Arabic characters need special handling in the shapeUnicode
* Function: Special Arabic characters need special handling in the shapeUnicode
* function, this function returns 1 or 2 for these special characters
* function, this function returns 1 or 2 for these special characters
*/
*/
private static int specialChar(char ch) {
private static int specialChar(char ch) {
if ((ch > '\u0621' && ch < '\u0626') ||
if ((ch > '\u0621' && ch < '\u0626') ||
(ch == '\u0627') ||
(ch == '\u0627') ||
(ch > '\u062E' && ch < '\u0633') ||
(ch > '\u062E' && ch < '\u0633') ||
(ch > '\u0647' && ch < '\u064A') ||
(ch > '\u0647' && ch < '\u064A') ||
(ch == '\u0629')) {
(ch == '\u0629')) {
return 1;
return 1;
} else if (ch >= '\u064B' && ch<= '\u0652') {
} else if (ch >= '\u064B' && ch<= '\u0652') {
return 2;
return 2;
} else if (ch >= 0x0653 && ch <= 0x0655 ||
} else if (ch >= 0x0653 && ch <= 0x0655 ||
ch == 0x0670 ||
ch == 0x0670 ||
ch >= 0xFE70 && ch <= 0xFE7F) {
ch >= 0xFE70 && ch <= 0xFE7F) {
return 3;
return 3;
} else {
} else {
return 0;
return 0;
}
}
}
}
/*
/*
* Name : getLink
* Name : getLink
* Function: Resolves the link between the characters as
* Function: Resolves the link between the characters as
* Arabic characters have four forms :
* Arabic characters have four forms :
* Isolated, Initial, Middle and Final Form
* Isolated, Initial, Middle and Final Form
*/
*/
private static int getLink(char ch) {
private static int getLink(char ch) {
if (ch >= '\u0622' && ch <= '\u06D3') {
if (ch >= '\u0622' && ch <= '\u06D3') {
return araLink[ch - '\u0622'];
return araLink[ch - '\u0622'];
} else if (ch == '\u200D') {
} else if (ch == '\u200D') {
return 3;
return 3;
} else if (ch >= '\u206D' && ch <= '\u206F') {
} else if (ch >= '\u206D' && ch <= '\u206F') {
return 4;
return 4;
} else if (ch >= '\uFE70' && ch <= '\uFEFC') {
} else if (ch >= '\uFE70' && ch <= '\uFEFC') {
return presLink[ch - '\uFE70'];
return presBLink[ch - '\uFE70'];
} else if (ch >= '\uFB50' && ch <= '\uFBE9') {
return presALink[ch - '\uFB50'];
} else {
} else {
return 0;
return 0;
}
}
}
}
/*
/*
* Name : countSpaces
* Name : countSpaces
* Function: Counts the number of spaces
* Function: Counts the number of spaces
* at each end of the logical buffer
* at each end of the logical buffer
*/
*/
private static int countSpacesLeft(char[] dest,
private static int countSpacesLeft(char[] dest,
int start,
int start,
int count) {
int count) {
for (int i = start, e = start + count; i < e; ++i) {
for (int i = start, e = start + count; i < e; ++i) {
if (dest[i] != SPACE_CHAR) {
if (dest[i] != SPACE_CHAR) {
return i - start;
return i - start;
}
}
}
}
return count;
return count;
}
}
private static int countSpacesRight(char[] dest,
private static int countSpacesRight(char[] dest,
int start,
int start,
int count) {
int count) {
for (int i = start + count; --i >= start;) {
for (int i = start + count; --i >= start;) {
if (dest[i] != SPACE_CHAR) {
if (dest[i] != SPACE_CHAR) {
return start + count - 1 - i;
return start + count - 1 - i;
}
}
}
}
return count;
return count;
}
}
/*
/*
* Name : isTashkeelChar
* Name : isTashkeelChar
* Function: Returns true for Tashkeel characters else return false
* Function: Returns true for Tashkeel characters else return false
*/
*/
private static boolean isTashkeelChar(char ch) {
private static boolean isTashkeelChar(char ch) {
return ( ch >='\u064B' && ch <= '\u0652' );
return ( ch >='\u064B' && ch <= '\u0652' );
}
}
/*
/*
*Name : isSeenTailFamilyChar
*Name : isSeenTailFamilyChar
*Function : returns 1 if the character is a seen family isolated character
*Function : returns 1 if the character is a seen family isolated character
* in the FE range otherwise returns 0
* in the FE range otherwise returns 0
*/
*/
private static int isSeenTailFamilyChar(char ch) {
private static int isSeenTailFamilyChar(char ch) {
if (ch >= 0xfeb1 && ch < 0xfebf){
if (ch >= 0xfeb1 && ch < 0xfebf){
return tailFamilyIsolatedFinal [ch - 0xFEB1];
return tailFamilyIsolatedFinal [ch - 0xFEB1];
} else {
} else {
return 0;
return 0;
}
}
}
}
/* Name : isSeenFamilyChar
/* Name : isSeenFamilyChar
* Function : returns 1 if the character is a seen family character in the Unicode
* Function : returns 1 if the character is a seen family character in the Unicode
* 06 range otherwise returns 0
* 06 range otherwise returns 0
*/
*/
private static int isSeenFamilyChar(char ch){
private static int isSeenFamilyChar(char ch){
if (ch >= 0x633 && ch <= 0x636){
if (ch >= 0x633 && ch <= 0x636){
return 1;
return 1;
}else {
}else {
return 0;
return 0;
}
}
}
}
/*
/*
*Name : isTailChar
*Name : isTailChar
*Function : returns true if the character matches one of the tail characters
*Function : returns true if the character matches one of the tail characters
* (0xfe73 or 0x200b) otherwise returns false
* (0xfe73 or 0x200b) otherwise returns false
*/
*/
private static boolean isTailChar(char ch) {
private static boolean isTailChar(char ch) {
if(ch == OLD_TAIL_CHAR || ch == NEW_TAIL_CHAR){
if(ch == OLD_TAIL_CHAR || ch == NEW_TAIL_CHAR){
return true;
return true;
}else{
}else{
return false;
return false;
}
}
}
}
/*
/*
*Name : isAlefMaksouraChar
*Name : isAlefMaksouraChar
*Function : returns true if the character is a Alef Maksoura Final or isolated
*Function : returns true if the character is a Alef Maksoura Final or isolated
* otherwise returns false
* otherwise returns false
*/
*/
private static boolean isAlefMaksouraChar(char ch) {
private static boolean isAlefMaksouraChar(char ch) {
return ( (ch == 0xFEEF) || ( ch == 0xFEF0) || (ch == 0x0649));
return ( (ch == 0xFEEF) || ( ch == 0xFEF0) || (ch == 0x0649));
}
}
/*
/*
* Name : isYehHamzaChar
* Name : isYehHamzaChar
* Function : returns true if the character is a yehHamza isolated or yehhamza
* Function : returns true if the character is a yehHamza isolated or yehhamza
* final is found otherwise returns false
* final is found otherwise returns false
*/
*/
private static boolean isYehHamzaChar(char ch) {
private static boolean isYehHamzaChar(char ch) {
if((ch==0xFE89)||(ch==0xFE8A)){
if((ch==0xFE89)||(ch==0xFE8A)){
return true;
return true;
}else{
}else{
return false;
return false;
}
}
}
}
/*
/*
*Name : isTashkeelCharFE
*Name : isTashkeelCharFE
*Function : Returns true for Tashkeel characters in FE range else return false
*Function : Returns true for Tashkeel characters in FE range else return false
*/
*/
private static boolean isTashkeelCharFE(char ch) {
private static boolean isTashkeelCharFE(char ch) {
return ( ch!=0xFE75 &&(ch>=0xFE70 && ch<= 0xFE7F) );
return ( ch!=0xFE75 &&(ch>=0xFE70 && ch<= 0xFE7F) );
}
}
/*
/*
* Name: isTashkeelOnTatweelChar
* Name: isTashkeelOnTatweelChar
* Function: Checks if the Tashkeel Character is on Tatweel or not,if the
* 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 on tatweel (FE range), it returns 1 else if the
* Tashkeel with shadda on tatweel (FC range)return 2 otherwise
* Tashkeel with shadda on tatweel (FC range)return 2 otherwise
* returns 0
* returns 0
*/
*/
private static int isTashkeelOnTatweelChar(char ch){
private static int isTashkeelOnTatweelChar(char ch){
if (ch >= 0xfe70 && ch <= 0xfe7f && ch != NEW_TAIL_CHAR && ch != 0xFE75 && ch != SHADDA_TATWEEL_CHAR)
if (ch >= 0xfe70 && ch <= 0xfe7f && ch != NEW_TAIL_CHAR && ch != 0xFE75 && ch != SHADDA_TATWEEL_CHAR)
{
{
return tashkeelMedial [ch - 0xFE70];
return tashkeelMedial [ch - 0xFE70];
} else if( (ch >= 0xfcf2 && ch <= 0xfcf4) || (ch == SHADDA_TATWEEL_CHAR)) {
} else if( (ch >= 0xfcf2 && ch <= 0xfcf4) || (ch == SHADDA_TATWEEL_CHAR)) {
return 2;
return 2;
} else {
} else {
return 0;
return 0;
}
}
}
}
/*
/*
* Name: isIsolatedTashkeelChar
* Name: isIsolatedTashkeelChar
* Function: Checks if the Tashkeel Character is in the isolated form
* Function: Checks if the Tashkeel Character is in the isolated form
* (i.e. Unicode FE range) returns 1 else if the Tashkeel
* (i.e. Unicode FE range) returns 1 else if the Tashkeel
* with shadda is in the isolated form (i.e. Unicode FC range)
* with shadda is in the isolated form (i.e. Unicode FC range)
* returns 1 otherwise returns 0
* returns 1 otherwise returns 0
*/
*/
private static int isIsolatedTashkeelChar(char ch){
private static int isIsolatedTashkeelChar(char ch){
if (ch >= 0xfe70 && ch <= 0xfe7f && ch != NEW_TAIL_CHAR && ch != 0xFE75){
if (ch >= 0xfe70 && ch <= 0xfe7f && ch != NEW_TAIL_CHAR && ch != 0xFE75){
return (1 - tashkeelMedial [ch - 0xFE70]);
return (1 - tashkeelMedial [ch - 0xFE70]);