+ *
+ * Note: Libraries that perform a bidirectional algorithm and reorder strings
+ * accordingly are sometimes called "Storage Layout Engines". ICU's Bidi and
+ * shaping (ArabicShaping) classes can be used at the core of such "Storage
+ * Layout Engines".
+ *
+ *
+ *
+ * Some of the API methods provide access to "runs". Such a
+ * "run" is defined as a sequence of characters that are at the same
+ * embedding level after performing the Bidi algorithm.
+ *
+ *
+ * Constant indicating that the base direction depends on the first strong
+ * directional character in the text according to the Unicode Bidirectional
+ * Algorithm. If no strong directional character is present,
+ * then set the paragraph level to 0 (left-to-right).
+ *
+ * If this value is used in conjunction with reordering modes
+ * REORDER_INVERSE_LIKE_DIRECT or
+ * REORDER_INVERSE_FOR_NUMBERS_SPECIAL, the text to reorder
+ * is assumed to be visual LTR, and the text after reordering is required
+ * to be the corresponding logical string with appropriate contextual
+ * direction. The direction of the result string will be RTL if either
+ * the righmost or leftmost strong character of the source text is RTL
+ * or Arabic Letter, the direction will be LTR otherwise.
+ *
+ * Constant indicating that the base direction depends on the first strong
+ * directional character in the text according to the Unicode Bidirectional
+ * Algorithm. If no strong directional character is present,
+ * then set the paragraph level to 1 (right-to-left).
+ *
+ * If this value is used in conjunction with reordering modes
+ * REORDER_INVERSE_LIKE_DIRECT or
+ * REORDER_INVERSE_FOR_NUMBERS_SPECIAL, the text to reorder
+ * is assumed to be visual LTR, and the text after reordering is required
+ * to be the corresponding logical string with appropriate contextual
+ * direction. The direction of the result string will be RTL if either
+ * the righmost or leftmost strong character of the source text is RTL
+ * or Arabic Letter, or if the text contains no strong character;
+ * the direction will be LTR otherwise.
This option is significant only with reordering modes which generate
+ * a result with Logical order, specifically.
+ * For other reordering modes, a minimum number of LRM or RLM characters
+ * will be added to the source text after reordering it so as to ensure
+ * round trip, i.e. when applying the inverse reordering mode on the
+ * resulting logical text with removal of Bidi marks
+ * (option OPTION_REMOVE_CONTROLS set before calling
+ * setPara() or option
+ * REMOVE_BIDI_CONTROLS in
+ * writeReordered), the result will be identical to the
+ * source text in the first transformation.
+ *
+ *
This option specifies that the caller is interested in processing
+ * large text object in parts. The results of the successive calls are
+ * expected to be concatenated by the caller. Only the call for the last
+ * part will have this option bit off.
+ *
+ * >CONTEXT_RTL_SHIFT) : paraLevel;
+ }
+
+ static boolean IsBidiControlChar(int c)
+ {
+ /* check for range 0x200c to 0x200f (ZWNJ, ZWJ, LRM, RLM) or
+ 0x202a to 0x202e (LRE, RLE, PDF, LRO, RLO) */
+ return (((c & 0xfffffffc) == 0x200c) || ((c >= 0x202a) && (c <= 0x202e)));
+ }
+
+ public void verifyValidPara()
+ {
+ if (this != this.paraBidi) {
+ throw new IllegalStateException("");
+ }
+ }
+
+ public void verifyValidParaOrLine()
+ {
+ BidiBase para = this.paraBidi;
+ /* verify Para */
+ if (this == para) {
+ return;
+ }
+ /* verify Line */
+ if ((para == null) || (para != para.paraBidi)) {
+ throw new IllegalStateException();
+ }
+ }
+
+ public void verifyRange(int index, int start, int limit)
+ {
+ if (index < start || index >= limit) {
+ throw new IllegalArgumentException("Value " + index +
+ " is out of range " + start + " to " + limit);
+ }
+ }
+
+ public void verifyIndex(int index, int start, int limit)
+ {
+ if (index < start || index >= limit) {
+ throw new ArrayIndexOutOfBoundsException("Index " + index +
+ " is out of range " + start + " to " + limit);
+ }
+ }
+
+ /**
+ * Allocate a Bidi object with preallocated memory
+ * for internal structures.
+ * This method provides a Bidi object like the default constructor
+ * but it also preallocates memory for internal structures
+ * according to the sizings supplied by the caller.
+ * The preallocation can be limited to some of the internal memory
+ * by setting some values to 0 here. That means that if, e.g.,
+ * maxRunCount cannot be reasonably predetermined and should not
+ * be set to maxLength (the only failproof value) to avoid
+ * wasting memory, then maxRunCount could be set to 0 here
+ * and the internal structures that are associated with it will be allocated
+ * on demand, just like with the default constructor.
+ *
+ * @param maxLength is the maximum text or line length that internal memory
+ * will be preallocated for. An attempt to associate this object with a
+ * longer text will fail, unless this value is 0, which leaves the allocation
+ * up to the implementation.
+ *
+ * @param maxRunCount is the maximum anticipated number of same-level runs
+ * that internal memory will be preallocated for. An attempt to access
+ * visual runs on an object that was not preallocated for as many runs
+ * as the text was actually resolved to will fail,
+ * unless this value is 0, which leaves the allocation up to the implementation.
+ * The number of runs depends on the actual text and maybe anywhere between
+ * 1 and maxLength. It is typically small.
+ *
+ * @throws IllegalArgumentException if maxLength or maxRunCount is less than 0
+ * @stable ICU 3.8
+ */
+ public BidiBase(int maxLength, int maxRunCount)
+ {
+ /* check the argument values */
+ if (maxLength < 0 || maxRunCount < 0) {
+ throw new IllegalArgumentException();
+ }
+
+ /* reset the object, all reference variables null, all flags false,
+ all sizes 0.
+ In fact, we don't need to do anything, since class members are
+ initialized as zero when an instance is created.
+ */
+ /*
+ mayAllocateText = false;
+ mayAllocateRuns = false;
+ orderParagraphsLTR = false;
+ paraCount = 0;
+ runCount = 0;
+ trailingWSStart = 0;
+ flags = 0;
+ paraLevel = 0;
+ defaultParaLevel = 0;
+ direction = 0;
+ */
+ /* get Bidi properties */
+ try {
+ bdp = UBiDiProps.getSingleton();
+ }
+ catch (IOException e) {
+ throw new MissingResourceException(e.getMessage(), "(BidiProps)", "");
+ }
+
+ /* allocate memory for arrays as requested */
+ if (maxLength > 0) {
+ getInitialDirPropsMemory(maxLength);
+ getInitialLevelsMemory(maxLength);
+ } else {
+ mayAllocateText = true;
+ }
+
+ if (maxRunCount > 0) {
+ // if maxRunCount == 1, use simpleRuns[]
+ if (maxRunCount > 1) {
+ getInitialRunsMemory(maxRunCount);
+ }
+ } else {
+ mayAllocateRuns = true;
+ }
+ }
+
+ /*
+ * We are allowed to allocate memory if object==null or
+ * mayAllocate==true for each array that we need.
+ *
+ * Assume sizeNeeded>0.
+ * If object != null, then assume size > 0.
+ */
+ private Object getMemory(String label, Object array, Class arrayClass,
+ boolean mayAllocate, int sizeNeeded)
+ {
+ int len = Array.getLength(array);
+
+ /* we have at least enough memory and must not allocate */
+ if (sizeNeeded == len) {
+ return array;
+ }
+ if (!mayAllocate) {
+ /* we must not allocate */
+ if (sizeNeeded <= len) {
+ return array;
+ }
+ throw new OutOfMemoryError("Failed to allocate memory for "
+ + label);
+ }
+ /* we may try to grow or shrink */
+ /* FOOD FOR THOUGHT: when shrinking it should be possible to avoid
+ the allocation altogether and rely on this.length */
+ try {
+ return Array.newInstance(arrayClass, sizeNeeded);
+ } catch (Exception e) {
+ throw new OutOfMemoryError("Failed to allocate memory for "
+ + label);
+ }
+ }
+
+ /* helper methods for each allocated array */
+ private void getDirPropsMemory(boolean mayAllocate, int len)
+ {
+ Object array = getMemory("DirProps", dirPropsMemory, Byte.TYPE, mayAllocate, len);
+ dirPropsMemory = (byte[]) array;
+ }
+
+ void getDirPropsMemory(int len)
+ {
+ getDirPropsMemory(mayAllocateText, len);
+ }
+
+ private void getLevelsMemory(boolean mayAllocate, int len)
+ {
+ Object array = getMemory("Levels", levelsMemory, Byte.TYPE, mayAllocate, len);
+ levelsMemory = (byte[]) array;
+ }
+
+ void getLevelsMemory(int len)
+ {
+ getLevelsMemory(mayAllocateText, len);
+ }
+
+ private void getRunsMemory(boolean mayAllocate, int len)
+ {
+ Object array = getMemory("Runs", runsMemory, BidiRun.class, mayAllocate, len);
+ runsMemory = (BidiRun[]) array;
+ }
+
+ void getRunsMemory(int len)
+ {
+ getRunsMemory(mayAllocateRuns, len);
+ }
+
+ /* additional methods used by constructor - always allow allocation */
+ private void getInitialDirPropsMemory(int len)
+ {
+ getDirPropsMemory(true, len);
+ }
+
+ private void getInitialLevelsMemory(int len)
+ {
+ getLevelsMemory(true, len);
+ }
+
+ private void getInitialParasMemory(int len)
+ {
+ Object array = getMemory("Paras", parasMemory, Integer.TYPE, true, len);
+ parasMemory = (int[]) array;
+ }
+
+ private void getInitialRunsMemory(int len)
+ {
+ getRunsMemory(true, len);
+ }
+
+/* perform (P2)..(P3) ------------------------------------------------------- */
+
+ private void getDirProps()
+ {
+ int i = 0, i0, i1;
+ flags = 0; /* collect all directionalities in the text */
+ int uchar;
+ byte dirProp;
+ byte paraDirDefault = 0; /* initialize to avoid compiler warnings */
+ boolean isDefaultLevel = IsDefaultLevel(paraLevel);
+ /* for inverse Bidi, the default para level is set to RTL if there is a
+ strong R or AL character at either end of the text */
+ lastArabicPos = -1;
+ controlCount = 0;
+
+ final int NOT_CONTEXTUAL = 0; /* 0: not contextual paraLevel */
+ final int LOOKING_FOR_STRONG = 1; /* 1: looking for first strong char */
+ final int FOUND_STRONG_CHAR = 2; /* 2: found first strong char */
+
+ int state;
+ int paraStart = 0; /* index of first char in paragraph */
+ byte paraDir; /* == CONTEXT_RTL within paragraphs
+ starting with strong R char */
+ byte lastStrongDir=0; /* for default level & inverse Bidi */
+ int lastStrongLTR=0; /* for STREAMING option */
+
+ if (isDefaultLevel) {
+ paraDirDefault = ((paraLevel & 1) != 0) ? CONTEXT_RTL : 0;
+ paraDir = paraDirDefault;
+ lastStrongDir = paraDirDefault;
+ state = LOOKING_FOR_STRONG;
+ } else {
+ state = NOT_CONTEXTUAL;
+ paraDir = 0;
+ }
+ /* count paragraphs and determine the paragraph level (P2..P3) */
+ /*
+ * see comment on constant fields:
+ * the LEVEL_DEFAULT_XXX values are designed so that
+ * their low-order bit alone yields the intended default
+ */
+
+ for (i = 0; i < originalLength; /* i is incremented in the loop */) {
+ i0 = i; /* index of first code unit */
+ uchar = UTF16.charAt(text, 0, originalLength, i);
+ i += Character.charCount(uchar);
+ i1 = i - 1; /* index of last code unit, gets the directional property */
+
+ dirProp = (byte)bdp.getClass(uchar);
+
+ flags |= DirPropFlag(dirProp);
+ dirProps[i1] = (byte)(dirProp | paraDir);
+ if (i1 > i0) { /* set previous code units' properties to BN */
+ flags |= DirPropFlag(BN);
+ do {
+ dirProps[--i1] = (byte)(BN | paraDir);
+ } while (i1 > i0);
+ }
+ if (state == LOOKING_FOR_STRONG) {
+ if (dirProp == L) {
+ state = FOUND_STRONG_CHAR;
+ if (paraDir != 0) {
+ paraDir = 0;
+ for (i1 = paraStart; i1 < i; i1++) {
+ dirProps[i1] &= ~CONTEXT_RTL;
+ }
+ }
+ continue;
+ }
+ if (dirProp == R || dirProp == AL) {
+ state = FOUND_STRONG_CHAR;
+ if (paraDir == 0) {
+ paraDir = CONTEXT_RTL;
+ for (i1 = paraStart; i1 < i; i1++) {
+ dirProps[i1] |= CONTEXT_RTL;
+ }
+ }
+ continue;
+ }
+ }
+ if (dirProp == L) {
+ lastStrongDir = 0;
+ lastStrongLTR = i; /* i is index to next character */
+ }
+ else if (dirProp == R) {
+ lastStrongDir = CONTEXT_RTL;
+ }
+ else if (dirProp == AL) {
+ lastStrongDir = CONTEXT_RTL;
+ lastArabicPos = i-1;
+ }
+ else if (dirProp == B) {
+ if (i < originalLength) { /* B not last char in text */
+ if (!((uchar == (int)CR) && (text[i] == (int)LF))) {
+ paraCount++;
+ }
+ if (isDefaultLevel) {
+ state=LOOKING_FOR_STRONG;
+ paraStart = i; /* i is index to next character */
+ paraDir = paraDirDefault;
+ lastStrongDir = paraDirDefault;
+ }
+ }
+ }
+ }
+ if (isDefaultLevel) {
+ paraLevel = GetParaLevelAt(0);
+ }
+
+ /* The following line does nothing new for contextual paraLevel, but is
+ needed for absolute paraLevel. */
+ flags |= DirPropFlagLR(paraLevel);
+
+ if (orderParagraphsLTR && (flags & DirPropFlag(B)) != 0) {
+ flags |= DirPropFlag(L);
+ }
+ }
+
+ /* perform (X1)..(X9) ------------------------------------------------------- */
+
+ /* determine if the text is mixed-directional or single-directional */
+ private byte directionFromFlags() {
+ /* if the text contains AN and neutrals, then some neutrals may become RTL */
+ if (!((flags & MASK_RTL) != 0 ||
+ ((flags & DirPropFlag(AN)) != 0 &&
+ (flags & MASK_POSSIBLE_N) != 0))) {
+ return Bidi.DIRECTION_LEFT_TO_RIGHT;
+ } else if ((flags & MASK_LTR) == 0) {
+ return Bidi.DIRECTION_RIGHT_TO_LEFT;
+ } else {
+ return MIXED;
+ }
+ }
+
+ /*
+ * Resolve the explicit levels as specified by explicit embedding codes.
+ * Recalculate the flags to have them reflect the real properties
+ * after taking the explicit embeddings into account.
+ *
+ * The Bidi algorithm is designed to result in the same behavior whether embedding
+ * levels are externally specified (from "styled text", supposedly the preferred
+ * method) or set by explicit embedding codes (LRx, RLx, PDF) in the plain text.
+ * That is why (X9) instructs to remove all explicit codes (and BN).
+ * However, in a real implementation, this removal of these codes and their index
+ * positions in the plain text is undesirable since it would result in
+ * reallocated, reindexed text.
+ * Instead, this implementation leaves the codes in there and just ignores them
+ * in the subsequent processing.
+ * In order to get the same reordering behavior, positions with a BN or an
+ * explicit embedding code just get the same level assigned as the last "real"
+ * character.
+ *
+ * Some implementations, not this one, then overwrite some of these
+ * directionality properties at "real" same-level-run boundaries by
+ * L or R codes so that the resolution of weak types can be performed on the
+ * entire paragraph at once instead of having to parse it once more and
+ * perform that resolution on same-level-runs.
+ * This limits the scope of the implicit rules in effectively
+ * the same way as the run limits.
+ *
+ * Instead, this implementation does not modify these codes.
+ * On one hand, the paragraph has to be scanned for same-level-runs, but
+ * on the other hand, this saves another loop to reset these codes,
+ * or saves making and modifying a copy of dirProps[].
+ *
+ *
+ * Note that (Pn) and (Xn) changed significantly from version 4 of the Bidi algorithm.
+ *
+ *
+ * Handling the stack of explicit levels (Xn):
+ *
+ * With the Bidi stack of explicit levels,
+ * as pushed with each LRE, RLE, LRO, and RLO and popped with each PDF,
+ * the explicit level must never exceed MAX_EXPLICIT_LEVEL==61.
+ *
+ * In order to have a correct push-pop semantics even in the case of overflows,
+ * there are two overflow counters:
+ * - countOver60 is incremented with each LRx at level 60
+ * - from level 60, one RLx increases the level to 61
+ * - countOver61 is incremented with each LRx and RLx at level 61
+ *
+ * Popping levels with PDF must work in the opposite order so that level 61
+ * is correct at the correct point. Underflows (too many PDFs) must be checked.
+ *
+ * This implementation assumes that MAX_EXPLICIT_LEVEL is odd.
+ */
+ private byte resolveExplicitLevels() {
+ int i = 0;
+ byte dirProp;
+ byte level = GetParaLevelAt(0);
+
+ byte dirct;
+ int paraIndex = 0;
+
+ /* determine if the text is mixed-directional or single-directional */
+ dirct = directionFromFlags();
+
+ /* we may not need to resolve any explicit levels, but for multiple
+ paragraphs we want to loop on all chars to set the para boundaries */
+ if ((dirct != MIXED) && (paraCount == 1)) {
+ /* not mixed directionality: levels don't matter - trailingWSStart will be 0 */
+ } else if ((paraCount == 1) &&
+ ((flags & MASK_EXPLICIT) == 0)) {
+ /* mixed, but all characters are at the same embedding level */
+ /* or we are in "inverse Bidi" */
+ /* and we don't have contextual multiple paragraphs with some B char */
+ /* set all levels to the paragraph level */
+ for (i = 0; i < length; ++i) {
+ levels[i] = level;
+ }
+ } else {
+ /* continue to perform (Xn) */
+
+ /* (X1) level is set for all codes, embeddingLevel keeps track of the push/pop operations */
+ /* both variables may carry the LEVEL_OVERRIDE flag to indicate the override status */
+ byte embeddingLevel = level;
+ byte newLevel;
+ byte stackTop = 0;
+
+ byte[] stack = new byte[MAX_EXPLICIT_LEVEL]; /* we never push anything >=MAX_EXPLICIT_LEVEL */
+ int countOver60 = 0;
+ int countOver61 = 0; /* count overflows of explicit levels */
+
+ /* recalculate the flags */
+ flags = 0;
+
+ for (i = 0; i < length; ++i) {
+ dirProp = NoContextRTL(dirProps[i]);
+ switch(dirProp) {
+ case LRE:
+ case LRO:
+ /* (X3, X5) */
+ newLevel = (byte)((embeddingLevel+2) & ~(INTERNAL_LEVEL_OVERRIDE | 1)); /* least greater even level */
+ if (newLevel <= MAX_EXPLICIT_LEVEL) {
+ stack[stackTop] = embeddingLevel;
+ ++stackTop;
+ embeddingLevel = newLevel;
+ if (dirProp == LRO) {
+ embeddingLevel |= INTERNAL_LEVEL_OVERRIDE;
+ }
+ /* we don't need to set LEVEL_OVERRIDE off for LRE
+ since this has already been done for newLevel which is
+ the source for embeddingLevel.
+ */
+ } else if ((embeddingLevel & ~INTERNAL_LEVEL_OVERRIDE) == MAX_EXPLICIT_LEVEL) {
+ ++countOver61;
+ } else /* (embeddingLevel & ~INTERNAL_LEVEL_OVERRIDE) == MAX_EXPLICIT_LEVEL-1 */ {
+ ++countOver60;
+ }
+ flags |= DirPropFlag(BN);
+ break;
+ case RLE:
+ case RLO:
+ /* (X2, X4) */
+ newLevel=(byte)(((embeddingLevel & ~INTERNAL_LEVEL_OVERRIDE) + 1) | 1); /* least greater odd level */
+ if (newLevel<=MAX_EXPLICIT_LEVEL) {
+ stack[stackTop] = embeddingLevel;
+ ++stackTop;
+ embeddingLevel = newLevel;
+ if (dirProp == RLO) {
+ embeddingLevel |= INTERNAL_LEVEL_OVERRIDE;
+ }
+ /* we don't need to set LEVEL_OVERRIDE off for RLE
+ since this has already been done for newLevel which is
+ the source for embeddingLevel.
+ */
+ } else {
+ ++countOver61;
+ }
+ flags |= DirPropFlag(BN);
+ break;
+ case PDF:
+ /* (X7) */
+ /* handle all the overflow cases first */
+ if (countOver61 > 0) {
+ --countOver61;
+ } else if (countOver60 > 0 && (embeddingLevel & ~INTERNAL_LEVEL_OVERRIDE) != MAX_EXPLICIT_LEVEL) {
+ /* handle LRx overflows from level 60 */
+ --countOver60;
+ } else if (stackTop > 0) {
+ /* this is the pop operation; it also pops level 61 while countOver60>0 */
+ --stackTop;
+ embeddingLevel = stack[stackTop];
+ /* } else { (underflow) */
+ }
+ flags |= DirPropFlag(BN);
+ break;
+ case B:
+ stackTop = 0;
+ countOver60 = 0;
+ countOver61 = 0;
+ level = GetParaLevelAt(i);
+ if ((i + 1) < length) {
+ embeddingLevel = GetParaLevelAt(i+1);
+ if (!((text[i] == CR) && (text[i + 1] == LF))) {
+ paras[paraIndex++] = i+1;
+ }
+ }
+ flags |= DirPropFlag(B);
+ break;
+ case BN:
+ /* BN, LRE, RLE, and PDF are supposed to be removed (X9) */
+ /* they will get their levels set correctly in adjustWSLevels() */
+ flags |= DirPropFlag(BN);
+ break;
+ default:
+ /* all other types get the "real" level */
+ if (level != embeddingLevel) {
+ level = embeddingLevel;
+ if ((level & INTERNAL_LEVEL_OVERRIDE) != 0) {
+ flags |= DirPropFlagO(level) | DirPropFlagMultiRuns;
+ } else {
+ flags |= DirPropFlagE(level) | DirPropFlagMultiRuns;
+ }
+ }
+ if ((level & INTERNAL_LEVEL_OVERRIDE) == 0) {
+ flags |= DirPropFlag(dirProp);
+ }
+ break;
+ }
+
+ /*
+ * We need to set reasonable levels even on BN codes and
+ * explicit codes because we will later look at same-level runs (X10).
+ */
+ levels[i] = level;
+ }
+ if ((flags & MASK_EMBEDDING) != 0) {
+ flags |= DirPropFlagLR(paraLevel);
+ }
+ if (orderParagraphsLTR && (flags & DirPropFlag(B)) != 0) {
+ flags |= DirPropFlag(L);
+ }
+
+ /* subsequently, ignore the explicit codes and BN (X9) */
+
+ /* again, determine if the text is mixed-directional or single-directional */
+ dirct = directionFromFlags();
+ }
+
+ return dirct;
+ }
+
+ /*
+ * Use a pre-specified embedding levels array:
+ *
+ * Adjust the directional properties for overrides (->LEVEL_OVERRIDE),
+ * ignore all explicit codes (X9),
+ * and check all the preset levels.
+ *
+ * Recalculate the flags to have them reflect the real properties
+ * after taking the explicit embeddings into account.
+ */
+ private byte checkExplicitLevels() {
+ byte dirProp;
+ int i;
+ this.flags = 0; /* collect all directionalities in the text */
+ byte level;
+ int paraIndex = 0;
+
+ for (i = 0; i < length; ++i) {
+ if (levels[i] == 0) {
+ levels[i] = paraLevel;
+ }
+ if (MAX_EXPLICIT_LEVEL < (levels[i]&0x7f)) {
+ if ((levels[i] & INTERNAL_LEVEL_OVERRIDE) != 0) {
+ levels[i] = (byte)(paraLevel|INTERNAL_LEVEL_OVERRIDE);
+ } else {
+ levels[i] = paraLevel;
+ }
+ }
+ level = levels[i];
+ dirProp = NoContextRTL(dirProps[i]);
+ if ((level & INTERNAL_LEVEL_OVERRIDE) != 0) {
+ /* keep the override flag in levels[i] but adjust the flags */
+ level &= ~INTERNAL_LEVEL_OVERRIDE; /* make the range check below simpler */
+ flags |= DirPropFlagO(level);
+ } else {
+ /* set the flags */
+ flags |= DirPropFlagE(level) | DirPropFlag(dirProp);
+ }
+
+ if ((level < GetParaLevelAt(i) &&
+ !((0 == level) && (dirProp == B))) ||
+ (MAX_EXPLICIT_LEVEL 0) */
+ /* */
+ /* Cells may be of format "n" where n represents the next state */
+ /* (except for the rightmost column). */
+ /* Cells may also be of format "_(x,y)" where x represents an action */
+ /* to perform and y represents the next state. */
+ /* */
+ /*********************************************************************/
+ /* Definitions and type for properties state tables */
+ /*********************************************************************/
+ private static final int IMPTABPROPS_COLUMNS = 14;
+ private static final int IMPTABPROPS_RES = IMPTABPROPS_COLUMNS - 1;
+ private static short GetStateProps(short cell) {
+ return (short)(cell & 0x1f);
+ }
+ private static short GetActionProps(short cell) {
+ return (short)(cell >> 5);
+ }
+
+ private static final short groupProp[] = /* dirProp regrouped */
+ {
+ /* L R EN ES ET AN CS B S WS ON LRE LRO AL RLE RLO PDF NSM BN */
+ 0, 1, 2, 7, 8, 3, 9, 6, 5, 4, 4, 10, 10, 12, 10, 10, 10, 11, 10
+ };
+ private static final short _L = 0;
+ private static final short _R = 1;
+ private static final short _EN = 2;
+ private static final short _AN = 3;
+ private static final short _ON = 4;
+ private static final short _S = 5;
+ private static final short _B = 6; /* reduced dirProp */
+
+ /*********************************************************************/
+ /* */
+ /* PROPERTIES STATE TABLE */
+ /* */
+ /* In table impTabProps, */
+ /* - the ON column regroups ON and WS */
+ /* - the BN column regroups BN, LRE, RLE, LRO, RLO, PDF */
+ /* - the Res column is the reduced property assigned to a run */
+ /* */
+ /* Action 1: process current run1, init new run1 */
+ /* 2: init new run2 */
+ /* 3: process run1, process run2, init new run1 */
+ /* 4: process run1, set run1=run2, init new run2 */
+ /* */
+ /* Notes: */
+ /* 1) This table is used in resolveImplicitLevels(). */
+ /* 2) This table triggers actions when there is a change in the Bidi*/
+ /* property of incoming characters (action 1). */
+ /* 3) Most such property sequences are processed immediately (in */
+ /* fact, passed to processPropertySeq(). */
+ /* 4) However, numbers are assembled as one sequence. This means */
+ /* that undefined situations (like CS following digits, until */
+ /* it is known if the next char will be a digit) are held until */
+ /* following chars define them. */
+ /* Example: digits followed by CS, then comes another CS or ON; */
+ /* the digits will be processed, then the CS assigned */
+ /* as the start of an ON sequence (action 3). */
+ /* 5) There are cases where more than one sequence must be */
+ /* processed, for instance digits followed by CS followed by L: */
+ /* the digits must be processed as one sequence, and the CS */
+ /* must be processed as an ON sequence, all this before starting */
+ /* assembling chars for the opening L sequence. */
+ /* */
+ /* */
+ private static final short impTabProps[][] =
+ {
+/* L, R, EN, AN, ON, S, B, ES, ET, CS, BN, NSM, AL, Res */
+/* 0 Init */ { 1, 2, 4, 5, 7, 15, 17, 7, 9, 7, 0, 7, 3, _ON },
+/* 1 L */ { 1, 32+2, 32+4, 32+5, 32+7, 32+15, 32+17, 32+7, 32+9, 32+7, 1, 1, 32+3, _L },
+/* 2 R */ { 32+1, 2, 32+4, 32+5, 32+7, 32+15, 32+17, 32+7, 32+9, 32+7, 2, 2, 32+3, _R },
+/* 3 AL */ { 32+1, 32+2, 32+6, 32+6, 32+8, 32+16, 32+17, 32+8, 32+8, 32+8, 3, 3, 3, _R },
+/* 4 EN */ { 32+1, 32+2, 4, 32+5, 32+7, 32+15, 32+17, 64+10, 11, 64+10, 4, 4, 32+3, _EN },
+/* 5 AN */ { 32+1, 32+2, 32+4, 5, 32+7, 32+15, 32+17, 32+7, 32+9, 64+12, 5, 5, 32+3, _AN },
+/* 6 AL:EN/AN */ { 32+1, 32+2, 6, 6, 32+8, 32+16, 32+17, 32+8, 32+8, 64+13, 6, 6, 32+3, _AN },
+/* 7 ON */ { 32+1, 32+2, 32+4, 32+5, 7, 32+15, 32+17, 7, 64+14, 7, 7, 7, 32+3, _ON },
+/* 8 AL:ON */ { 32+1, 32+2, 32+6, 32+6, 8, 32+16, 32+17, 8, 8, 8, 8, 8, 32+3, _ON },
+/* 9 ET */ { 32+1, 32+2, 4, 32+5, 7, 32+15, 32+17, 7, 9, 7, 9, 9, 32+3, _ON },
+/*10 EN+ES/CS */ { 96+1, 96+2, 4, 96+5, 128+7, 96+15, 96+17, 128+7,128+14, 128+7, 10, 128+7, 96+3, _EN },
+/*11 EN+ET */ { 32+1, 32+2, 4, 32+5, 32+7, 32+15, 32+17, 32+7, 11, 32+7, 11, 11, 32+3, _EN },
+/*12 AN+CS */ { 96+1, 96+2, 96+4, 5, 128+7, 96+15, 96+17, 128+7,128+14, 128+7, 12, 128+7, 96+3, _AN },
+/*13 AL:EN/AN+CS */ { 96+1, 96+2, 6, 6, 128+8, 96+16, 96+17, 128+8, 128+8, 128+8, 13, 128+8, 96+3, _AN },
+/*14 ON+ET */ { 32+1, 32+2, 128+4, 32+5, 7, 32+15, 32+17, 7, 14, 7, 14, 14, 32+3, _ON },
+/*15 S */ { 32+1, 32+2, 32+4, 32+5, 32+7, 15, 32+17, 32+7, 32+9, 32+7, 15, 32+7, 32+3, _S },
+/*16 AL:S */ { 32+1, 32+2, 32+6, 32+6, 32+8, 16, 32+17, 32+8, 32+8, 32+8, 16, 32+8, 32+3, _S },
+/*17 B */ { 32+1, 32+2, 32+4, 32+5, 32+7, 32+15, 17, 32+7, 32+9, 32+7, 17, 32+7, 32+3, _B }
+ };
+
+ /*********************************************************************/
+ /* The levels state machine tables */
+ /*********************************************************************/
+ /* */
+ /* All table cells are 8 bits: */
+ /* bits 0..3: next state */
+ /* bits 4..7: action to perform (if > 0) */
+ /* */
+ /* Cells may be of format "n" where n represents the next state */
+ /* (except for the rightmost column). */
+ /* Cells may also be of format "_(x,y)" where x represents an action */
+ /* to perform and y represents the next state. */
+ /* */
+ /* This format limits each table to 16 states each and to 15 actions.*/
+ /* */
+ /*********************************************************************/
+ /* Definitions and type for levels state tables */
+ /*********************************************************************/
+ private static final int IMPTABLEVELS_COLUMNS = _B + 2;
+ private static final int IMPTABLEVELS_RES = IMPTABLEVELS_COLUMNS - 1;
+ private static short GetState(byte cell) { return (short)(cell & 0x0f); }
+ private static short GetAction(byte cell) { return (short)(cell >> 4); }
+
+ private static class ImpTabPair {
+ byte[][][] imptab;
+ short[][] impact;
+
+ ImpTabPair(byte[][] table1, byte[][] table2,
+ short[] act1, short[] act2) {
+ imptab = new byte[][][] {table1, table2};
+ impact = new short[][] {act1, act2};
+ }
+ }
+
+ /*********************************************************************/
+ /* */
+ /* LEVELS STATE TABLES */
+ /* */
+ /* In all levels state tables, */
+ /* - state 0 is the initial state */
+ /* - the Res column is the increment to add to the text level */
+ /* for this property sequence. */
+ /* */
+ /* The impact arrays for each table of a pair map the local action */
+ /* numbers of the table to the total list of actions. For instance, */
+ /* action 2 in a given table corresponds to the action number which */
+ /* appears in entry [2] of the impact array for that table. */
+ /* The first entry of all impact arrays must be 0. */
+ /* */
+ /* Action 1: init conditional sequence */
+ /* 2: prepend conditional sequence to current sequence */
+ /* 3: set ON sequence to new level - 1 */
+ /* 4: init EN/AN/ON sequence */
+ /* 5: fix EN/AN/ON sequence followed by R */
+ /* 6: set previous level sequence to level 2 */
+ /* */
+ /* Notes: */
+ /* 1) These tables are used in processPropertySeq(). The input */
+ /* is property sequences as determined by resolveImplicitLevels. */
+ /* 2) Most such property sequences are processed immediately */
+ /* (levels are assigned). */
+ /* 3) However, some sequences cannot be assigned a final level till */
+ /* one or more following sequences are received. For instance, */
+ /* ON following an R sequence within an even-level paragraph. */
+ /* If the following sequence is R, the ON sequence will be */
+ /* assigned basic run level+1, and so will the R sequence. */
+ /* 4) S is generally handled like ON, since its level will be fixed */
+ /* to paragraph level in adjustWSLevels(). */
+ /* */
+
+ private static final byte impTabL_DEFAULT[][] = /* Even paragraph level */
+ /* In this table, conditional sequences receive the higher possible level
+ until proven otherwise.
+ */
+ {
+ /* L, R, EN, AN, ON, S, B, Res */
+ /* 0 : init */ { 0, 1, 0, 2, 0, 0, 0, 0 },
+ /* 1 : R */ { 0, 1, 3, 3, 0x14, 0x14, 0, 1 },
+ /* 2 : AN */ { 0, 1, 0, 2, 0x15, 0x15, 0, 2 },
+ /* 3 : R+EN/AN */ { 0, 1, 3, 3, 0x14, 0x14, 0, 2 },
+ /* 4 : R+ON */ { 0x20, 1, 3, 3, 4, 4, 0x20, 1 },
+ /* 5 : AN+ON */ { 0x20, 1, 0x20, 2, 5, 5, 0x20, 1 }
+ };
+
+ private static final byte impTabR_DEFAULT[][] = /* Odd paragraph level */
+ /* In this table, conditional sequences receive the lower possible level
+ until proven otherwise.
+ */
+ {
+ /* L, R, EN, AN, ON, S, B, Res */
+ /* 0 : init */ { 1, 0, 2, 2, 0, 0, 0, 0 },
+ /* 1 : L */ { 1, 0, 1, 3, 0x14, 0x14, 0, 1 },
+ /* 2 : EN/AN */ { 1, 0, 2, 2, 0, 0, 0, 1 },
+ /* 3 : L+AN */ { 1, 0, 1, 3, 5, 5, 0, 1 },
+ /* 4 : L+ON */ { 0x21, 0, 0x21, 3, 4, 4, 0, 0 },
+ /* 5 : L+AN+ON */ { 1, 0, 1, 3, 5, 5, 0, 0 }
+ };
+
+ private static final short[] impAct0 = {0,1,2,3,4,5,6};
+
+ private static final ImpTabPair impTab_DEFAULT = new ImpTabPair(
+ impTabL_DEFAULT, impTabR_DEFAULT, impAct0, impAct0);
+
+ private static final byte impTabL_NUMBERS_SPECIAL[][] = { /* Even paragraph level */
+ /* In this table, conditional sequences receive the higher possible
+ level until proven otherwise.
+ */
+ /* L, R, EN, AN, ON, S, B, Res */
+ /* 0 : init */ { 0, 2, 1, 1, 0, 0, 0, 0 },
+ /* 1 : L+EN/AN */ { 0, 2, 1, 1, 0, 0, 0, 2 },
+ /* 2 : R */ { 0, 2, 4, 4, 0x13, 0, 0, 1 },
+ /* 3 : R+ON */ { 0x20, 2, 4, 4, 3, 3, 0x20, 1 },
+ /* 4 : R+EN/AN */ { 0, 2, 4, 4, 0x13, 0x13, 0, 2 }
+ };
+ private static final ImpTabPair impTab_NUMBERS_SPECIAL = new ImpTabPair(
+ impTabL_NUMBERS_SPECIAL, impTabR_DEFAULT, impAct0, impAct0);
+
+ private static final byte impTabL_GROUP_NUMBERS_WITH_R[][] = {
+ /* In this table, EN/AN+ON sequences receive levels as if associated with R
+ until proven that there is L or sor/eor on both sides. AN is handled like EN.
+ */
+ /* L, R, EN, AN, ON, S, B, Res */
+ /* 0 init */ { 0, 3, 0x11, 0x11, 0, 0, 0, 0 },
+ /* 1 EN/AN */ { 0x20, 3, 1, 1, 2, 0x20, 0x20, 2 },
+ /* 2 EN/AN+ON */ { 0x20, 3, 1, 1, 2, 0x20, 0x20, 1 },
+ /* 3 R */ { 0, 3, 5, 5, 0x14, 0, 0, 1 },
+ /* 4 R+ON */ { 0x20, 3, 5, 5, 4, 0x20, 0x20, 1 },
+ /* 5 R+EN/AN */ { 0, 3, 5, 5, 0x14, 0, 0, 2 }
+ };
+ private static final byte impTabR_GROUP_NUMBERS_WITH_R[][] = {
+ /* In this table, EN/AN+ON sequences receive levels as if associated with R
+ until proven that there is L on both sides. AN is handled like EN.
+ */
+ /* L, R, EN, AN, ON, S, B, Res */
+ /* 0 init */ { 2, 0, 1, 1, 0, 0, 0, 0 },
+ /* 1 EN/AN */ { 2, 0, 1, 1, 0, 0, 0, 1 },
+ /* 2 L */ { 2, 0, 0x14, 0x14, 0x13, 0, 0, 1 },
+ /* 3 L+ON */ { 0x22, 0, 4, 4, 3, 0, 0, 0 },
+ /* 4 L+EN/AN */ { 0x22, 0, 4, 4, 3, 0, 0, 1 }
+ };
+ private static final ImpTabPair impTab_GROUP_NUMBERS_WITH_R = new
+ ImpTabPair(impTabL_GROUP_NUMBERS_WITH_R,
+ impTabR_GROUP_NUMBERS_WITH_R, impAct0, impAct0);
+
+ private static final byte impTabL_INVERSE_NUMBERS_AS_L[][] = {
+ /* This table is identical to the Default LTR table except that EN and AN
+ are handled like L.
+ */
+ /* L, R, EN, AN, ON, S, B, Res */
+ /* 0 : init */ { 0, 1, 0, 0, 0, 0, 0, 0 },
+ /* 1 : R */ { 0, 1, 0, 0, 0x14, 0x14, 0, 1 },
+ /* 2 : AN */ { 0, 1, 0, 0, 0x15, 0x15, 0, 2 },
+ /* 3 : R+EN/AN */ { 0, 1, 0, 0, 0x14, 0x14, 0, 2 },
+ /* 4 : R+ON */ { 0x20, 1, 0x20, 0x20, 4, 4, 0x20, 1 },
+ /* 5 : AN+ON */ { 0x20, 1, 0x20, 0x20, 5, 5, 0x20, 1 }
+ };
+ private static final byte impTabR_INVERSE_NUMBERS_AS_L[][] = {
+ /* This table is identical to the Default RTL table except that EN and AN
+ are handled like L.
+ */
+ /* L, R, EN, AN, ON, S, B, Res */
+ /* 0 : init */ { 1, 0, 1, 1, 0, 0, 0, 0 },
+ /* 1 : L */ { 1, 0, 1, 1, 0x14, 0x14, 0, 1 },
+ /* 2 : EN/AN */ { 1, 0, 1, 1, 0, 0, 0, 1 },
+ /* 3 : L+AN */ { 1, 0, 1, 1, 5, 5, 0, 1 },
+ /* 4 : L+ON */ { 0x21, 0, 0x21, 0x21, 4, 4, 0, 0 },
+ /* 5 : L+AN+ON */ { 1, 0, 1, 1, 5, 5, 0, 0 }
+ };
+ private static final ImpTabPair impTab_INVERSE_NUMBERS_AS_L = new ImpTabPair
+ (impTabL_INVERSE_NUMBERS_AS_L, impTabR_INVERSE_NUMBERS_AS_L,
+ impAct0, impAct0);
+
+ private static final byte impTabR_INVERSE_LIKE_DIRECT[][] = { /* Odd paragraph level */
+ /* In this table, conditional sequences receive the lower possible level
+ until proven otherwise.
+ */
+ /* L, R, EN, AN, ON, S, B, Res */
+ /* 0 : init */ { 1, 0, 2, 2, 0, 0, 0, 0 },
+ /* 1 : L */ { 1, 0, 1, 2, 0x13, 0x13, 0, 1 },
+ /* 2 : EN/AN */ { 1, 0, 2, 2, 0, 0, 0, 1 },
+ /* 3 : L+ON */ { 0x21, 0x30, 6, 4, 3, 3, 0x30, 0 },
+ /* 4 : L+ON+AN */ { 0x21, 0x30, 6, 4, 5, 5, 0x30, 3 },
+ /* 5 : L+AN+ON */ { 0x21, 0x30, 6, 4, 5, 5, 0x30, 2 },
+ /* 6 : L+ON+EN */ { 0x21, 0x30, 6, 4, 3, 3, 0x30, 1 }
+ };
+ private static final short[] impAct1 = {0,1,11,12};
+ private static final ImpTabPair impTab_INVERSE_LIKE_DIRECT = new ImpTabPair(
+ impTabL_DEFAULT, impTabR_INVERSE_LIKE_DIRECT, impAct0, impAct1);
+
+ private static final byte impTabL_INVERSE_LIKE_DIRECT_WITH_MARKS[][] = {
+ /* The case handled in this table is (visually): R EN L
+ */
+ /* L, R, EN, AN, ON, S, B, Res */
+ /* 0 : init */ { 0, 0x63, 0, 1, 0, 0, 0, 0 },
+ /* 1 : L+AN */ { 0, 0x63, 0, 1, 0x12, 0x30, 0, 4 },
+ /* 2 : L+AN+ON */ { 0x20, 0x63, 0x20, 1, 2, 0x30, 0x20, 3 },
+ /* 3 : R */ { 0, 0x63, 0x55, 0x56, 0x14, 0x30, 0, 3 },
+ /* 4 : R+ON */ { 0x30, 0x43, 0x55, 0x56, 4, 0x30, 0x30, 3 },
+ /* 5 : R+EN */ { 0x30, 0x43, 5, 0x56, 0x14, 0x30, 0x30, 4 },
+ /* 6 : R+AN */ { 0x30, 0x43, 0x55, 6, 0x14, 0x30, 0x30, 4 }
+ };
+ private static final byte impTabR_INVERSE_LIKE_DIRECT_WITH_MARKS[][] = {
+ /* The cases handled in this table are (visually): R EN L
+ R L AN L
+ */
+ /* L, R, EN, AN, ON, S, B, Res */
+ /* 0 : init */ { 0x13, 0, 1, 1, 0, 0, 0, 0 },
+ /* 1 : R+EN/AN */ { 0x23, 0, 1, 1, 2, 0x40, 0, 1 },
+ /* 2 : R+EN/AN+ON */ { 0x23, 0, 1, 1, 2, 0x40, 0, 0 },
+ /* 3 : L */ { 3 , 0, 3, 0x36, 0x14, 0x40, 0, 1 },
+ /* 4 : L+ON */ { 0x53, 0x40, 5, 0x36, 4, 0x40, 0x40, 0 },
+ /* 5 : L+ON+EN */ { 0x53, 0x40, 5, 0x36, 4, 0x40, 0x40, 1 },
+ /* 6 : L+AN */ { 0x53, 0x40, 6, 6, 4, 0x40, 0x40, 3 }
+ };
+ private static final short impAct2[] = {0,1,7,8,9,10};
+ private static final ImpTabPair impTab_INVERSE_LIKE_DIRECT_WITH_MARKS =
+ new ImpTabPair(impTabL_INVERSE_LIKE_DIRECT_WITH_MARKS,
+ impTabR_INVERSE_LIKE_DIRECT_WITH_MARKS, impAct0, impAct2);
+
+ private static final ImpTabPair impTab_INVERSE_FOR_NUMBERS_SPECIAL = new ImpTabPair(
+ impTabL_NUMBERS_SPECIAL, impTabR_INVERSE_LIKE_DIRECT, impAct0, impAct1);
+
+ private static final byte impTabL_INVERSE_FOR_NUMBERS_SPECIAL_WITH_MARKS[][] = {
+ /* The case handled in this table is (visually): R EN L
+ */
+ /* L, R, EN, AN, ON, S, B, Res */
+ /* 0 : init */ { 0, 0x62, 1, 1, 0, 0, 0, 0 },
+ /* 1 : L+EN/AN */ { 0, 0x62, 1, 1, 0, 0x30, 0, 4 },
+ /* 2 : R */ { 0, 0x62, 0x54, 0x54, 0x13, 0x30, 0, 3 },
+ /* 3 : R+ON */ { 0x30, 0x42, 0x54, 0x54, 3, 0x30, 0x30, 3 },
+ /* 4 : R+EN/AN */ { 0x30, 0x42, 4, 4, 0x13, 0x30, 0x30, 4 }
+ };
+ private static final ImpTabPair impTab_INVERSE_FOR_NUMBERS_SPECIAL_WITH_MARKS = new
+ ImpTabPair(impTabL_INVERSE_FOR_NUMBERS_SPECIAL_WITH_MARKS,
+ impTabR_INVERSE_LIKE_DIRECT_WITH_MARKS, impAct0, impAct2);
+
+ private class LevState {
+ byte[][] impTab; /* level table pointer */
+ short[] impAct; /* action map array */
+ int startON; /* start of ON sequence */
+ int startL2EN; /* start of level 2 sequence */
+ int lastStrongRTL; /* index of last found R or AL */
+ short state; /* current state */
+ byte runLevel; /* run level before implicit solving */
+ }
+
+ /*------------------------------------------------------------------------*/
+
+ static final int FIRSTALLOC = 10;
+ /*
+ * param pos: position where to insert
+ * param flag: one of LRM_BEFORE, LRM_AFTER, RLM_BEFORE, RLM_AFTER
+ */
+ private void addPoint(int pos, int flag)
+ {
+ Point point = new Point();
+
+ int len = insertPoints.points.length;
+ if (len == 0) {
+ insertPoints.points = new Point[FIRSTALLOC];
+ len = FIRSTALLOC;
+ }
+ if (insertPoints.size >= len) { /* no room for new point */
+ Point[] savePoints = insertPoints.points;
+ insertPoints.points = new Point[len * 2];
+ System.arraycopy(savePoints, 0, insertPoints.points, 0, len);
+ }
+ point.pos = pos;
+ point.flag = flag;
+ insertPoints.points[insertPoints.size] = point;
+ insertPoints.size++;
+ }
+
+ /* perform rules (Wn), (Nn), and (In) on a run of the text ------------------ */
+
+ /*
+ * This implementation of the (Wn) rules applies all rules in one pass.
+ * In order to do so, it needs a look-ahead of typically 1 character
+ * (except for W5: sequences of ET) and keeps track of changes
+ * in a rule Wp that affect a later Wq (p= 0) {
+ addPoint(levState.startL2EN, LRM_BEFORE);
+ }
+ levState.startL2EN = -1; /* not within previous if since could also be -2 */
+ /* check if we had any relevant EN/AN after R/AL */
+ if ((insertPoints.points.length == 0) ||
+ (insertPoints.size <= insertPoints.confirmed)) {
+ /* nothing, just clean up */
+ levState.lastStrongRTL = -1;
+ /* check if we have a pending conditional segment */
+ level = (byte)impTab[oldStateSeq][IMPTABLEVELS_RES];
+ if ((level & 1) != 0 && levState.startON > 0) { /* after ON */
+ start = levState.startON; /* reset to basic run level */
+ }
+ if (_prop == _S) { /* add LRM before S */
+ addPoint(start0, LRM_BEFORE);
+ insertPoints.confirmed = insertPoints.size;
+ }
+ break;
+ }
+ /* reset previous RTL cont to level for LTR text */
+ for (k = levState.lastStrongRTL + 1; k < start0; k++) {
+ /* reset odd level, leave runLevel+2 as is */
+ levels[k] = (byte)((levels[k] - 2) & ~1);
+ }
+ /* mark insert points as confirmed */
+ insertPoints.confirmed = insertPoints.size;
+ levState.lastStrongRTL = -1;
+ if (_prop == _S) { /* add LRM before S */
+ addPoint(start0, LRM_BEFORE);
+ insertPoints.confirmed = insertPoints.size;
+ }
+ break;
+
+ case 4: /* R/AL after possible relevant EN/AN */
+ /* just clean up */
+ if (insertPoints.points.length > 0)
+ /* remove all non confirmed insert points */
+ insertPoints.size = insertPoints.confirmed;
+ levState.startON = -1;
+ levState.startL2EN = -1;
+ levState.lastStrongRTL = limit - 1;
+ break;
+
+ case 5: /* EN/AN after R/AL + possible cont */
+ /* check for real AN */
+ if ((_prop == _AN) && (NoContextRTL(dirProps[start0]) == AN)) {
+ /* real AN */
+ if (levState.startL2EN == -1) { /* if no relevant EN already found */
+ /* just note the righmost digit as a strong RTL */
+ levState.lastStrongRTL = limit - 1;
+ break;
+ }
+ if (levState.startL2EN >= 0) { /* after EN, no AN */
+ addPoint(levState.startL2EN, LRM_BEFORE);
+ levState.startL2EN = -2;
+ }
+ /* note AN */
+ addPoint(start0, LRM_BEFORE);
+ break;
+ }
+ /* if first EN/AN after R/AL */
+ if (levState.startL2EN == -1) {
+ levState.startL2EN = start0;
+ }
+ break;
+
+ case 6: /* note location of latest R/AL */
+ levState.lastStrongRTL = limit - 1;
+ levState.startON = -1;
+ break;
+
+ case 7: /* L after R+ON/EN/AN */
+ /* include possible adjacent number on the left */
+ for (k = start0-1; k >= 0 && ((levels[k] & 1) == 0); k--) {
+ }
+ if (k >= 0) {
+ addPoint(k, RLM_BEFORE); /* add RLM before */
+ insertPoints.confirmed = insertPoints.size; /* confirm it */
+ }
+ levState.startON = start0;
+ break;
+
+ case 8: /* AN after L */
+ /* AN numbers between L text on both sides may be trouble. */
+ /* tentatively bracket with LRMs; will be confirmed if followed by L */
+ addPoint(start0, LRM_BEFORE); /* add LRM before */
+ addPoint(start0, LRM_AFTER); /* add LRM after */
+ break;
+
+ case 9: /* R after L+ON/EN/AN */
+ /* false alert, infirm LRMs around previous AN */
+ insertPoints.size=insertPoints.confirmed;
+ if (_prop == _S) { /* add RLM before S */
+ addPoint(start0, RLM_BEFORE);
+ insertPoints.confirmed = insertPoints.size;
+ }
+ break;
+
+ case 10: /* L after L+ON/AN */
+ level = (byte)(levState.runLevel + addLevel);
+ for (k=levState.startON; k < start0; k++) {
+ if (levels[k] < level) {
+ levels[k] = level;
+ }
+ }
+ insertPoints.confirmed = insertPoints.size; /* confirm inserts */
+ levState.startON = start0;
+ break;
+
+ case 11: /* L after L+ON+EN/AN/ON */
+ level = (byte)levState.runLevel;
+ for (k = start0-1; k >= levState.startON; k--) {
+ if (levels[k] == level+3) {
+ while (levels[k] == level+3) {
+ levels[k--] -= 2;
+ }
+ while (levels[k] == level) {
+ k--;
+ }
+ }
+ if (levels[k] == level+2) {
+ levels[k] = level;
+ continue;
+ }
+ levels[k] = (byte)(level+1);
+ }
+ break;
+
+ case 12: /* R after L+ON+EN/AN/ON */
+ level = (byte)(levState.runLevel+1);
+ for (k = start0-1; k >= levState.startON; k--) {
+ if (levels[k] > level) {
+ levels[k] -= 2;
+ }
+ }
+ break;
+
+ default: /* we should never get here */
+ throw new IllegalStateException("Internal ICU error in processPropertySeq");
+ }
+ }
+ if ((addLevel) != 0 || (start < start0)) {
+ level = (byte)(levState.runLevel + addLevel);
+ for (k = start; k < limit; k++) {
+ levels[k] = level;
+ }
+ }
+ }
+
+ private void resolveImplicitLevels(int start, int limit, short sor, short eor)
+ {
+ LevState levState = new LevState();
+ int i, start1, start2;
+ short oldStateImp, stateImp, actionImp;
+ short gprop, resProp, cell;
+ short nextStrongProp = R;
+ int nextStrongPos = -1;
+
+
+ /* check for RTL inverse Bidi mode */
+ /* FOOD FOR THOUGHT: in case of RTL inverse Bidi, it would make sense to
+ * loop on the text characters from end to start.
+ * This would need a different properties state table (at least different
+ * actions) and different levels state tables (maybe very similar to the
+ * LTR corresponding ones.
+ */
+ /* initialize for levels state table */
+ levState.startL2EN = -1; /* used for INVERSE_LIKE_DIRECT_WITH_MARKS */
+ levState.lastStrongRTL = -1; /* used for INVERSE_LIKE_DIRECT_WITH_MARKS */
+ levState.state = 0;
+ levState.runLevel = levels[start];
+ levState.impTab = impTabPair.imptab[levState.runLevel & 1];
+ levState.impAct = impTabPair.impact[levState.runLevel & 1];
+ processPropertySeq(levState, (short)sor, start, start);
+ /* initialize for property state table */
+ if (dirProps[start] == NSM) {
+ stateImp = (short)(1 + sor);
+ } else {
+ stateImp = 0;
+ }
+ start1 = start;
+ start2 = 0;
+
+ for (i = start; i <= limit; i++) {
+ if (i >= limit) {
+ gprop = eor;
+ } else {
+ short prop, prop1;
+ prop = NoContextRTL(dirProps[i]);
+ gprop = groupProp[prop];
+ }
+ oldStateImp = stateImp;
+ cell = impTabProps[oldStateImp][gprop];
+ stateImp = GetStateProps(cell); /* isolate the new state */
+ actionImp = GetActionProps(cell); /* isolate the action */
+ if ((i == limit) && (actionImp == 0)) {
+ /* there is an unprocessed sequence if its property == eor */
+ actionImp = 1; /* process the last sequence */
+ }
+ if (actionImp != 0) {
+ resProp = impTabProps[oldStateImp][IMPTABPROPS_RES];
+ switch (actionImp) {
+ case 1: /* process current seq1, init new seq1 */
+ processPropertySeq(levState, resProp, start1, i);
+ start1 = i;
+ break;
+ case 2: /* init new seq2 */
+ start2 = i;
+ break;
+ case 3: /* process seq1, process seq2, init new seq1 */
+ processPropertySeq(levState, resProp, start1, start2);
+ processPropertySeq(levState, _ON, start2, i);
+ start1 = i;
+ break;
+ case 4: /* process seq1, set seq1=seq2, init new seq2 */
+ processPropertySeq(levState, resProp, start1, start2);
+ start1 = start2;
+ start2 = i;
+ break;
+ default: /* we should never get here */
+ throw new IllegalStateException("Internal ICU error in resolveImplicitLevels");
+ }
+ }
+ }
+ /* flush possible pending sequence, e.g. ON */
+ processPropertySeq(levState, (short)eor, limit, limit);
+ }
+
+ /* perform (L1) and (X9) ---------------------------------------------------- */
+
+ /*
+ * Reset the embedding levels for some non-graphic characters (L1).
+ * This method also sets appropriate levels for BN, and
+ * explicit embedding types that are supposed to have been removed
+ * from the paragraph in (X9).
+ */
+ private void adjustWSLevels() {
+ int i;
+
+ if ((flags & MASK_WS) != 0) {
+ int flag;
+ i = trailingWSStart;
+ while (i > 0) {
+ /* reset a sequence of WS/BN before eop and B/S to the paragraph paraLevel */
+ while (i > 0 && ((flag = DirPropFlagNC(dirProps[--i])) & MASK_WS) != 0) {
+ if (orderParagraphsLTR && (flag & DirPropFlag(B)) != 0) {
+ levels[i] = 0;
+ } else {
+ levels[i] = GetParaLevelAt(i);
+ }
+ }
+
+ /* reset BN to the next character's paraLevel until B/S, which restarts above loop */
+ /* here, i+1 is guaranteed to be 0) {
+ flag = DirPropFlagNC(dirProps[--i]);
+ if ((flag & MASK_BN_EXPLICIT) != 0) {
+ levels[i] = levels[i + 1];
+ } else if (orderParagraphsLTR && (flag & DirPropFlag(B)) != 0) {
+ levels[i] = 0;
+ break;
+ } else if ((flag & MASK_B_S) != 0){
+ levels[i] = GetParaLevelAt(i);
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ private int Bidi_Min(int x, int y) {
+ return x < y ? x : y;
+ }
+
+ private int Bidi_Abs(int x) {
+ return x >= 0 ? x : -x;
+ }
+
+ /**
+ * Perform the Unicode Bidi algorithm. It is defined in the
+ * Unicode Standard Annex #9,
+ * version 13,
+ * also described in The Unicode Standard, Version 4.0 .
+ *
+ * This method takes a piece of plain text containing one or more paragraphs,
+ * with or without externally specified embedding levels from styled
+ * text and computes the left-right-directionality of each character.
+ *
+ * If the entire text is all of the same directionality, then
+ * the method may not perform all the steps described by the algorithm,
+ * i.e., some levels may not be the same as if all steps were performed.
+ * This is not relevant for unidirectional text.
+ * For example, in pure LTR text with numbers the numbers would get
+ * a resolved level of 2 higher than the surrounding text according to
+ * the algorithm. This implementation may set all resolved levels to
+ * the same value in such a case.
+ *
+ * The text can be composed of multiple paragraphs. Occurrence of a block
+ * separator in the text terminates a paragraph, and whatever comes next starts
+ * a new paragraph. The exception to this rule is when a Carriage Return (CR)
+ * is followed by a Line Feed (LF). Both CR and LF are block separators, but
+ * in that case, the pair of characters is considered as terminating the
+ * preceding paragraph, and a new paragraph will be started by a character
+ * coming after the LF.
+ *
+ * Although the text is passed here as a String, it is
+ * stored internally as an array of characters. Therefore the
+ * documentation will refer to indexes of the characters in the text.
+ *
+ * @param text contains the text that the Bidi algorithm will be performed
+ * on. This text can be retrieved with getText() or
+ * getTextAsString.
+ *
+ * @param paraLevel specifies the default level for the text;
+ * it is typically 0 (LTR) or 1 (RTL).
+ * If the method shall determine the paragraph level from the text,
+ * then paraLevel can be set to
+ * either LEVEL_DEFAULT_LTR
+ * or LEVEL_DEFAULT_RTL; if the text contains multiple
+ * paragraphs, the paragraph level shall be determined separately for
+ * each paragraph; if a paragraph does not include any strongly typed
+ * character, then the desired default is used (0 for LTR or 1 for RTL).
+ * Any other value between 0 and MAX_EXPLICIT_LEVEL
+ * is also valid, with odd levels indicating RTL.
+ *
+ * @param embeddingLevels (in) may be used to preset the embedding and override levels,
+ * ignoring characters like LRE and PDF in the text.
+ * A level overrides the directional property of its corresponding
+ * (same index) character if the level has the
+ * LEVEL_OVERRIDE bit set.
+ * Except for that bit, it must be
+ * paraLevel<=embeddingLevels[]<=MAX_EXPLICIT_LEVEL,
+ * with one exception: a level of zero may be specified for a
+ * paragraph separator even if paraLevel>0 when multiple
+ * paragraphs are submitted in the same call to setPara().
+ * Caution: A reference to this array, not a copy
+ * of the levels, will be stored in the Bidi object;
+ * the embeddingLevels
+ * should not be modified to avoid unexpected results on subsequent
+ * Bidi operations. However, the setPara() and
+ * setLine() methods may modify some or all of the
+ * levels.
+ * Note: the embeddingLevels array must
+ * have one entry for each character in text.
+ *
+ * @throws IllegalArgumentException if the values in embeddingLevels are
+ * not within the allowed range
+ *
+ * @see #LEVEL_DEFAULT_LTR
+ * @see #LEVEL_DEFAULT_RTL
+ * @see #LEVEL_OVERRIDE
+ * @see #MAX_EXPLICIT_LEVEL
+ * @stable ICU 3.8
+ */
+ void setPara(String text, byte paraLevel, byte[] embeddingLevels)
+ {
+ if (text == null) {
+ setPara(new char[0], paraLevel, embeddingLevels);
+ } else {
+ setPara(text.toCharArray(), paraLevel, embeddingLevels);
+ }
+ }
+
+ /**
+ * Perform the Unicode Bidi algorithm. It is defined in the
+ * Unicode Standard Annex #9,
+ * version 13,
+ * also described in The Unicode Standard, Version 4.0 .
+ *
+ * This method takes a piece of plain text containing one or more paragraphs,
+ * with or without externally specified embedding levels from styled
+ * text and computes the left-right-directionality of each character.
+ *
+ * If the entire text is all of the same directionality, then
+ * the method may not perform all the steps described by the algorithm,
+ * i.e., some levels may not be the same as if all steps were performed.
+ * This is not relevant for unidirectional text.
+ * For example, in pure LTR text with numbers the numbers would get
+ * a resolved level of 2 higher than the surrounding text according to
+ * the algorithm. This implementation may set all resolved levels to
+ * the same value in such a case.
+ *
+ * The text can be composed of multiple paragraphs. Occurrence of a block
+ * separator in the text terminates a paragraph, and whatever comes next starts
+ * a new paragraph. The exception to this rule is when a Carriage Return (CR)
+ * is followed by a Line Feed (LF). Both CR and LF are block separators, but
+ * in that case, the pair of characters is considered as terminating the
+ * preceding paragraph, and a new paragraph will be started by a character
+ * coming after the LF.
+ *
+ * The text is stored internally as an array of characters. Therefore the
+ * documentation will refer to indexes of the characters in the text.
+ *
+ * @param chars contains the text that the Bidi algorithm will be performed
+ * on. This text can be retrieved with getText() or
+ * getTextAsString.
+ *
+ * @param paraLevel specifies the default level for the text;
+ * it is typically 0 (LTR) or 1 (RTL).
+ * If the method shall determine the paragraph level from the text,
+ * then paraLevel can be set to
+ * either LEVEL_DEFAULT_LTR
+ * or LEVEL_DEFAULT_RTL; if the text contains multiple
+ * paragraphs, the paragraph level shall be determined separately for
+ * each paragraph; if a paragraph does not include any strongly typed
+ * character, then the desired default is used (0 for LTR or 1 for RTL).
+ * Any other value between 0 and MAX_EXPLICIT_LEVEL
+ * is also valid, with odd levels indicating RTL.
+ *
+ * @param embeddingLevels (in) may be used to preset the embedding and
+ * override levels, ignoring characters like LRE and PDF in the text.
+ * A level overrides the directional property of its corresponding
+ * (same index) character if the level has the
+ * LEVEL_OVERRIDE bit set.
+ * Except for that bit, it must be
+ * paraLevel<=embeddingLevels[]<=MAX_EXPLICIT_LEVEL,
+ * with one exception: a level of zero may be specified for a
+ * paragraph separator even if paraLevel>0 when multiple
+ * paragraphs are submitted in the same call to setPara().
+ * Caution: A reference to this array, not a copy
+ * of the levels, will be stored in the Bidi object;
+ * the embeddingLevels
+ * should not be modified to avoid unexpected results on subsequent
+ * Bidi operations. However, the setPara() and
+ * setLine() methods may modify some or all of the
+ * levels.
+ * Note: the embeddingLevels array must
+ * have one entry for each character in text.
+ *
+ * @throws IllegalArgumentException if the values in embeddingLevels are
+ * not within the allowed range
+ *
+ * @see #LEVEL_DEFAULT_LTR
+ * @see #LEVEL_DEFAULT_RTL
+ * @see #LEVEL_OVERRIDE
+ * @see #MAX_EXPLICIT_LEVEL
+ * @stable ICU 3.8
+ */
+ public void setPara(char[] chars, byte paraLevel, byte[] embeddingLevels)
+ {
+ /* check the argument values */
+ if (paraLevel < INTERNAL_LEVEL_DEFAULT_LTR) {
+ verifyRange(paraLevel, 0, MAX_EXPLICIT_LEVEL + 1);
+ }
+ if (chars == null) {
+ chars = new char[0];
+ }
+
+ /* initialize the Bidi object */
+ this.paraBidi = null; /* mark unfinished setPara */
+ this.text = chars;
+ this.length = this.originalLength = this.resultLength = text.length;
+ this.paraLevel = paraLevel;
+ this.direction = Bidi.DIRECTION_LEFT_TO_RIGHT;
+ this.paraCount = 1;
+
+ /* Allocate zero-length arrays instead of setting to null here; then
+ * checks for null in various places can be eliminated.
+ */
+ dirProps = new byte[0];
+ levels = new byte[0];
+ runs = new BidiRun[0];
+ isGoodLogicalToVisualRunsMap = false;
+ insertPoints.size = 0; /* clean up from last call */
+ insertPoints.confirmed = 0; /* clean up from last call */
+
+ /*
+ * Save the original paraLevel if contextual; otherwise, set to 0.
+ */
+ if (IsDefaultLevel(paraLevel)) {
+ defaultParaLevel = paraLevel;
+ } else {
+ defaultParaLevel = 0;
+ }
+
+ if (length == 0) {
+ /*
+ * For an empty paragraph, create a Bidi object with the paraLevel and
+ * the flags and the direction set but without allocating zero-length arrays.
+ * There is nothing more to do.
+ */
+ if (IsDefaultLevel(paraLevel)) {
+ this.paraLevel &= 1;
+ defaultParaLevel = 0;
+ }
+ if ((this.paraLevel & 1) != 0) {
+ flags = DirPropFlag(R);
+ direction = Bidi.DIRECTION_RIGHT_TO_LEFT;
+ } else {
+ flags = DirPropFlag(L);
+ direction = Bidi.DIRECTION_LEFT_TO_RIGHT;
+ }
+
+ runCount = 0;
+ paraCount = 0;
+ paraBidi = this; /* mark successful setPara */
+ return;
+ }
+
+ runCount = -1;
+
+ /*
+ * Get the directional properties,
+ * the flags bit-set, and
+ * determine the paragraph level if necessary.
+ */
+ getDirPropsMemory(length);
+ dirProps = dirPropsMemory;
+ getDirProps();
+
+ /* the processed length may have changed if OPTION_STREAMING is set */
+ trailingWSStart = length; /* the levels[] will reflect the WS run */
+
+ /* allocate paras memory */
+ if (paraCount > 1) {
+ getInitialParasMemory(paraCount);
+ paras = parasMemory;
+ paras[paraCount - 1] = length;
+ } else {
+ /* initialize paras for single paragraph */
+ paras = simpleParas;
+ simpleParas[0] = length;
+ }
+
+ /* are explicit levels specified? */
+ if (embeddingLevels == null) {
+ /* no: determine explicit levels according to the (Xn) rules */
+ getLevelsMemory(length);
+ levels = levelsMemory;
+ direction = resolveExplicitLevels();
+ } else {
+ /* set BN for all explicit codes, check that all levels are 0 or paraLevel..MAX_EXPLICIT_LEVEL */
+ levels = embeddingLevels;
+ direction = checkExplicitLevels();
+ }
+
+ /*
+ * The steps after (X9) in the Bidi algorithm are performed only if
+ * the paragraph text has mixed directionality!
+ */
+ switch (direction) {
+ case Bidi.DIRECTION_LEFT_TO_RIGHT:
+ /* make sure paraLevel is even */
+ paraLevel = (byte)((paraLevel + 1) & ~1);
+
+ /* all levels are implicitly at paraLevel (important for getLevels()) */
+ trailingWSStart = 0;
+ break;
+ case Bidi.DIRECTION_RIGHT_TO_LEFT:
+ /* make sure paraLevel is odd */
+ paraLevel |= 1;
+
+ /* all levels are implicitly at paraLevel (important for getLevels()) */
+ trailingWSStart = 0;
+ break;
+ default:
+ this.impTabPair = impTab_DEFAULT;
+
+ /*
+ * If there are no external levels specified and there
+ * are no significant explicit level codes in the text,
+ * then we can treat the entire paragraph as one run.
+ * Otherwise, we need to perform the following rules on runs of
+ * the text with the same embedding levels. (X10)
+ * "Significant" explicit level codes are ones that actually
+ * affect non-BN characters.
+ * Examples for "insignificant" ones are empty embeddings
+ * LRE-PDF, LRE-RLE-PDF-PDF, etc.
+ */
+ if (embeddingLevels == null && paraCount <= 1 &&
+ (flags & DirPropFlagMultiRuns) == 0) {
+ resolveImplicitLevels(0, length,
+ GetLRFromLevel(GetParaLevelAt(0)),
+ GetLRFromLevel(GetParaLevelAt(length - 1)));
+ } else {
+ /* sor, eor: start and end types of same-level-run */
+ int start, limit = 0;
+ byte level, nextLevel;
+ short sor, eor;
+
+ /* determine the first sor and set eor to it because of the loop body (sor=eor there) */
+ level = GetParaLevelAt(0);
+ nextLevel = levels[0];
+ if (level < nextLevel) {
+ eor = GetLRFromLevel(nextLevel);
+ } else {
+ eor = GetLRFromLevel(level);
+ }
+
+ do {
+ /* determine start and limit of the run (end points just behind the run) */
+
+ /* the values for this run's start are the same as for the previous run's end */
+ start = limit;
+ level = nextLevel;
+ if ((start > 0) && (NoContextRTL(dirProps[start - 1]) == B)) {
+ /* except if this is a new paragraph, then set sor = para level */
+ sor = GetLRFromLevel(GetParaLevelAt(start));
+ } else {
+ sor = eor;
+ }
+
+ /* search for the limit of this run */
+ while (++limit < length && levels[limit] == level) {}
+
+ /* get the correct level of the next run */
+ if (limit < length) {
+ nextLevel = levels[limit];
+ } else {
+ nextLevel = GetParaLevelAt(length - 1);
+ }
+
+ /* determine eor from max(level, nextLevel); sor is last run's eor */
+ if ((level & ~INTERNAL_LEVEL_OVERRIDE) < (nextLevel & ~INTERNAL_LEVEL_OVERRIDE)) {
+ eor = GetLRFromLevel(nextLevel);
+ } else {
+ eor = GetLRFromLevel(level);
+ }
+
+ /* if the run consists of overridden directional types, then there
+ are no implicit types to be resolved */
+ if ((level & INTERNAL_LEVEL_OVERRIDE) == 0) {
+ resolveImplicitLevels(start, limit, sor, eor);
+ } else {
+ /* remove the LEVEL_OVERRIDE flags */
+ do {
+ levels[start++] &= ~INTERNAL_LEVEL_OVERRIDE;
+ } while (start < limit);
+ }
+ } while (limit < length);
+ }
+
+ /* reset the embedding levels for some non-graphic characters (L1), (X9) */
+ adjustWSLevels();
+
+ break;
+ }
+
+ resultLength += insertPoints.size;
+ paraBidi = this; /* mark successful setPara */
+ }
+
+ /**
+ * Perform the Unicode Bidi algorithm on a given paragraph, as defined in the
+ * Unicode Standard Annex #9,
+ * version 13,
+ * also described in The Unicode Standard, Version 4.0 .
+ *
+ * This method takes a paragraph of text and computes the
+ * left-right-directionality of each character. The text should not
+ * contain any Unicode block separators.
+ *
+ * The RUN_DIRECTION attribute in the text, if present, determines the base
+ * direction (left-to-right or right-to-left). If not present, the base
+ * direction is computed using the Unicode Bidirectional Algorithm,
+ * defaulting to left-to-right if there are no strong directional characters
+ * in the text. This attribute, if present, must be applied to all the text
+ * in the paragraph.
+ *
+ * The BIDI_EMBEDDING attribute in the text, if present, represents
+ * embedding level information. Negative values from -1 to -62 indicate
+ * overrides at the absolute value of the level. Positive values from 1 to
+ * 62 indicate embeddings. Where values are zero or not defined, the base
+ * embedding level as determined by the base direction is assumed.
+ *
+ * The NUMERIC_SHAPING attribute in the text, if present, converts European
+ * digits to other decimal digits before running the bidi algorithm. This
+ * attribute, if present, must be applied to all the text in the paragraph.
+ *
+ * If the entire text is all of the same directionality, then
+ * the method may not perform all the steps described by the algorithm,
+ * i.e., some levels may not be the same as if all steps were performed.
+ * This is not relevant for unidirectional text.
+ * For example, in pure LTR text with numbers the numbers would get
+ * a resolved level of 2 higher than the surrounding text according to
+ * the algorithm. This implementation may set all resolved levels to
+ * the same value in such a case.
+ *
+ * @param paragraph a paragraph of text with optional character and
+ * paragraph attribute information
+ * @stable ICU 3.8
+ */
+ public void setPara(AttributedCharacterIterator paragraph)
+ {
+ byte paraLvl;
+ Boolean runDirection = (Boolean) paragraph.getAttribute(TextAttribute.RUN_DIRECTION);
+ NumericShaper shaper = (NumericShaper) paragraph.getAttribute(TextAttribute.NUMERIC_SHAPING);
+ if (runDirection == null) {
+ paraLvl = INTERNAL_LEVEL_DEFAULT_LTR;
+ } else {
+ paraLvl = (runDirection.equals(TextAttribute.RUN_DIRECTION_LTR)) ?
+ (byte)Bidi.DIRECTION_LEFT_TO_RIGHT : (byte)Bidi.DIRECTION_RIGHT_TO_LEFT;
+ }
+
+ byte[] lvls = null;
+ int len = paragraph.getEndIndex() - paragraph.getBeginIndex();
+ byte[] embeddingLevels = new byte[len];
+ char[] txt = new char[len];
+ int i = 0;
+ char ch = paragraph.first();
+ while (ch != AttributedCharacterIterator.DONE) {
+ txt[i] = ch;
+ Integer embedding = (Integer) paragraph.getAttribute(TextAttribute.BIDI_EMBEDDING);
+ if (embedding != null) {
+ byte level = embedding.byteValue();
+ if (level == 0) {
+ /* no-op */
+ } else if (level < 0) {
+ lvls = embeddingLevels;
+ embeddingLevels[i] = (byte)((0 - level) | INTERNAL_LEVEL_OVERRIDE);
+ } else {
+ lvls = embeddingLevels;
+ embeddingLevels[i] = level;
+ }
+ }
+ ch = paragraph.next();
+ ++i;
+ }
+
+ if (shaper != null) {
+ shaper.shape(txt, 0, len);
+ }
+ setPara(txt, paraLvl, lvls);
+ }
+
+ /**
+ * Specify whether block separators must be allocated level zero,
+ * so that successive paragraphs will progress from left to right.
+ * This method must be called before setPara().
+ * Paragraph separators (B) may appear in the text. Setting them to level zero
+ * means that all paragraph separators (including one possibly appearing
+ * in the last text position) are kept in the reordered text after the text
+ * that they follow in the source text.
+ * When this feature is not enabled, a paragraph separator at the last
+ * position of the text before reordering will go to the first position
+ * of the reordered text when the paragraph level is odd.
+ *
+ * @param ordarParaLTR specifies whether paragraph separators (B) must
+ * receive level 0, so that successive paragraphs progress from left to right.
+ *
+ * @see #setPara
+ * @stable ICU 3.8
+ */
+ private void orderParagraphsLTR(boolean ordarParaLTR) {
+ orderParagraphsLTR = ordarParaLTR;
+ }
+
+ /**
+ * Get the directionality of the text.
+ *
+ * @return a value of LTR, RTL or MIXED
+ * that indicates if the entire text
+ * represented by this object is unidirectional,
+ * and which direction, or if it is mixed-directional.
+ *
+ * @throws IllegalStateException if this call is not preceded by a successful
+ * call to setPara or setLine
+ *
+ * @see #LTR
+ * @see #RTL
+ * @see #MIXED
+ * @stable ICU 3.8
+ */
+ private byte getDirection()
+ {
+ verifyValidParaOrLine();
+ return direction;
+ }
+
+ /**
+ * Get the length of the text.
+ *
+ * @return The length of the text that the Bidi object was
+ * created for.
+ *
+ * @throws IllegalStateException if this call is not preceded by a successful
+ * call to setPara or setLine
+ * @stable ICU 3.8
+ */
+ public int getLength()
+ {
+ verifyValidParaOrLine();
+ return originalLength;
+ }
+
+ /* paragraphs API methods ------------------------------------------------- */
+
+ /**
+ * Get the paragraph level of the text.
+ *
+ * @return The paragraph level. If there are multiple paragraphs, their
+ * level may vary if the required paraLevel is LEVEL_DEFAULT_LTR or
+ * LEVEL_DEFAULT_RTL. In that case, the level of the first paragraph
+ * is returned.
+ *
+ * @throws IllegalStateException if this call is not preceded by a successful
+ * call to setPara or setLine
+ *
+ * @see #LEVEL_DEFAULT_LTR
+ * @see #LEVEL_DEFAULT_RTL
+ * @see #getParagraph
+ * @see #getParagraphByIndex
+ * @stable ICU 3.8
+ */
+ public byte getParaLevel()
+ {
+ verifyValidParaOrLine();
+ return paraLevel;
+ }
+
+ /**
+ * Get the index of a paragraph, given a position within the text.
+ *
+ * @param charIndex is the index of a character within the text, in the
+ * range [0..getProcessedLength()-1].
+ *
+ * @return The index of the paragraph containing the specified position,
+ * starting from 0.
+ *
+ * @throws IllegalStateException if this call is not preceded by a successful
+ * call to setPara or setLine
+ * @throws IllegalArgumentException if charIndex is not within the legal range
+ *
+ * @see com.ibm.icu.text.BidiRun
+ * @see #getProcessedLength
+ * @stable ICU 3.8
+ */
+ public int getParagraphIndex(int charIndex)
+ {
+ verifyValidParaOrLine();
+ BidiBase bidi = paraBidi; /* get Para object if Line object */
+ verifyRange(charIndex, 0, bidi.length);
+ int paraIndex;
+ for (paraIndex = 0; charIndex >= bidi.paras[paraIndex]; paraIndex++) {
+ }
+ return paraIndex;
+ }
+
+ /**
+ * setLine() returns a Bidi object to
+ * contain the reordering information, especially the resolved levels,
+ * for all the characters in a line of text. This line of text is
+ * specified by referring to a Bidi object representing
+ * this information for a piece of text containing one or more paragraphs,
+ * and by specifying a range of indexes in this text.
+ * In the new line object, the indexes will range from 0 to limit-start-1.
+ *
+ * This is used after calling setPara()
+ * for a piece of text, and after line-breaking on that text.
+ * It is not necessary if each paragraph is treated as a single line.
+ *
+ * After line-breaking, rules (L1) and (L2) for the treatment of
+ * trailing WS and for reordering are performed on
+ * a Bidi object that represents a line.
+ *
+ * Important: the line Bidi object may
+ * reference data within the global text Bidi object.
+ * You should not alter the content of the global text object until
+ * you are finished using the line object.
+ *
+ * @param start is the line's first index into the text.
+ *
+ * @param limit is just behind the line's last index into the text
+ * (its last index +1).
+ *
+ * @return a Bidi object that will now represent a line of the text.
+ *
+ * @throws IllegalStateException if this call is not preceded by a successful
+ * call to setPara
+ * @throws IllegalArgumentException if start and limit are not in the range
+ * 0<=start<limit<=getProcessedLength(),
+ * or if the specified line crosses a paragraph boundary
+ *
+ * @see #setPara
+ * @see #getProcessedLength
+ * @stable ICU 3.8
+ */
+ public Bidi setLine(Bidi bidi, BidiBase bidiBase, Bidi newBidi, BidiBase newBidiBase, int start, int limit)
+ {
+ verifyValidPara();
+ verifyRange(start, 0, limit);
+ verifyRange(limit, 0, length+1);
+ if (getParagraphIndex(start) != getParagraphIndex(limit - 1)) {
+ /* the line crosses a paragraph boundary */
+ throw new IllegalArgumentException();
+ }
+
+ return BidiLine.setLine(bidi, this, newBidi, newBidiBase, start, limit);
+ }
+
+ /**
+ * Get the level for one character.
+ *
+ * @param charIndex the index of a character.
+ *
+ * @return The level for the character at charIndex.
+ *
+ * @throws IllegalStateException if this call is not preceded by a successful
+ * call to setPara or setLine
+ * @throws IllegalArgumentException if charIndex is not in the range
+ * 0<=charIndex<getProcessedLength()
+ *
+ * @see #getProcessedLength
+ * @stable ICU 3.8
+ */
+ public byte getLevelAt(int charIndex)
+ {
+ if (charIndex < 0 || charIndex >= length) {
+ return (byte)getBaseLevel();
+ }
+ verifyValidParaOrLine();
+ verifyRange(charIndex, 0, length);
+ return BidiLine.getLevelAt(this, charIndex);
+ }
+
+ /**
+ * Get an array of levels for each character.
+ *
+ * Note that this method may allocate memory under some
+ * circumstances, unlike getLevelAt().
+ *
+ * @return The levels array for the text,
+ * or null if an error occurs.
+ *
+ * @throws IllegalStateException if this call is not preceded by a successful
+ * call to setPara or setLine
+ * @stable ICU 3.8
+ */
+ private byte[] getLevels()
+ {
+ verifyValidParaOrLine();
+ if (length <= 0) {
+ return new byte[0];
+ }
+ return BidiLine.getLevels(this);
+ }
+
+ /**
+ * Get the number of runs.
+ * This method may invoke the actual reordering on the
+ * Bidi object, after setPara()
+ * may have resolved only the levels of the text. Therefore,
+ * countRuns() may have to allocate memory,
+ * and may throw an exception if it fails to do so.
+ *
+ * @return The number of runs.
+ *
+ * @throws IllegalStateException if this call is not preceded by a successful
+ * call to setPara or setLine
+ * @stable ICU 3.8
+ */
+ public int countRuns()
+ {
+ verifyValidParaOrLine();
+ BidiLine.getRuns(this);
+ return runCount;
+ }
+
+ /**
+ * Get a visual-to-logical index map (array) for the characters in the
+ * Bidi (paragraph or line) object.
+ *
+ * Some values in the map may be MAP_NOWHERE if the
+ * corresponding text characters are Bidi marks inserted in the visual
+ * output by the option OPTION_INSERT_MARKS.
+ *
+ * When the visual output is altered by using options of
+ * writeReordered() such as INSERT_LRM_FOR_NUMERIC,
+ * KEEP_BASE_COMBINING, OUTPUT_REVERSE,
+ * REMOVE_BIDI_CONTROLS, the logical positions returned may not
+ * be correct. It is advised to use, when possible, reordering options
+ * such as {@link #OPTION_INSERT_MARKS} and {@link #OPTION_REMOVE_CONTROLS}.
+ *
+ * @return an array of getResultLength()
+ * indexes which will reflect the reordering of the characters.
+ * The index map will result in
+ * indexMap[visualIndex]==logicalIndex, where
+ * indexMap represents the returned array.
+ *
+ * @throws IllegalStateException if this call is not preceded by a successful
+ * call to setPara or setLine
+ *
+ * @see #getLogicalMap
+ * @see #getLogicalIndex
+ * @see #getResultLength
+ * @see #MAP_NOWHERE
+ * @see #OPTION_INSERT_MARKS
+ * @see #writeReordered
+ * @stable ICU 3.8
+ */
+ private int[] getVisualMap()
+ {
+ /* countRuns() checks successful call to setPara/setLine */
+ countRuns();
+ if (resultLength <= 0) {
+ return new int[0];
+ }
+ return BidiLine.getVisualMap(this);
+ }
+
+ /**
+ * This is a convenience method that does not use a Bidi object.
+ * It is intended to be used for when an application has determined the levels
+ * of objects (character sequences) and just needs to have them reordered (L2).
+ * This is equivalent to using getVisualMap() on a
+ * Bidi object.
+ *
+ * @param levels is an array of levels that have been determined by
+ * the application.
+ *
+ * @return an array of levels.length
+ * indexes which will reflect the reordering of the characters.
+ * The index map will result in
+ * indexMap[visualIndex]==logicalIndex, where
+ * indexMap represents the returned array.
+ *
+ * @stable ICU 3.8
+ */
+ private static int[] reorderVisual(byte[] levels)
+ {
+ return BidiLine.reorderVisual(levels);
+ }
+
+ /**
+ * Constant indicating that the base direction depends on the first strong
+ * directional character in the text according to the Unicode Bidirectional
+ * Algorithm. If no strong directional character is present, the base
+ * direction is left-to-right.
+ * @stable ICU 3.8
+ */
+ private static final int INTERNAL_DIRECTION_DEFAULT_LEFT_TO_RIGHT = 0x7e;
+
+ /**
+ * Constant indicating that the base direction depends on the first strong
+ * directional character in the text according to the Unicode Bidirectional
+ * Algorithm. If no strong directional character is present, the base
+ * direction is right-to-left.
+ * @stable ICU 3.8
+ */
+ private static final int INTERMAL_DIRECTION_DEFAULT_RIGHT_TO_LEFT = 0x7f;
+
+ /**
+ * Create Bidi from the given text, embedding, and direction information.
+ * The embeddings array may be null. If present, the values represent
+ * embedding level information. Negative values from -1 to -61 indicate
+ * overrides at the absolute value of the level. Positive values from 1 to
+ * 61 indicate embeddings. Where values are zero, the base embedding level
+ * as determined by the base direction is assumed.
+ *
+ * Note: this constructor calls setPara() internally.
+ *
+ * @param text an array containing the paragraph of text to process.
+ * @param textStart the index into the text array of the start of the
+ * paragraph.
+ * @param embeddings an array containing embedding values for each character
+ * in the paragraph. This can be null, in which case it is assumed
+ * that there is no external embedding information.
+ * @param embStart the index into the embedding array of the start of the
+ * paragraph.
+ * @param paragraphLength the length of the paragraph in the text and
+ * embeddings arrays.
+ * @param flags a collection of flags that control the algorithm. The
+ * algorithm understands the flags DIRECTION_LEFT_TO_RIGHT,
+ * DIRECTION_RIGHT_TO_LEFT, DIRECTION_DEFAULT_LEFT_TO_RIGHT, and
+ * DIRECTION_DEFAULT_RIGHT_TO_LEFT. Other values are reserved.
+ *
+ * @throws IllegalArgumentException if the values in embeddings are
+ * not within the allowed range
+ *
+ * @see #DIRECTION_LEFT_TO_RIGHT
+ * @see #DIRECTION_RIGHT_TO_LEFT
+ * @see #DIRECTION_DEFAULT_LEFT_TO_RIGHT
+ * @see #DIRECTION_DEFAULT_RIGHT_TO_LEFT
+ * @stable ICU 3.8
+ */
+ public BidiBase(char[] text,
+ int textStart,
+ byte[] embeddings,
+ int embStart,
+ int paragraphLength,
+ int flags)
+ {
+ this(0, 0);
+ byte paraLvl;
+ switch (flags) {
+ case Bidi.DIRECTION_LEFT_TO_RIGHT:
+ default:
+ paraLvl = Bidi.DIRECTION_LEFT_TO_RIGHT;
+ break;
+ case Bidi.DIRECTION_RIGHT_TO_LEFT:
+ paraLvl = Bidi.DIRECTION_RIGHT_TO_LEFT;
+ break;
+ case Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT:
+ paraLvl = INTERNAL_LEVEL_DEFAULT_LTR;
+ break;
+ case Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT:
+ paraLvl = INTERNAL_LEVEL_DEFAULT_RTL;
+ break;
+ }
+ byte[] paraEmbeddings;
+ if (embeddings == null) {
+ paraEmbeddings = null;
+ } else {
+ paraEmbeddings = new byte[paragraphLength];
+ byte lev;
+ for (int i = 0; i < paragraphLength; i++) {
+ lev = embeddings[i + embStart];
+ if (lev < 0) {
+ lev = (byte)((- lev) | INTERNAL_LEVEL_OVERRIDE);
+ } else if (lev == 0) {
+ lev = paraLvl;
+ if (paraLvl > MAX_EXPLICIT_LEVEL) {
+ lev &= 1;
+ }
+ }
+ paraEmbeddings[i] = lev;
+ }
+ }
+ if (textStart == 0 && embStart == 0 && paragraphLength == text.length) {
+ setPara(text, paraLvl, paraEmbeddings);
+ } else {
+ char[] paraText = new char[paragraphLength];
+ System.arraycopy(text, textStart, paraText, 0, paragraphLength);
+ setPara(paraText, paraLvl, paraEmbeddings);
+ }
+ }
+
+ /**
+ * Return true if the line is not left-to-right or right-to-left. This means
+ * it either has mixed runs of left-to-right and right-to-left text, or the
+ * base direction differs from the direction of the only run of text.
+ *
+ * @return true if the line is not left-to-right or right-to-left.
+ *
+ * @throws IllegalStateException if this call is not preceded by a successful
+ * call to setPara
+ * @stable ICU 3.8
+ */
+ public boolean isMixed()
+ {
+ return (!isLeftToRight() && !isRightToLeft());
+ }
+
+ /**
+ * Return true if the line is all left-to-right text and the base direction
+ * is left-to-right.
+ *
+ * @return true if the line is all left-to-right text and the base direction
+ * is left-to-right.
+ *
+ * @throws IllegalStateException if this call is not preceded by a successful
+ * call to setPara
+ * @stable ICU 3.8
+ */
+ public boolean isLeftToRight()
+ {
+ return (getDirection() == Bidi.DIRECTION_LEFT_TO_RIGHT && (paraLevel & 1) == 0);
+ }
+
+ /**
+ * Return true if the line is all right-to-left text, and the base direction
+ * is right-to-left
+ *
+ * @return true if the line is all right-to-left text, and the base
+ * direction is right-to-left
+ *
+ * @throws IllegalStateException if this call is not preceded by a successful
+ * call to setPara
+ * @stable ICU 3.8
+ */
+ public boolean isRightToLeft()
+ {
+ return (getDirection() == Bidi.DIRECTION_RIGHT_TO_LEFT && (paraLevel & 1) == 1);
+ }
+
+ /**
+ * Return true if the base direction is left-to-right
+ *
+ * @return true if the base direction is left-to-right
+ *
+ * @throws IllegalStateException if this call is not preceded by a successful
+ * call to setPara or setLine
+ *
+ * @stable ICU 3.8
+ */
+ public boolean baseIsLeftToRight()
+ {
+ return (getParaLevel() == Bidi.DIRECTION_LEFT_TO_RIGHT);
+ }
+
+ /**
+ * Return the base level (0 if left-to-right, 1 if right-to-left).
+ *
+ * @return the base level
+ *
+ * @throws IllegalStateException if this call is not preceded by a successful
+ * call to setPara or setLine
+ *
+ * @stable ICU 3.8
+ */
+ public int getBaseLevel()
+ {
+ return getParaLevel();
+ }
+
+ /**
+ * Compute the logical to visual run mapping
+ */
+ private void getLogicalToVisualRunsMap()
+ {
+ if (isGoodLogicalToVisualRunsMap) {
+ return;
+ }
+ int count = countRuns();
+ if ((logicalToVisualRunsMap == null) ||
+ (logicalToVisualRunsMap.length < count)) {
+ logicalToVisualRunsMap = new int[count];
+ }
+ int i;
+ long[] keys = new long[count];
+ for (i = 0; i < count; i++) {
+ keys[i] = ((long)(runs[i].start)<<32) + i;
+ }
+ Arrays.sort(keys);
+ for (i = 0; i < count; i++) {
+ logicalToVisualRunsMap[i] = (int)(keys[i] & 0x00000000FFFFFFFF);
+ }
+ keys = null;
+ isGoodLogicalToVisualRunsMap = true;
+ }
+
+ /**
+ * Return the level of the nth logical run in this line.
+ *
+ * @param run the index of the run, between 0 and countRuns()-1
+ *
+ * @return the level of the run
+ *
+ * @throws IllegalStateException if this call is not preceded by a successful
+ * call to setPara or setLine
+ * @throws IllegalArgumentException if run is not in
+ * the range 0<=run<countRuns()
+ * @stable ICU 3.8
+ */
+ public int getRunLevel(int run)
+ {
+ verifyValidParaOrLine();
+ BidiLine.getRuns(this);
+ if (runCount == 1) {
+ return getParaLevel();
+ }
+ verifyIndex(run, 0, runCount);
+ getLogicalToVisualRunsMap();
+ return runs[logicalToVisualRunsMap[run]].level;
+ }
+
+ /**
+ * Return the index of the character at the start of the nth logical run in
+ * this line, as an offset from the start of the line.
+ *
+ * @param run the index of the run, between 0 and countRuns()
+ *
+ * @return the start of the run
+ *
+ * @throws IllegalStateException if this call is not preceded by a successful
+ * call to setPara or setLine
+ * @throws IllegalArgumentException if run is not in
+ * the range 0<=run<countRuns()
+ * @stable ICU 3.8
+ */
+ public int getRunStart(int run)
+ {
+ verifyValidParaOrLine();
+ BidiLine.getRuns(this);
+ if (runCount == 1) {
+ return 0;
+ } else if (run == runCount) {
+ return length;
+ }
+ verifyIndex(run, 0, runCount);
+ getLogicalToVisualRunsMap();
+ return runs[logicalToVisualRunsMap[run]].start;
+ }
+
+ /**
+ * Return the index of the character past the end of the nth logical run in
+ * this line, as an offset from the start of the line. For example, this
+ * will return the length of the line for the last run on the line.
+ *
+ * @param run the index of the run, between 0 and countRuns()
+ *
+ * @return the limit of the run
+ *
+ * @throws IllegalStateException if this call is not preceded by a successful
+ * call to setPara or setLine
+ * @throws IllegalArgumentException if run is not in
+ * the range 0<=run<countRuns()
+ * @stable ICU 3.8
+ */
+ public int getRunLimit(int run)
+ {
+ verifyValidParaOrLine();
+ BidiLine.getRuns(this);
+ if (runCount == 1) {
+ return length;
+ }
+ verifyIndex(run, 0, runCount);
+ getLogicalToVisualRunsMap();
+ int idx = logicalToVisualRunsMap[run];
+ int len = idx == 0 ? runs[idx].limit :
+ runs[idx].limit - runs[idx-1].limit;
+ return runs[idx].start + len;
+ }
+
+ /**
+ * Return true if the specified text requires bidi analysis. If this returns
+ * false, the text will display left-to-right. Clients can then avoid
+ * constructing a Bidi object. Text in the Arabic Presentation Forms area of
+ * Unicode is presumed to already be shaped and ordered for display, and so
+ * will not cause this method to return true.
+ *
+ * @param text the text containing the characters to test
+ * @param start the start of the range of characters to test
+ * @param limit the limit of the range of characters to test
+ *
+ * @return true if the range of characters requires bidi analysis
+ *
+ * @stable ICU 3.8
+ */
+ public static boolean requiresBidi(char[] text,
+ int start,
+ int limit)
+ {
+ final int RTLMask = (1 << Bidi.DIRECTION_RIGHT_TO_LEFT |
+ 1 << AL |
+ 1 << RLE |
+ 1 << RLO |
+ 1 << AN);
+
+ if (0 > start || start > limit || limit > text.length) {
+ throw new IllegalArgumentException("Value start " + start +
+ " is out of range 0 to " + limit);
+ }
+ for (int i = start; i < limit; ++i) {
+ if (Character.isHighSurrogate(text[i]) && i < (limit-1) &&
+ Character.isLowSurrogate(text[i+1])) {
+ if (((1 << UCharacter.getDirection(Character.codePointAt(text, i))) & RTLMask) != 0) {
+ return true;
+ }
+ } else if (((1 << UCharacter.getDirection(text[i])) & RTLMask) != 0) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Reorder the objects in the array into visual order based on their levels.
+ * This is a utility method to use when you have a collection of objects
+ * representing runs of text in logical order, each run containing text at a
+ * single level. The elements at index from
+ * objectStart up to objectStart + count in the
+ * objects array will be reordered into visual order assuming
+ * each run of text has the level indicated by the corresponding element in
+ * the levels array (at index - objectStart + levelStart).
+ *
+ * @param levels an array representing the bidi level of each object
+ * @param levelStart the start position in the levels array
+ * @param objects the array of objects to be reordered into visual order
+ * @param objectStart the start position in the objects array
+ * @param count the number of objects to reorder
+ * @stable ICU 3.8
+ */
+ public static void reorderVisually(byte[] levels,
+ int levelStart,
+ Object[] objects,
+ int objectStart,
+ int count)
+ {
+ if (0 > levelStart || levels.length <= levelStart) {
+ throw new IllegalArgumentException("Value levelStart " +
+ levelStart + " is out of range 0 to " +
+ (levels.length-1));
+ }
+ if (0 > objectStart || objects.length <= objectStart) {
+ throw new IllegalArgumentException("Value objectStart " +
+ levelStart + " is out of range 0 to " +
+ (objects.length-1));
+ }
+ if (0 > count || objects.length < (objectStart+count)) {
+ throw new IllegalArgumentException("Value count " +
+ levelStart + " is out of range 0 to " +
+ (objects.length - objectStart));
+ }
+ byte[] reorderLevels = new byte[count];
+ System.arraycopy(levels, levelStart, reorderLevels, 0, count);
+ int[] indexMap = reorderVisual(reorderLevels);
+ Object[] temp = new Object[count];
+ System.arraycopy(objects, objectStart, temp, 0, count);
+ for (int i = 0; i < count; ++i) {
+ objects[objectStart + i] = temp[indexMap[i]];
+ }
+ }
+
+ /**
+ * Display the bidi internal state, used in debugging.
+ */
+ public String toString() {
+ StringBuffer buf = new StringBuffer(super.toString());
+
+ buf.append("[dir: " + direction);
+ buf.append(" baselevel: " + paraLevel);
+ buf.append(" length: " + length);
+ buf.append(" runs: ");
+ if (levels == null) {
+ buf.append("null");
+ } else {
+ buf.append('[');
+ buf.append(levels[0]);
+ for (int i = 0; i < levels.length; i++) {
+ buf.append(' ');
+ buf.append(levels[i]);
+ }
+ buf.append(']');
+ }
+ buf.append(" text: [0x");
+ buf.append(Integer.toHexString(text[0]));
+ for (int i = 0; i < text.length; i++) {
+ buf.append(" 0x");
+ buf.append(Integer.toHexString(text[i]));
+ }
+ buf.append(']');
+ buf.append(']');
+
+ return buf.toString();
+ }
+
+}
diff --git a/jdk/src/share/classes/sun/text/bidi/BidiLine.java b/jdk/src/share/classes/sun/text/bidi/BidiLine.java
new file mode 100644
index 00000000000..311cf3349cd
--- /dev/null
+++ b/jdk/src/share/classes/sun/text/bidi/BidiLine.java
@@ -0,0 +1,849 @@
+/*
+ * Portions Copyright 2009 Sun Microsystems, Inc. All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+/*
+ *******************************************************************************
+ * (C) Copyright IBM Corp. and others, 1996-2009 - All Rights Reserved *
+ * *
+ * The original version of this source code and documentation is copyrighted *
+ * and owned by IBM, These materials are provided under terms of a License *
+ * Agreement between IBM and Sun. This technology is protected by multiple *
+ * US and International patents. This notice and attribution to IBM may not *
+ * to removed. *
+ *******************************************************************************
+ */
+/* Written by Simon Montagu, Matitiahu Allouche
+ * (ported from C code written by Markus W. Scherer)
+ */
+
+package sun.text.bidi;
+
+import java.text.Bidi;
+import java.util.Arrays;
+
+public final class BidiLine {
+
+ /*
+ * General remarks about the functions in this file:
+ *
+ * These functions deal with the aspects of potentially mixed-directional
+ * text in a single paragraph or in a line of a single paragraph
+ * which has already been processed according to
+ * the Unicode 3.0 Bidi algorithm as defined in
+ * http://www.unicode.org/unicode/reports/tr9/ , version 13,
+ * also described in The Unicode Standard, Version 4.0.1 .
+ *
+ * This means that there is a Bidi object with a levels
+ * and a dirProps array.
+ * paraLevel and direction are also set.
+ * Only if the length of the text is zero, then levels==dirProps==NULL.
+ *
+ * The overall directionality of the paragraph
+ * or line is used to bypass the reordering steps if possible.
+ * Even purely RTL text does not need reordering there because
+ * the getLogical/VisualIndex() methods can compute the
+ * index on the fly in such a case.
+ *
+ * The implementation of the access to same-level-runs and of the reordering
+ * do attempt to provide better performance and less memory usage compared to
+ * a direct implementation of especially rule (L2) with an array of
+ * one (32-bit) integer per text character.
+ *
+ * Here, the levels array is scanned as soon as necessary, and a vector of
+ * same-level-runs is created. Reordering then is done on this vector.
+ * For each run of text positions that were resolved to the same level,
+ * only 8 bytes are stored: the first text position of the run and the visual
+ * position behind the run after reordering.
+ * One sign bit is used to hold the directionality of the run.
+ * This is inefficient if there are many very short runs. If the average run
+ * length is <2, then this uses more memory.
+ *
+ * In a further attempt to save memory, the levels array is never changed
+ * after all the resolution rules (Xn, Wn, Nn, In).
+ * Many methods have to consider the field trailingWSStart:
+ * if it is less than length, then there is an implicit trailing run
+ * at the paraLevel,
+ * which is not reflected in the levels array.
+ * This allows a line Bidi object to use the same levels array as
+ * its paragraph parent object.
+ *
+ * When a Bidi object is created for a line of a paragraph, then the
+ * paragraph's levels and dirProps arrays are reused by way of setting
+ * a pointer into them, not by copying. This again saves memory and forbids to
+ * change the now shared levels for (L1).
+ */
+
+ /* handle trailing WS (L1) -------------------------------------------------- */
+
+ /*
+ * setTrailingWSStart() sets the start index for a trailing
+ * run of WS in the line. This is necessary because we do not modify
+ * the paragraph's levels array that we just point into.
+ * Using trailingWSStart is another form of performing (L1).
+ *
+ * To make subsequent operations easier, we also include the run
+ * before the WS if it is at the paraLevel - we merge the two here.
+ *
+ * This method is called only from setLine(), so paraLevel is
+ * set correctly for the line even when contextual multiple paragraphs.
+ */
+
+ static void setTrailingWSStart(BidiBase bidiBase)
+ {
+ byte[] dirProps = bidiBase.dirProps;
+ byte[] levels = bidiBase.levels;
+ int start = bidiBase.length;
+ byte paraLevel = bidiBase.paraLevel;
+
+ /* If the line is terminated by a block separator, all preceding WS etc...
+ are already set to paragraph level.
+ Setting trailingWSStart to pBidi->length will avoid changing the
+ level of B chars from 0 to paraLevel in getLevels when
+ orderParagraphsLTR==TRUE
+ */
+ if (BidiBase.NoContextRTL(dirProps[start - 1]) == BidiBase.B) {
+ bidiBase.trailingWSStart = start; /* currently == bidiBase.length */
+ return;
+ }
+ /* go backwards across all WS, BN, explicit codes */
+ while (start > 0 &&
+ (BidiBase.DirPropFlagNC(dirProps[start - 1]) & BidiBase.MASK_WS) != 0) {
+ --start;
+ }
+
+ /* if the WS run can be merged with the previous run then do so here */
+ while (start > 0 && levels[start - 1] == paraLevel) {
+ --start;
+ }
+
+ bidiBase.trailingWSStart=start;
+ }
+
+ public static Bidi setLine(Bidi bidi, BidiBase paraBidi,
+ Bidi newBidi, BidiBase newBidiBase,
+ int start, int limit) {
+ int length;
+
+ BidiBase lineBidi = newBidiBase;
+
+ /* set the values in lineBidi from its paraBidi parent */
+ /* class members are already initialized to 0 */
+ // lineBidi.paraBidi = null; /* mark unfinished setLine */
+ // lineBidi.flags = 0;
+ // lineBidi.controlCount = 0;
+
+ length = lineBidi.length = lineBidi.originalLength =
+ lineBidi.resultLength = limit - start;
+
+ lineBidi.text = new char[length];
+ System.arraycopy(paraBidi.text, start, lineBidi.text, 0, length);
+ lineBidi.paraLevel = paraBidi.GetParaLevelAt(start);
+ lineBidi.paraCount = paraBidi.paraCount;
+ lineBidi.runs = new BidiRun[0];
+ if (paraBidi.controlCount > 0) {
+ int j;
+ for (j = start; j < limit; j++) {
+ if (BidiBase.IsBidiControlChar(paraBidi.text[j])) {
+ lineBidi.controlCount++;
+ }
+ }
+ lineBidi.resultLength -= lineBidi.controlCount;
+ }
+ /* copy proper subset of DirProps */
+ lineBidi.getDirPropsMemory(length);
+ lineBidi.dirProps = lineBidi.dirPropsMemory;
+ System.arraycopy(paraBidi.dirProps, start, lineBidi.dirProps, 0,
+ length);
+ /* copy proper subset of Levels */
+ lineBidi.getLevelsMemory(length);
+ lineBidi.levels = lineBidi.levelsMemory;
+ System.arraycopy(paraBidi.levels, start, lineBidi.levels, 0,
+ length);
+ lineBidi.runCount = -1;
+
+ if (paraBidi.direction != BidiBase.MIXED) {
+ /* the parent is already trivial */
+ lineBidi.direction = paraBidi.direction;
+
+ /*
+ * The parent's levels are all either
+ * implicitly or explicitly ==paraLevel;
+ * do the same here.
+ */
+ if (paraBidi.trailingWSStart <= start) {
+ lineBidi.trailingWSStart = 0;
+ } else if (paraBidi.trailingWSStart < limit) {
+ lineBidi.trailingWSStart = paraBidi.trailingWSStart - start;
+ } else {
+ lineBidi.trailingWSStart = length;
+ }
+ } else {
+ byte[] levels = lineBidi.levels;
+ int i, trailingWSStart;
+ byte level;
+
+ setTrailingWSStart(lineBidi);
+ trailingWSStart = lineBidi.trailingWSStart;
+
+ /* recalculate lineBidi.direction */
+ if (trailingWSStart == 0) {
+ /* all levels are at paraLevel */
+ lineBidi.direction = (byte)(lineBidi.paraLevel & 1);
+ } else {
+ /* get the level of the first character */
+ level = (byte)(levels[0] & 1);
+
+ /* if there is anything of a different level, then the line
+ is mixed */
+ if (trailingWSStart < length &&
+ (lineBidi.paraLevel & 1) != level) {
+ /* the trailing WS is at paraLevel, which differs from
+ levels[0] */
+ lineBidi.direction = BidiBase.MIXED;
+ } else {
+ /* see if levels[1..trailingWSStart-1] have the same
+ direction as levels[0] and paraLevel */
+ for (i = 1; ; i++) {
+ if (i == trailingWSStart) {
+ /* the direction values match those in level */
+ lineBidi.direction = level;
+ break;
+ } else if ((levels[i] & 1) != level) {
+ lineBidi.direction = BidiBase.MIXED;
+ break;
+ }
+ }
+ }
+ }
+
+ switch(lineBidi.direction) {
+ case Bidi.DIRECTION_LEFT_TO_RIGHT:
+ /* make sure paraLevel is even */
+ lineBidi.paraLevel = (byte)
+ ((lineBidi.paraLevel + 1) & ~1);
+
+ /* all levels are implicitly at paraLevel (important for
+ getLevels()) */
+ lineBidi.trailingWSStart = 0;
+ break;
+ case Bidi.DIRECTION_RIGHT_TO_LEFT:
+ /* make sure paraLevel is odd */
+ lineBidi.paraLevel |= 1;
+
+ /* all levels are implicitly at paraLevel (important for
+ getLevels()) */
+ lineBidi.trailingWSStart = 0;
+ break;
+ default:
+ break;
+ }
+ }
+
+ newBidiBase.paraBidi = paraBidi; /* mark successful setLine */
+ return newBidi;
+ }
+
+ static byte getLevelAt(BidiBase bidiBase, int charIndex)
+ {
+ /* return paraLevel if in the trailing WS run, otherwise the real level */
+ if (bidiBase.direction != BidiBase.MIXED || charIndex >= bidiBase.trailingWSStart) {
+ return bidiBase.GetParaLevelAt(charIndex);
+ } else {
+ return bidiBase.levels[charIndex];
+ }
+ }
+
+ static byte[] getLevels(BidiBase bidiBase)
+ {
+ int start = bidiBase.trailingWSStart;
+ int length = bidiBase.length;
+
+ if (start != length) {
+ /* the current levels array does not reflect the WS run */
+ /*
+ * After the previous if(), we know that the levels array
+ * has an implicit trailing WS run and therefore does not fully
+ * reflect itself all the levels.
+ * This must be a Bidi object for a line, and
+ * we need to create a new levels array.
+ */
+ /* bidiBase.paraLevel is ok even if contextual multiple paragraphs,
+ since bidiBase is a line object */
+ Arrays.fill(bidiBase.levels, start, length, bidiBase.paraLevel);
+
+ /* this new levels array is set for the line and reflects the WS run */
+ bidiBase.trailingWSStart = length;
+ }
+ if (length < bidiBase.levels.length) {
+ byte[] levels = new byte[length];
+ System.arraycopy(bidiBase.levels, 0, levels, 0, length);
+ return levels;
+ }
+ return bidiBase.levels;
+ }
+
+ static BidiRun getLogicalRun(BidiBase bidiBase, int logicalPosition)
+ {
+ /* this is done based on runs rather than on levels since levels have
+ a special interpretation when REORDER_RUNS_ONLY
+ */
+ BidiRun newRun = new BidiRun(), iRun;
+ getRuns(bidiBase);
+ int runCount = bidiBase.runCount;
+ int visualStart = 0, logicalLimit = 0;
+ iRun = bidiBase.runs[0];
+
+ for (int i = 0; i < runCount; i++) {
+ iRun = bidiBase.runs[i];
+ logicalLimit = iRun.start + iRun.limit - visualStart;
+ if ((logicalPosition >= iRun.start) &&
+ (logicalPosition < logicalLimit)) {
+ break;
+ }
+ visualStart = iRun.limit;
+ }
+ newRun.start = iRun.start;
+ newRun.limit = logicalLimit;
+ newRun.level = iRun.level;
+ return newRun;
+ }
+
+ /* in trivial cases there is only one trivial run; called by getRuns() */
+ private static void getSingleRun(BidiBase bidiBase, byte level) {
+ /* simple, single-run case */
+ bidiBase.runs = bidiBase.simpleRuns;
+ bidiBase.runCount = 1;
+
+ /* fill and reorder the single run */
+ bidiBase.runs[0] = new BidiRun(0, bidiBase.length, level);
+ }
+
+ /* reorder the runs array (L2) ---------------------------------------------- */
+
+ /*
+ * Reorder the same-level runs in the runs array.
+ * Here, runCount>1 and maxLevel>=minLevel>=paraLevel.
+ * All the visualStart fields=logical start before reordering.
+ * The "odd" bits are not set yet.
+ *
+ * Reordering with this data structure lends itself to some handy shortcuts:
+ *
+ * Since each run is moved but not modified, and since at the initial maxLevel
+ * each sequence of same-level runs consists of only one run each, we
+ * don't need to do anything there and can predecrement maxLevel.
+ * In many simple cases, the reordering is thus done entirely in the
+ * index mapping.
+ * Also, reordering occurs only down to the lowest odd level that occurs,
+ * which is minLevel|1. However, if the lowest level itself is odd, then
+ * in the last reordering the sequence of the runs at this level or higher
+ * will be all runs, and we don't need the elaborate loop to search for them.
+ * This is covered by ++minLevel instead of minLevel|=1 followed
+ * by an extra reorder-all after the reorder-some loop.
+ * About a trailing WS run:
+ * Such a run would need special treatment because its level is not
+ * reflected in levels[] if this is not a paragraph object.
+ * Instead, all characters from trailingWSStart on are implicitly at
+ * paraLevel.
+ * However, for all maxLevel>paraLevel, this run will never be reordered
+ * and does not need to be taken into account. maxLevel==paraLevel is only reordered
+ * if minLevel==paraLevel is odd, which is done in the extra segment.
+ * This means that for the main reordering loop we don't need to consider
+ * this run and can --runCount. If it is later part of the all-runs
+ * reordering, then runCount is adjusted accordingly.
+ */
+ private static void reorderLine(BidiBase bidiBase, byte minLevel, byte maxLevel) {
+
+ /* nothing to do? */
+ if (maxLevel<=(minLevel|1)) {
+ return;
+ }
+
+ BidiRun[] runs;
+ BidiRun tempRun;
+ byte[] levels;
+ int firstRun, endRun, limitRun, runCount;
+
+ /*
+ * Reorder only down to the lowest odd level
+ * and reorder at an odd minLevel in a separate, simpler loop.
+ * See comments above for why minLevel is always incremented.
+ */
+ ++minLevel;
+
+ runs = bidiBase.runs;
+ levels = bidiBase.levels;
+ runCount = bidiBase.runCount;
+
+ /* do not include the WS run at paraLevel<=old minLevel except in the simple loop */
+ if (bidiBase.trailingWSStart < bidiBase.length) {
+ --runCount;
+ }
+
+ while (--maxLevel >= minLevel) {
+ firstRun = 0;
+
+ /* loop for all sequences of runs */
+ for ( ; ; ) {
+ /* look for a sequence of runs that are all at >=maxLevel */
+ /* look for the first run of such a sequence */
+ while (firstRun < runCount && levels[runs[firstRun].start] < maxLevel) {
+ ++firstRun;
+ }
+ if (firstRun >= runCount) {
+ break; /* no more such runs */
+ }
+
+ /* look for the limit run of such a sequence (the run behind it) */
+ for (limitRun = firstRun; ++limitRun < runCount &&
+ levels[runs[limitRun].start]>=maxLevel; ) {}
+
+ /* Swap the entire sequence of runs from firstRun to limitRun-1. */
+ endRun = limitRun - 1;
+ while (firstRun < endRun) {
+ tempRun = runs[firstRun];
+ runs[firstRun] = runs[endRun];
+ runs[endRun] = tempRun;
+ ++firstRun;
+ --endRun;
+ }
+
+ if (limitRun == runCount) {
+ break; /* no more such runs */
+ } else {
+ firstRun = limitRun + 1;
+ }
+ }
+ }
+
+ /* now do maxLevel==old minLevel (==odd!), see above */
+ if ((minLevel & 1) == 0) {
+ firstRun = 0;
+
+ /* include the trailing WS run in this complete reordering */
+ if (bidiBase.trailingWSStart == bidiBase.length) {
+ --runCount;
+ }
+
+ /* Swap the entire sequence of all runs. (endRun==runCount) */
+ while (firstRun < runCount) {
+ tempRun = runs[firstRun];
+ runs[firstRun] = runs[runCount];
+ runs[runCount] = tempRun;
+ ++firstRun;
+ --runCount;
+ }
+ }
+ }
+
+ /* compute the runs array --------------------------------------------------- */
+
+ static int getRunFromLogicalIndex(BidiBase bidiBase, int logicalIndex) {
+ BidiRun[] runs = bidiBase.runs;
+ int runCount = bidiBase.runCount, visualStart = 0, i, length, logicalStart;
+
+ for (i = 0; i < runCount; i++) {
+ length = runs[i].limit - visualStart;
+ logicalStart = runs[i].start;
+ if ((logicalIndex >= logicalStart) && (logicalIndex < (logicalStart+length))) {
+ return i;
+ }
+ visualStart += length;
+ }
+ /* we should never get here */
+ throw new IllegalStateException("Internal ICU error in getRunFromLogicalIndex");
+ }
+
+ /*
+ * Compute the runs array from the levels array.
+ * After getRuns() returns true, runCount is guaranteed to be >0
+ * and the runs are reordered.
+ * Odd-level runs have visualStart on their visual right edge and
+ * they progress visually to the left.
+ * If option OPTION_INSERT_MARKS is set, insertRemove will contain the
+ * sum of appropriate LRM/RLM_BEFORE/AFTER flags.
+ * If option OPTION_REMOVE_CONTROLS is set, insertRemove will contain the
+ * negative number of BiDi control characters within this run.
+ */
+ static void getRuns(BidiBase bidiBase) {
+ /*
+ * This method returns immediately if the runs are already set. This
+ * includes the case of length==0 (handled in setPara)..
+ */
+ if (bidiBase.runCount >= 0) {
+ return;
+ }
+ if (bidiBase.direction != BidiBase.MIXED) {
+ /* simple, single-run case - this covers length==0 */
+ /* bidiBase.paraLevel is ok even for contextual multiple paragraphs */
+ getSingleRun(bidiBase, bidiBase.paraLevel);
+ } else /* BidiBase.MIXED, length>0 */ {
+ /* mixed directionality */
+ int length = bidiBase.length, limit;
+ byte[] levels = bidiBase.levels;
+ int i, runCount;
+ byte level = BidiBase.INTERNAL_LEVEL_DEFAULT_LTR; /* initialize with no valid level */
+ /*
+ * If there are WS characters at the end of the line
+ * and the run preceding them has a level different from
+ * paraLevel, then they will form their own run at paraLevel (L1).
+ * Count them separately.
+ * We need some special treatment for this in order to not
+ * modify the levels array which a line Bidi object shares
+ * with its paragraph parent and its other line siblings.
+ * In other words, for the trailing WS, it may be
+ * levels[]!=paraLevel but we have to treat it like it were so.
+ */
+ limit = bidiBase.trailingWSStart;
+ /* count the runs, there is at least one non-WS run, and limit>0 */
+ runCount = 0;
+ for (i = 0; i < limit; ++i) {
+ /* increment runCount at the start of each run */
+ if (levels[i] != level) {
+ ++runCount;
+ level = levels[i];
+ }
+ }
+
+ /*
+ * We don't need to see if the last run can be merged with a trailing
+ * WS run because setTrailingWSStart() would have done that.
+ */
+ if (runCount == 1 && limit == length) {
+ /* There is only one non-WS run and no trailing WS-run. */
+ getSingleRun(bidiBase, levels[0]);
+ } else /* runCount>1 || limit 1 */
+ bidiBase.getRunsMemory(runCount);
+ runs = bidiBase.runsMemory;
+
+ /* set the runs */
+ /* FOOD FOR THOUGHT: this could be optimized, e.g.:
+ * 464->444, 484->444, 575->555, 595->555
+ * However, that would take longer. Check also how it would
+ * interact with BiDi control removal and inserting Marks.
+ */
+ runIndex = 0;
+
+ /* search for the run limits and initialize visualLimit values with the run lengths */
+ i = 0;
+ do {
+ /* prepare this run */
+ start = i;
+ level = levels[i];
+ if (level < minLevel) {
+ minLevel = level;
+ }
+ if (level > maxLevel) {
+ maxLevel = level;
+ }
+
+ /* look for the run limit */
+ while (++i < limit && levels[i] == level) {}
+
+ /* i is another run limit */
+ runs[runIndex] = new BidiRun(start, i - start, level);
+ ++runIndex;
+ } while (i < limit);
+
+ if (limit < length) {
+ /* there is a separate WS run */
+ runs[runIndex] = new BidiRun(limit, length - limit, bidiBase.paraLevel);
+ /* For the trailing WS run, bidiBase.paraLevel is ok even
+ if contextual multiple paragraphs. */
+ if (bidiBase.paraLevel < minLevel) {
+ minLevel = bidiBase.paraLevel;
+ }
+ }
+
+ /* set the object fields */
+ bidiBase.runs = runs;
+ bidiBase.runCount = runCount;
+
+ reorderLine(bidiBase, minLevel, maxLevel);
+
+ /* now add the direction flags and adjust the visualLimit's to be just that */
+ /* this loop will also handle the trailing WS run */
+ limit = 0;
+ for (i = 0; i < runCount; ++i) {
+ runs[i].level = levels[runs[i].start];
+ limit = (runs[i].limit += limit);
+ }
+
+ /* Set the embedding level for the trailing WS run. */
+ /* For a RTL paragraph, it will be the *first* run in visual order. */
+ /* For the trailing WS run, bidiBase.paraLevel is ok even if
+ contextual multiple paragraphs. */
+ if (runIndex < runCount) {
+ int trailingRun = ((bidiBase.paraLevel & 1) != 0)? 0 : runIndex;
+ runs[trailingRun].level = bidiBase.paraLevel;
+ }
+ }
+ }
+
+ /* handle insert LRM/RLM BEFORE/AFTER run */
+ if (bidiBase.insertPoints.size > 0) {
+ BidiBase.Point point;
+ int runIndex, ip;
+ for (ip = 0; ip < bidiBase.insertPoints.size; ip++) {
+ point = bidiBase.insertPoints.points[ip];
+ runIndex = getRunFromLogicalIndex(bidiBase, point.pos);
+ bidiBase.runs[runIndex].insertRemove |= point.flag;
+ }
+ }
+
+ /* handle remove BiDi control characters */
+ if (bidiBase.controlCount > 0) {
+ int runIndex, ic;
+ char c;
+ for (ic = 0; ic < bidiBase.length; ic++) {
+ c = bidiBase.text[ic];
+ if (BidiBase.IsBidiControlChar(c)) {
+ runIndex = getRunFromLogicalIndex(bidiBase, ic);
+ bidiBase.runs[runIndex].insertRemove--;
+ }
+ }
+ }
+ }
+
+ static int[] prepareReorder(byte[] levels, byte[] pMinLevel, byte[] pMaxLevel)
+ {
+ int start;
+ byte level, minLevel, maxLevel;
+
+ if (levels == null || levels.length <= 0) {
+ return null;
+ }
+
+ /* determine minLevel and maxLevel */
+ minLevel = BidiBase.MAX_EXPLICIT_LEVEL + 1;
+ maxLevel = 0;
+ for (start = levels.length; start>0; ) {
+ level = levels[--start];
+ if (level > BidiBase.MAX_EXPLICIT_LEVEL + 1) {
+ return null;
+ }
+ if (level < minLevel) {
+ minLevel = level;
+ }
+ if (level > maxLevel) {
+ maxLevel = level;
+ }
+ }
+ pMinLevel[0] = minLevel;
+ pMaxLevel[0] = maxLevel;
+
+ /* initialize the index map */
+ int[] indexMap = new int[levels.length];
+ for (start = levels.length; start > 0; ) {
+ --start;
+ indexMap[start] = start;
+ }
+
+ return indexMap;
+ }
+
+ static int[] reorderVisual(byte[] levels)
+ {
+ byte[] aMinLevel = new byte[1];
+ byte[] aMaxLevel = new byte[1];
+ int start, end, limit, temp;
+ byte minLevel, maxLevel;
+
+ int[] indexMap = prepareReorder(levels, aMinLevel, aMaxLevel);
+ if (indexMap == null) {
+ return null;
+ }
+
+ minLevel = aMinLevel[0];
+ maxLevel = aMaxLevel[0];
+
+ /* nothing to do? */
+ if (minLevel == maxLevel && (minLevel & 1) == 0) {
+ return indexMap;
+ }
+
+ /* reorder only down to the lowest odd level */
+ minLevel |= 1;
+
+ /* loop maxLevel..minLevel */
+ do {
+ start = 0;
+
+ /* loop for all sequences of levels to reorder at the current maxLevel */
+ for ( ; ; ) {
+ /* look for a sequence of levels that are all at >=maxLevel */
+ /* look for the first index of such a sequence */
+ while (start < levels.length && levels[start] < maxLevel) {
+ ++start;
+ }
+ if (start >= levels.length) {
+ break; /* no more such runs */
+ }
+
+ /* look for the limit of such a sequence (the index behind it) */
+ for (limit = start; ++limit < levels.length && levels[limit] >= maxLevel; ) {}
+
+ /*
+ * Swap the entire interval of indexes from start to limit-1.
+ * We don't need to swap the levels for the purpose of this
+ * algorithm: the sequence of levels that we look at does not
+ * move anyway.
+ */
+ end = limit - 1;
+ while (start < end) {
+ temp = indexMap[start];
+ indexMap[start] = indexMap[end];
+ indexMap[end] = temp;
+
+ ++start;
+ --end;
+ }
+
+ if (limit == levels.length) {
+ break; /* no more such sequences */
+ } else {
+ start = limit + 1;
+ }
+ }
+ } while (--maxLevel >= minLevel);
+
+ return indexMap;
+ }
+
+ static int[] getVisualMap(BidiBase bidiBase)
+ {
+ /* fill a visual-to-logical index map using the runs[] */
+ BidiRun[] runs = bidiBase.runs;
+ int logicalStart, visualStart, visualLimit;
+ int allocLength = bidiBase.length > bidiBase.resultLength ? bidiBase.length
+ : bidiBase.resultLength;
+ int[] indexMap = new int[allocLength];
+
+ visualStart = 0;
+ int idx = 0;
+ for (int j = 0; j < bidiBase.runCount; ++j) {
+ logicalStart = runs[j].start;
+ visualLimit = runs[j].limit;
+ if (runs[j].isEvenRun()) {
+ do { /* LTR */
+ indexMap[idx++] = logicalStart++;
+ } while (++visualStart < visualLimit);
+ } else {
+ logicalStart += visualLimit - visualStart; /* logicalLimit */
+ do { /* RTL */
+ indexMap[idx++] = --logicalStart;
+ } while (++visualStart < visualLimit);
+ }
+ /* visualStart==visualLimit; */
+ }
+
+ if (bidiBase.insertPoints.size > 0) {
+ int markFound = 0, runCount = bidiBase.runCount;
+ int insertRemove, i, j, k;
+ runs = bidiBase.runs;
+ /* count all inserted marks */
+ for (i = 0; i < runCount; i++) {
+ insertRemove = runs[i].insertRemove;
+ if ((insertRemove & (BidiBase.LRM_BEFORE|BidiBase.RLM_BEFORE)) > 0) {
+ markFound++;
+ }
+ if ((insertRemove & (BidiBase.LRM_AFTER|BidiBase.RLM_AFTER)) > 0) {
+ markFound++;
+ }
+ }
+ /* move back indexes by number of preceding marks */
+ k = bidiBase.resultLength;
+ for (i = runCount - 1; i >= 0 && markFound > 0; i--) {
+ insertRemove = runs[i].insertRemove;
+ if ((insertRemove & (BidiBase.LRM_AFTER|BidiBase.RLM_AFTER)) > 0) {
+ indexMap[--k] = BidiBase.MAP_NOWHERE;
+ markFound--;
+ }
+ visualStart = i > 0 ? runs[i-1].limit : 0;
+ for (j = runs[i].limit - 1; j >= visualStart && markFound > 0; j--) {
+ indexMap[--k] = indexMap[j];
+ }
+ if ((insertRemove & (BidiBase.LRM_BEFORE|BidiBase.RLM_BEFORE)) > 0) {
+ indexMap[--k] = BidiBase.MAP_NOWHERE;
+ markFound--;
+ }
+ }
+ }
+ else if (bidiBase.controlCount > 0) {
+ int runCount = bidiBase.runCount, logicalEnd;
+ int insertRemove, length, i, j, k, m;
+ char uchar;
+ boolean evenRun;
+ runs = bidiBase.runs;
+ visualStart = 0;
+ /* move forward indexes by number of preceding controls */
+ k = 0;
+ for (i = 0; i < runCount; i++, visualStart += length) {
+ length = runs[i].limit - visualStart;
+ insertRemove = runs[i].insertRemove;
+ /* if no control found yet, nothing to do in this run */
+ if ((insertRemove == 0) && (k == visualStart)) {
+ k += length;
+ continue;
+ }
+ /* if no control in this run */
+ if (insertRemove == 0) {
+ visualLimit = runs[i].limit;
+ for (j = visualStart; j < visualLimit; j++) {
+ indexMap[k++] = indexMap[j];
+ }
+ continue;
+ }
+ logicalStart = runs[i].start;
+ evenRun = runs[i].isEvenRun();
+ logicalEnd = logicalStart + length - 1;
+ for (j = 0; j < length; j++) {
+ m = evenRun ? logicalStart + j : logicalEnd - j;
+ uchar = bidiBase.text[m];
+ if (!BidiBase.IsBidiControlChar(uchar)) {
+ indexMap[k++] = m;
+ }
+ }
+ }
+ }
+ if (allocLength == bidiBase.resultLength) {
+ return indexMap;
+ }
+ int[] newMap = new int[bidiBase.resultLength];
+ System.arraycopy(indexMap, 0, newMap, 0, bidiBase.resultLength);
+ return newMap;
+ }
+
+}
diff --git a/jdk/src/share/classes/sun/text/bidi/BidiRun.java b/jdk/src/share/classes/sun/text/bidi/BidiRun.java
new file mode 100644
index 00000000000..8ff6cc2f80f
--- /dev/null
+++ b/jdk/src/share/classes/sun/text/bidi/BidiRun.java
@@ -0,0 +1,124 @@
+/*
+ * Portions Copyright 2009 Sun Microsystems, Inc. All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+/*
+ *******************************************************************************
+ * (C) Copyright IBM Corp. and others, 1996-2009 - All Rights Reserved *
+ * *
+ * The original version of this source code and documentation is copyrighted *
+ * and owned by IBM, These materials are provided under terms of a License *
+ * Agreement between IBM and Sun. This technology is protected by multiple *
+ * US and International patents. This notice and attribution to IBM may not *
+ * to removed. *
+ *******************************************************************************
+ */
+/* Written by Simon Montagu, Matitiahu Allouche
+ * (ported from C code written by Markus W. Scherer)
+ */
+
+package sun.text.bidi;
+
+/**
+ * A BidiRun represents a sequence of characters at the same embedding level.
+ * The Bidi algorithm decomposes a piece of text into sequences of characters
+ * at the same embedding level, each such sequence is called a run
.
+ *
+ * A BidiRun represents such a run by storing its essential properties,
+ * but does not duplicate the characters which form the run.
+ *
+ *
The "limit" of the run is the position just after the
+ * last character, i.e., one more than that position.
+ *
+ *
This class has no public constructor, and its members cannot be
+ * modified by users.
+ *
+ * @see com.ibm.icu.text.Bidi
+ */
+public class BidiRun {
+
+ int start; /* first logical position of the run */
+ int limit; /* last visual position of the run +1 */
+ int insertRemove; /* if >0, flags for inserting LRM/RLM before/after run,
+ if <0, count of bidi controls within run */
+ byte level;
+
+ /*
+ * Default constructor
+ *
+ * Note that members start and limit of a run instance have different
+ * meanings depending whether the run is part of the runs array of a Bidi
+ * object, or if it is a reference returned by getVisualRun() or
+ * getLogicalRun().
+ * For a member of the runs array of a Bidi object,
+ * - start is the first logical position of the run in the source text.
+ * - limit is one after the last visual position of the run.
+ * For a reference returned by getLogicalRun() or getVisualRun(),
+ * - start is the first logical position of the run in the source text.
+ * - limit is one after the last logical position of the run.
+ */
+ BidiRun()
+ {
+ this(0, 0, (byte)0);
+ }
+
+ /*
+ * Constructor
+ */
+ BidiRun(int start, int limit, byte embeddingLevel)
+ {
+ this.start = start;
+ this.limit = limit;
+ this.level = embeddingLevel;
+ }
+
+ /*
+ * Copy the content of a BidiRun instance
+ */
+ void copyFrom(BidiRun run)
+ {
+ this.start = run.start;
+ this.limit = run.limit;
+ this.level = run.level;
+ this.insertRemove = run.insertRemove;
+ }
+
+ /**
+ * Get level of run
+ */
+ public byte getEmbeddingLevel()
+ {
+ return level;
+ }
+
+ /**
+ * Check if run level is even
+ * @return true if the embedding level of this run is even, i.e. it is a
+ * left-to-right run.
+ */
+ boolean isEvenRun()
+ {
+ return (level & 1) == 0;
+ }
+
+}
diff --git a/jdk/src/share/classes/sun/text/normalizer/UCharacter.java b/jdk/src/share/classes/sun/text/normalizer/UCharacter.java
index 8225517f07c..4ff5695dd3e 100644
--- a/jdk/src/share/classes/sun/text/normalizer/UCharacter.java
+++ b/jdk/src/share/classes/sun/text/normalizer/UCharacter.java
@@ -1,5 +1,5 @@
/*
- * Portions Copyright 2005-2009 Sun Microsystems, Inc. All Rights Reserved.
+ * Portions Copyright 2009 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -355,7 +355,7 @@ public final class UCharacter
private static int getEuropeanDigit(int ch) {
if ((ch > 0x7a && ch < 0xff21)
|| ch < 0x41 || (ch > 0x5a && ch < 0x61)
- || ch > 0xff5a || (ch > 0xff31 && ch < 0xff41)) {
+ || ch > 0xff5a || (ch > 0xff3a && ch < 0xff41)) {
return -1;
}
if (ch <= 0x7a) {
diff --git a/jdk/src/share/native/sun/font/bidi/cmemory.h b/jdk/src/share/native/sun/font/bidi/cmemory.h
deleted file mode 100644
index 65245f7fc09..00000000000
--- a/jdk/src/share/native/sun/font/bidi/cmemory.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * Portions Copyright 2000 Sun Microsystems, Inc. All Rights Reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Sun designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-/*
- * (C) Copyright IBM Corp. 1998, 1999 - All Rights Reserved
- *
- * The original version of this source code and documentation is
- * copyrighted and owned by IBM. These materials are provided
- * under terms of a License Agreement between IBM and Sun.
- * This technology is protected by multiple US and International
- * patents. This notice and attribution to IBM may not be removed.
- */
-
-/*
-* File CMEMORY.H
-*
-* Contains stdlib.h/string.h memory functions
-*
-* @author Bertrand A. Damiba
-*
-* Modification History:
-*
-* Date Name Description
-* 6/20/98 Bertrand Created.
-* 05/03/99 stephen Changed from functions to macros.
-*
-*******************************************************************************
-*/
-
-#ifndef CMEMORY_H
-#define CMEMORY_H
-
-#include
-#include
-
-#define icu_malloc(size) malloc(size)
-#define icu_realloc(buffer, size) realloc(buffer, size)
-#define icu_free(buffer) free(buffer)
-#define icu_memcpy(dst, src, size) memcpy(dst, src, size)
-#define icu_memmove(dst, src, size) memmove(dst, src, size)
-#define icu_memset(buffer, mark, size) memset(buffer, mark, size)
-#define icu_memcmp(buffer1, buffer2, size) memcmp(buffer1, buffer2,size)
-
-#endif
diff --git a/jdk/src/share/native/sun/font/bidi/jbidi.c b/jdk/src/share/native/sun/font/bidi/jbidi.c
deleted file mode 100644
index 2b2342aee09..00000000000
--- a/jdk/src/share/native/sun/font/bidi/jbidi.c
+++ /dev/null
@@ -1,167 +0,0 @@
-/*
- * Portions Copyright 2000-2003 Sun Microsystems, Inc. All Rights Reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Sun designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-/*
- * (C) Copyright IBM Corp. 2000 - 2003 - All Rights Reserved
- *
- * The original version of this source code and documentation is
- * copyrighted and owned by IBM. These materials are provided
- * under terms of a License Agreement between IBM and Sun.
- * This technology is protected by multiple US and International
- * patents. This notice and attribution to IBM may not be removed.
- */
-
-// jni interface to native bidi from java
-
-#include
-#include "jbidi.h"
-
-#define U_COMMON_IMPLEMENTATION
-#include "ubidi.h"
-#include "ubidiimp.h"
-#include "uchardir.h"
-
-static jclass g_bidi_class = 0;
-static jmethodID g_bidi_reset = 0;
-
-static void resetBidi(JNIEnv *env, jclass cls, jobject bidi, jint dir, jint level, jint len, jintArray runs, jintArray cws) {
- if (!g_bidi_class) {
- g_bidi_class = (*env)->NewGlobalRef(env, cls);
- g_bidi_reset = (*env)->GetMethodID(env, g_bidi_class, "reset", "(III[I[I)V");
- }
-
- (*env)->CallVoidMethod(env, bidi, g_bidi_reset, dir, level, len, runs, cws);
-}
-
-JNIEXPORT jint JNICALL Java_java_text_Bidi_nativeGetDirectionCode
- (JNIEnv *env, jclass cls, jint cp)
-{
- return (jint)u_getDirection((uint32_t)cp);
-}
-
-JNIEXPORT void JNICALL Java_java_text_Bidi_nativeBidiChars
- (JNIEnv *env, jclass cls, jobject jbidi, jcharArray text, jint tStart, jbyteArray embs, jint eStart, jint length, jint dir)
-{
- UErrorCode err = U_ZERO_ERROR;
- UBiDi* bidi = ubidi_openSized(length, length, &err);
- if (!U_FAILURE(err)) {
- jchar *cText = (jchar*)(*env)->GetPrimitiveArrayCritical(env, text, NULL);
- if (cText) {
- UBiDiLevel baseLevel = (UBiDiLevel)dir;
- jbyte *cEmbs = 0;
- uint8_t *cEmbsAdj = 0;
- if (embs != NULL) {
- cEmbs = (jbyte*)(*env)->GetPrimitiveArrayCritical(env, embs, NULL);
- if (cEmbs) {
- cEmbsAdj = (uint8_t*)(cEmbs + eStart);
- }
- }
- ubidi_setPara(bidi, cText + tStart, length, baseLevel, cEmbsAdj, &err);
- if (cEmbs) {
- (*env)->ReleasePrimitiveArrayCritical(env, embs, cEmbs, JNI_ABORT);
- }
-
- (*env)->ReleasePrimitiveArrayCritical(env, text, cText, JNI_ABORT);
-
- if (!U_FAILURE(err)) {
- jint resDir = (jint)ubidi_getDirection(bidi);
- jint resLevel = (jint)ubidi_getParaLevel(bidi);
- jint resRunCount = 0;
- jintArray resRuns = 0;
- jintArray resCWS = 0;
- if (resDir == UBIDI_MIXED) {
- resRunCount = (jint)ubidi_countRuns(bidi, &err);
- if (!U_FAILURE(err)) {
- if (resRunCount) {
- jint* cResRuns = (jint*)calloc(resRunCount * 2, sizeof(jint));
- if (cResRuns) {
- int32_t limit = 0;
- UBiDiLevel level;
- jint *p = cResRuns;
- while (limit < length) {
- ubidi_getLogicalRun(bidi, limit, &limit, &level);
- *p++ = (jint)limit;
- *p++ = (jint)level;
- }
-
- {
- const DirProp *dp = bidi->dirProps;
- jint ccws = 0;
- jint n = 0;
- p = cResRuns;
- do {
- if ((*(p+1) ^ resLevel) & 0x1) {
- while (n < *p) {
- if (dp[n++] == WS) {
- ++ccws;
- }
- }
- } else {
- n = *p;
- }
- p += 2;
- } while (n < length);
-
- resCWS = (*env)->NewIntArray(env, ccws);
- if (resCWS) {
- jint* cResCWS = (jint*)(*env)->GetPrimitiveArrayCritical(env, resCWS, NULL);
- if (cResCWS) {
- jint ccws = 0;
- jint n = 0;
- p = cResRuns;
- do {
- if ((*(p+1) ^ resLevel) & 0x1) {
- while (n < *p) {
- if (dp[n] == WS) {
- cResCWS[ccws++] = n;
- }
- ++n;
- }
- } else {
- n = *p;
- }
- p += 2;
- } while (n < length);
- (*env)->ReleasePrimitiveArrayCritical(env, resCWS, cResCWS, 0);
- }
- }
- }
-
- resRuns = (*env)->NewIntArray(env, resRunCount * 2);
- if (resRuns) {
- (*env)->SetIntArrayRegion(env, resRuns, 0, resRunCount * 2, cResRuns);
- }
- free(cResRuns);
- }
- }
- }
- }
-
- resetBidi(env, cls, jbidi, resDir, resLevel, length, resRuns, resCWS);
- }
- }
- ubidi_close(bidi);
- }
-}
diff --git a/jdk/src/share/native/sun/font/bidi/jbidi.h b/jdk/src/share/native/sun/font/bidi/jbidi.h
deleted file mode 100644
index 38855e12ead..00000000000
--- a/jdk/src/share/native/sun/font/bidi/jbidi.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Portions Copyright 2000-2003 Sun Microsystems, Inc. All Rights Reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Sun designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-/*
- * (C) Copyright IBM Corp. 2000 - 2003 - All Rights Reserved
- *
- * The original version of this source code and documentation is
- * copyrighted and owned by IBM. These materials are provided
- * under terms of a License Agreement between IBM and Sun.
- * This technology is protected by multiple US and International
- * patents. This notice and attribution to IBM may not be removed.
- */
-
-/* DO NOT EDIT THIS FILE - it is machine generated */
-#include
-/* Header for class Bidi */
-
-#ifndef _Included_Bidi
-#define _Included_Bidi
-#ifdef __cplusplus
-extern "C" {
-#endif
-#undef Bidi_DIR_LTR
-#define Bidi_DIR_LTR 0L
-#undef Bidi_DIR_RTL
-#define Bidi_DIR_RTL 1L
-#undef Bidi_DIR_DEFAULT_LTR
-#define Bidi_DIR_DEFAULT_LTR -2L
-#undef Bidi_DIR_DEFAULT_RTL
-#define Bidi_DIR_DEFAULT_RTL -1L
-#undef Bidi_DIR_MIXED
-#define Bidi_DIR_MIXED -1L
-#undef Bidi_DIR_MIN
-#define Bidi_DIR_MIN -2L
-#undef Bidi_DIR_MAX
-#define Bidi_DIR_MAX 1L
-
-JNIEXPORT jint JNICALL Java_java_text_Bidi_nativeGetDirectionCode
- (JNIEnv *, jclass, jint);
-
-JNIEXPORT void JNICALL Java_java_text_Bidi_nativeBidiChars
- (JNIEnv *, jclass, jobject, jcharArray, jint, jbyteArray, jint, jint, jint);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
diff --git a/jdk/src/share/native/sun/font/bidi/ubidi.c b/jdk/src/share/native/sun/font/bidi/ubidi.c
deleted file mode 100644
index cd4e3fec143..00000000000
--- a/jdk/src/share/native/sun/font/bidi/ubidi.c
+++ /dev/null
@@ -1,1433 +0,0 @@
-/*
- * Portions Copyright 2000-2008 Sun Microsystems, Inc. All Rights Reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Sun designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-/*
- * (C) Copyright IBM Corp. 1999-2003 - All Rights Reserved
- *
- * The original version of this source code and documentation is
- * copyrighted and owned by IBM. These materials are provided
- * under terms of a License Agreement between IBM and Sun.
- * This technology is protected by multiple US and International
- * patents. This notice and attribution to IBM may not be removed.
- */
-
-/*
-*
-******************************************************************************
-* file name: ubidi.c
-* encoding: US-ASCII
-* tab size: 8 (not used)
-* indentation:4
-*
-* created on: 1999jul27
-* created by: Markus W. Scherer
-*/
-
-/* set import/export definitions */
-#ifndef U_COMMON_IMPLEMENTATION
-# define U_COMMON_IMPLEMENTATION
-#endif
-
-#include "cmemory.h"
-#include "utypes.h"
-#include "uchardir.h"
-#include "ubidi.h"
-#include "ubidiimp.h"
-
-/*
- * General implementation notes:
- *
- * Throughout the implementation, there are comments like (W2) that refer to
- * rules of the BiDi algorithm in its version 5, in this example to the second
- * rule of the resolution of weak types.
- *
- * For handling surrogate pairs, where two UChar's form one "abstract" (or UTF-32)
- * character according to UTF-16, the second UChar gets the directional property of
- * the entire character assigned, while the first one gets a BN, a boundary
- * neutral, type, which is ignored by most of the algorithm according to
- * rule (X9) and the implementation suggestions of the BiDi algorithm.
- *
- * Later, adjustWSLevels() will set the level for each BN to that of the
- * following character (UChar), which results in surrogate pairs getting the
- * same level on each of their surrogates.
- *
- * In a UTF-8 implementation, the same thing could be done: the last byte of
- * a multi-byte sequence would get the "real" property, while all previous
- * bytes of that sequence would get BN.
- *
- * It is not possible to assign all those parts of a character the same real
- * property because this would fail in the resolution of weak types with rules
- * that look at immediately surrounding types.
- *
- * As a related topic, this implementation does not remove Boundary Neutral
- * types from the input, but ignores them whereever this is relevant.
- * For example, the loop for the resolution of the weak types reads
- * types until it finds a non-BN.
- * Also, explicit embedding codes are neither changed into BN nor removed.
- * They are only treated the same way real BNs are.
- * As stated before, adjustWSLevels() takes care of them at the end.
- * For the purpose of conformance, the levels of all these codes
- * do not matter.
- *
- * Note that this implementation never modifies the dirProps
- * after the initial setup.
- *
- *
- * In this implementation, the resolution of weak types (Wn),
- * neutrals (Nn), and the assignment of the resolved level (In)
- * are all done in one single loop, in resolveImplicitLevels().
- * Changes of dirProp values are done on the fly, without writing
- * them back to the dirProps array.
- *
- *
- * This implementation contains code that allows to bypass steps of the
- * algorithm that are not needed on the specific paragraph
- * in order to speed up the most common cases considerably,
- * like text that is entirely LTR, or RTL text without numbers.
- *
- * Most of this is done by setting a bit for each directional property
- * in a flags variable and later checking for whether there are
- * any LTR characters or any RTL characters, or both, whether
- * there are any explicit embedding codes, etc.
- *
- * If the (Xn) steps are performed, then the flags are re-evaluated,
- * because they will then not contain the embedding codes any more
- * and will be adjusted for override codes, so that subsequently
- * more bypassing may be possible than what the initial flags suggested.
- *
- * If the text is not mixed-directional, then the
- * algorithm steps for the weak type resolution are not performed,
- * and all levels are set to the paragraph level.
- *
- * If there are no explicit embedding codes, then the (Xn) steps
- * are not performed.
- *
- * If embedding levels are supplied as a parameter, then all
- * explicit embedding codes are ignored, and the (Xn) steps
- * are not performed.
- *
- * White Space types could get the level of the run they belong to,
- * and are checked with a test of (flags&MASK_EMBEDDING) to
- * consider if the paragraph direction should be considered in
- * the flags variable.
- *
- * If there are no White Space types in the paragraph, then
- * (L1) is not necessary in adjustWSLevels().
- */
-
-/* prototypes --------------------------------------------------------------- */
-
-static void
-getDirProps(UBiDi *pBiDi, const UChar *text);
-
-static UBiDiDirection
-resolveExplicitLevels(UBiDi *pBiDi);
-
-static UBiDiDirection
-checkExplicitLevels(UBiDi *pBiDi, UErrorCode *pErrorCode);
-
-static UBiDiDirection
-directionFromFlags(Flags flags);
-
-static void
-resolveImplicitLevels(UBiDi *pBiDi,
- int32_t start, int32_t limit,
- DirProp sor, DirProp eor);
-
-static void
-adjustWSLevels(UBiDi *pBiDi);
-
-/* to avoid some conditional statements, use tiny constant arrays */
-static const Flags flagLR[2]={ DIRPROP_FLAG(L), DIRPROP_FLAG(R) };
-static const Flags flagE[2]={ DIRPROP_FLAG(LRE), DIRPROP_FLAG(RLE) };
-static const Flags flagO[2]={ DIRPROP_FLAG(LRO), DIRPROP_FLAG(RLO) };
-
-#define DIRPROP_FLAG_LR(level) flagLR[(level)&1]
-#define DIRPROP_FLAG_E(level) flagE[(level)&1]
-#define DIRPROP_FLAG_O(level) flagO[(level)&1]
-
-/* UBiDi object management -------------------------------------------------- */
-
-U_CAPI UBiDi * U_EXPORT2
-ubidi_open(void)
-{
- UErrorCode errorCode=U_ZERO_ERROR;
- return ubidi_openSized(0, 0, &errorCode);
-}
-
-U_CAPI UBiDi * U_EXPORT2
-ubidi_openSized(int32_t maxLength, int32_t maxRunCount, UErrorCode *pErrorCode) {
- UBiDi *pBiDi;
-
- /* check the argument values */
- if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
- return NULL;
- } else if(maxLength<0 || maxRunCount<0) {
- *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
- return NULL; /* invalid arguments */
- }
-
- /* allocate memory for the object */
- pBiDi=(UBiDi *)icu_malloc(sizeof(UBiDi));
- if(pBiDi==NULL) {
- *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
- return NULL;
- }
-
- /* reset the object, all pointers NULL, all flags FALSE, all sizes 0 */
- icu_memset(pBiDi, 0, sizeof(UBiDi));
-
- /* allocate memory for arrays as requested */
- if(maxLength>0) {
- if( !getInitialDirPropsMemory(pBiDi, maxLength) ||
- !getInitialLevelsMemory(pBiDi, maxLength)
- ) {
- *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
- }
- } else {
- pBiDi->mayAllocateText=TRUE;
- }
-
- if(maxRunCount>0) {
- if(maxRunCount==1) {
- /* use simpleRuns[] */
- pBiDi->runsSize=sizeof(Run);
- } else if(!getInitialRunsMemory(pBiDi, maxRunCount)) {
- *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
- }
- } else {
- pBiDi->mayAllocateRuns=TRUE;
- }
-
- if(U_SUCCESS(*pErrorCode)) {
- return pBiDi;
- } else {
- ubidi_close(pBiDi);
- return NULL;
- }
-}
-
-/*
- * We are allowed to allocate memory if memory==NULL or
- * mayAllocate==TRUE for each array that we need.
- * We also try to grow and shrink memory as needed if we
- * allocate it.
- *
- * Assume sizeNeeded>0.
- * If *pMemory!=NULL, then assume *pSize>0.
- *
- * ### this realloc() may unnecessarily copy the old data,
- * which we know we don't need any more;
- * is this the best way to do this??
- */
-extern bool_t
-ubidi_getMemory(void **pMemory, int32_t *pSize, bool_t mayAllocate, int32_t sizeNeeded) {
- /* check for existing memory */
- if(*pMemory==NULL) {
- /* we need to allocate memory */
- if(mayAllocate && (*pMemory=icu_malloc(sizeNeeded))!=NULL) {
- *pSize=sizeNeeded;
- return TRUE;
- } else {
- return FALSE;
- }
- } else {
- /* there is some memory, is it enough or too much? */
- if(sizeNeeded>*pSize && !mayAllocate) {
- /* not enough memory, and we must not allocate */
- return FALSE;
- } else if(sizeNeeded!=*pSize && mayAllocate) {
- /* we may try to grow or shrink */
- void *memory;
-
- if((memory=icu_realloc(*pMemory, sizeNeeded))!=NULL) {
- *pMemory=memory;
- *pSize=sizeNeeded;
- return TRUE;
- } else {
- /* we failed to grow */
- return FALSE;
- }
- } else {
- /* we have at least enough memory and must not allocate */
- return TRUE;
- }
- }
-}
-
-U_CAPI void U_EXPORT2
-ubidi_close(UBiDi *pBiDi) {
- if(pBiDi!=NULL) {
- if(pBiDi->dirPropsMemory!=NULL) {
- icu_free(pBiDi->dirPropsMemory);
- }
- if(pBiDi->levelsMemory!=NULL) {
- icu_free(pBiDi->levelsMemory);
- }
- if(pBiDi->runsMemory!=NULL) {
- icu_free(pBiDi->runsMemory);
- }
- icu_free(pBiDi);
- }
-}
-
-/* set to approximate "inverse BiDi" ---------------------------------------- */
-
-U_CAPI void U_EXPORT2
-ubidi_setInverse(UBiDi *pBiDi, bool_t isInverse) {
- if(pBiDi!=NULL) {
- pBiDi->isInverse=isInverse;
- }
-}
-
-U_CAPI bool_t U_EXPORT2
-ubidi_isInverse(UBiDi *pBiDi) {
- if(pBiDi!=NULL) {
- return pBiDi->isInverse;
- } else {
- return FALSE;
- }
-}
-
-/* ubidi_setPara ------------------------------------------------------------ */
-
-U_CAPI void U_EXPORT2
-ubidi_setPara(UBiDi *pBiDi, const UChar *text, int32_t length,
- UBiDiLevel paraLevel, UBiDiLevel *embeddingLevels,
- UErrorCode *pErrorCode) {
- UBiDiDirection direction;
-
- /* check the argument values */
- if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
- return;
- } else if(pBiDi==NULL || text==NULL ||
- ((UBIDI_MAX_EXPLICIT_LEVELtext=text;
- pBiDi->length=length;
- pBiDi->paraLevel=paraLevel;
- pBiDi->direction=UBIDI_LTR;
- pBiDi->trailingWSStart=length; /* the levels[] will reflect the WS run */
-
- pBiDi->dirProps=NULL;
- pBiDi->levels=NULL;
- pBiDi->runs=NULL;
-
- if(length==0) {
- /*
- * For an empty paragraph, create a UBiDi object with the paraLevel and
- * the flags and the direction set but without allocating zero-length arrays.
- * There is nothing more to do.
- */
- if(IS_DEFAULT_LEVEL(paraLevel)) {
- pBiDi->paraLevel&=1;
- }
- if(paraLevel&1) {
- pBiDi->flags=DIRPROP_FLAG(R);
- pBiDi->direction=UBIDI_RTL;
- } else {
- pBiDi->flags=DIRPROP_FLAG(L);
- pBiDi->direction=UBIDI_LTR;
- }
-
- pBiDi->runCount=0;
- return;
- }
-
- pBiDi->runCount=-1;
-
- /*
- * Get the directional properties,
- * the flags bit-set, and
- * determine the partagraph level if necessary.
- */
- if(getDirPropsMemory(pBiDi, length)) {
- pBiDi->dirProps=pBiDi->dirPropsMemory;
- getDirProps(pBiDi, text);
- } else {
- *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
- return;
- }
-
- if (getLevelsMemory(pBiDi, length)) {
- pBiDi->levels=pBiDi->levelsMemory;
- /* are explicit levels specified? */
- if(embeddingLevels==NULL) {
- /* no: determine explicit levels according to the (Xn) rules */
- direction=resolveExplicitLevels(pBiDi);
- } else {
- /* set BN for all explicit codes, check that all levels are paraLevel..UBIDI_MAX_EXPLICIT_LEVEL */
- icu_memcpy(pBiDi->levels, embeddingLevels, length);
- direction=checkExplicitLevels(pBiDi, pErrorCode);
- if(U_FAILURE(*pErrorCode)) {
- return;
- }
- }
- } else {
- *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
- return;
- }
-
- /*
- * The steps after (X9) in the UBiDi algorithm are performed only if
- * the paragraph text has mixed directionality!
- */
- pBiDi->direction=direction;
- switch(direction) {
- case UBIDI_LTR:
- /* make sure paraLevel is even */
- pBiDi->paraLevel=(UBiDiLevel)((pBiDi->paraLevel+1)&~1);
-
- /* all levels are implicitly at paraLevel (important for ubidi_getLevels()) */
- pBiDi->trailingWSStart=0;
- break;
- case UBIDI_RTL:
- /* make sure paraLevel is odd */
- pBiDi->paraLevel|=1;
-
- /* all levels are implicitly at paraLevel (important for ubidi_getLevels()) */
- pBiDi->trailingWSStart=0;
- break;
- default:
- /*
- * If there are no external levels specified and there
- * are no significant explicit level codes in the text,
- * then we can treat the entire paragraph as one run.
- * Otherwise, we need to perform the following rules on runs of
- * the text with the same embedding levels. (X10)
- * "Significant" explicit level codes are ones that actually
- * affect non-BN characters.
- * Examples for "insignificant" ones are empty embeddings
- * LRE-PDF, LRE-RLE-PDF-PDF, etc.
- */
- if(embeddingLevels==NULL && !(pBiDi->flags&DIRPROP_FLAG_MULTI_RUNS)) {
- resolveImplicitLevels(pBiDi, 0, length,
- GET_LR_FROM_LEVEL(pBiDi->paraLevel),
- GET_LR_FROM_LEVEL(pBiDi->paraLevel));
- } else {
- /* sor, eor: start and end types of same-level-run */
- UBiDiLevel *levels=pBiDi->levels;
- int32_t start, limit=0;
- UBiDiLevel level, nextLevel;
- DirProp sor, eor;
-
- /* determine the first sor and set eor to it because of the loop body (sor=eor there) */
- level=pBiDi->paraLevel;
- nextLevel=levels[0];
- if(levelparaLevel;
- }
-
- /* determine eor from max(level, nextLevel); sor is last run's eor */
- if((level&~UBIDI_LEVEL_OVERRIDE)<(nextLevel&~UBIDI_LEVEL_OVERRIDE)) {
- eor=GET_LR_FROM_LEVEL(nextLevel);
- } else {
- eor=GET_LR_FROM_LEVEL(level);
- }
-
- /* if the run consists of overridden directional types, then there
- are no implicit types to be resolved */
- if(!(level&UBIDI_LEVEL_OVERRIDE)) {
- resolveImplicitLevels(pBiDi, start, limit, sor, eor);
- } else {
- /* remove the UBIDI_LEVEL_OVERRIDE flags */
- do {
- levels[start++]&=~UBIDI_LEVEL_OVERRIDE;
- } while(startisInverse) {
- if(!ubidi_getRuns(pBiDi)) {
- *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
- return;
- }
- }
- break;
- }
-}
-
-/* perform (P2)..(P3) ------------------------------------------------------- */
-
-/*
- * Get the directional properties for the text,
- * calculate the flags bit-set, and
- * determine the partagraph level if necessary.
- */
-static void
-getDirProps(UBiDi *pBiDi, const UChar *text) {
- DirProp *dirProps=pBiDi->dirPropsMemory; /* pBiDi->dirProps is const */
-
- int32_t i=0, i0, i1, length=pBiDi->length;
- Flags flags=0; /* collect all directionalities in the text */
- UChar uchar;
- DirProp dirProp;
-
- if(IS_DEFAULT_LEVEL(pBiDi->paraLevel)) {
- /* determine the paragraph level (P2..P3) */
- for(;;) {
- uchar=text[i];
- if(!IS_FIRST_SURROGATE(uchar) || i+1==length || !IS_SECOND_SURROGATE(text[i+1])) {
- /* not a surrogate pair */
- flags|=DIRPROP_FLAG(dirProps[i]=dirProp=u_charDirection(uchar));
- } else {
- /* a surrogate pair */
- dirProps[i++]=BN; /* first surrogate in the pair gets the BN type */
- flags|=DIRPROP_FLAG(dirProps[i]=dirProp=u_surrogatePairDirection(uchar, text[i]))|DIRPROP_FLAG(BN);
- }
- ++i;
- if(dirProp==L) {
- pBiDi->paraLevel=0;
- break;
- } else if(dirProp==R || dirProp==AL) {
- pBiDi->paraLevel=1;
- break;
- } else if(i>=length) {
- /*
- * see comment in ubidi.h:
- * the DEFAULT_XXX values are designed so that
- * their bit 0 alone yields the intended default
- */
- pBiDi->paraLevel&=1;
- break;
- }
- }
- } else {
- flags|=DIRPROP_FLAG_LR(pBiDi->paraLevel);
- }
-
- /* get the rest of the directional properties and the flags bits */
- while(iparaLevel);
- }
-
- pBiDi->flags=flags;
-}
-
-/* perform (X1)..(X9) ------------------------------------------------------- */
-
-/*
- * Resolve the explicit levels as specified by explicit embedding codes.
- * Recalculate the flags to have them reflect the real properties
- * after taking the explicit embeddings into account.
- *
- * The BiDi algorithm is designed to result in the same behavior whether embedding
- * levels are externally specified (from "styled text", supposedly the preferred
- * method) or set by explicit embedding codes (LRx, RLx, PDF) in the plain text.
- * That is why (X9) instructs to remove all explicit codes (and BN).
- * However, in a real implementation, this removal of these codes and their index
- * positions in the plain text is undesirable since it would result in
- * reallocated, reindexed text.
- * Instead, this implementation leaves the codes in there and just ignores them
- * in the subsequent processing.
- * In order to get the same reordering behavior, positions with a BN or an
- * explicit embedding code just get the same level assigned as the last "real"
- * character.
- *
- * Some implementations, not this one, then overwrite some of these
- * directionality properties at "real" same-level-run boundaries by
- * L or R codes so that the resolution of weak types can be performed on the
- * entire paragraph at once instead of having to parse it once more and
- * perform that resolution on same-level-runs.
- * This limits the scope of the implicit rules in effectively
- * the same way as the run limits.
- *
- * Instead, this implementation does not modify these codes.
- * On one hand, the paragraph has to be scanned for same-level-runs, but
- * on the other hand, this saves another loop to reset these codes,
- * or saves making and modifying a copy of dirProps[].
- *
- *
- * Note that (Pn) and (Xn) changed significantly from version 4 of the BiDi algorithm.
- *
- *
- * Handling the stack of explicit levels (Xn):
- *
- * With the BiDi stack of explicit levels,
- * as pushed with each LRE, RLE, LRO, and RLO and popped with each PDF,
- * the explicit level must never exceed UBIDI_MAX_EXPLICIT_LEVEL==61.
- *
- * In order to have a correct push-pop semantics even in the case of overflows,
- * there are two overflow counters:
- * - countOver60 is incremented with each LRx at level 60
- * - from level 60, one RLx increases the level to 61
- * - countOver61 is incremented with each LRx and RLx at level 61
- *
- * Popping levels with PDF must work in the opposite order so that level 61
- * is correct at the correct point. Underflows (too many PDFs) must be checked.
- *
- * This implementation assumes that UBIDI_MAX_EXPLICIT_LEVEL is odd.
- */
-
-static UBiDiDirection
-resolveExplicitLevels(UBiDi *pBiDi) {
- const DirProp *dirProps=pBiDi->dirProps;
- UBiDiLevel *levels=pBiDi->levels;
-
- int32_t i=0, length=pBiDi->length;
- Flags flags=pBiDi->flags; /* collect all directionalities in the text */
- DirProp dirProp;
- UBiDiLevel level=pBiDi->paraLevel;
-
- UBiDiDirection direction;
-
- /* determine if the text is mixed-directional or single-directional */
- direction=directionFromFlags(flags);
-
- /* we may not need to resolve any explicit levels */
- if(direction!=UBIDI_MIXED) {
- /* not mixed directionality: levels don't matter - trailingWSStart will be 0 */
- } else if(!(flags&MASK_EXPLICIT) || pBiDi->isInverse) {
- /* mixed, but all characters are at the same embedding level */
- /* or we are in "inverse BiDi" */
- /* set all levels to the paragraph level */
- for(i=0; i=UBIDI_MAX_EXPLICIT_LEVEL */
- uint32_t countOver60=0, countOver61=0; /* count overflows of explicit levels */
-
- /* recalculate the flags */
- flags=0;
-
- /* since we assume that this is a single paragraph, we ignore (X8) */
- for(i=0; i0) {
- --countOver61;
- } else if(countOver60>0 && (embeddingLevel&~UBIDI_LEVEL_OVERRIDE)!=UBIDI_MAX_EXPLICIT_LEVEL) {
- /* handle LRx overflows from level 60 */
- --countOver60;
- } else if(stackTop>0) {
- /* this is the pop operation; it also pops level 61 while countOver60>0 */
- --stackTop;
- embeddingLevel=stack[stackTop];
- /* } else { (underflow) */
- }
- flags|=DIRPROP_FLAG(BN);
- break;
- case B:
- /*
- * We do not really expect to see a paragraph separator (B),
- * but we should do something reasonable with it,
- * especially at the end of the text.
- */
- stackTop=0;
- countOver60=countOver61=0;
- embeddingLevel=level=pBiDi->paraLevel;
- flags|=DIRPROP_FLAG(B);
- break;
- case BN:
- /* BN, LRE, RLE, and PDF are supposed to be removed (X9) */
- /* they will get their levels set correctly in adjustWSLevels() */
- flags|=DIRPROP_FLAG(BN);
- break;
- default:
- /* all other types get the "real" level */
- if(level!=embeddingLevel) {
- level=embeddingLevel;
- if(level&UBIDI_LEVEL_OVERRIDE) {
- flags|=DIRPROP_FLAG_O(level)|DIRPROP_FLAG_MULTI_RUNS;
- } else {
- flags|=DIRPROP_FLAG_E(level)|DIRPROP_FLAG_MULTI_RUNS;
- }
- }
- if(!(level&UBIDI_LEVEL_OVERRIDE)) {
- flags|=DIRPROP_FLAG(dirProp);
- }
- break;
- }
-
- /*
- * We need to set reasonable levels even on BN codes and
- * explicit codes because we will later look at same-level runs (X10).
- */
- levels[i]=level;
- }
- if(flags&MASK_EMBEDDING) {
- flags|=DIRPROP_FLAG_LR(pBiDi->paraLevel);
- }
-
- /* subsequently, ignore the explicit codes and BN (X9) */
-
- /* again, determine if the text is mixed-directional or single-directional */
- pBiDi->flags=flags;
- direction=directionFromFlags(flags);
- }
- return direction;
-}
-
-/*
- * Use a pre-specified embedding levels array:
- *
- * Adjust the directional properties for overrides (->LEVEL_OVERRIDE),
- * ignore all explicit codes (X9),
- * and check all the preset levels.
- *
- * Recalculate the flags to have them reflect the real properties
- * after taking the explicit embeddings into account.
- */
-static UBiDiDirection
-checkExplicitLevels(UBiDi *pBiDi, UErrorCode *pErrorCode) {
- const DirProp *dirProps=pBiDi->dirProps;
- UBiDiLevel *levels=pBiDi->levels;
-
- int32_t i, length=pBiDi->length;
- Flags flags=0; /* collect all directionalities in the text */
- UBiDiLevel level, paraLevel=pBiDi->paraLevel;
-
- for(i=0; iparaLevel);
- }
-
- /* determine if the text is mixed-directional or single-directional */
- pBiDi->flags=flags;
- return directionFromFlags(flags);
-}
-
-/* determine if the text is mixed-directional or single-directional */
-static UBiDiDirection
-directionFromFlags(Flags flags) {
- /* if the text contains AN and neutrals, then some neutrals may become RTL */
- if(!(flags&MASK_RTL || ((flags&DIRPROP_FLAG(AN)) && (flags&MASK_POSSIBLE_N)))) {
- return UBIDI_LTR;
- } else if(!(flags&MASK_LTR)) {
- return UBIDI_RTL;
- } else {
- return UBIDI_MIXED;
- }
-}
-
-/* perform rules (Wn), (Nn), and (In) on a run of the text ------------------ */
-
-/*
- * This implementation of the (Wn) rules applies all rules in one pass.
- * In order to do so, it needs a look-ahead of typically 1 character
- * (except for W5: sequences of ET) and keeps track of changes
- * in a rule Wp that affect a later Wq (pdirProps;
- UBiDiLevel *levels=pBiDi->levels;
-
- int32_t i, next, neutralStart=-1;
- DirProp prevDirProp, dirProp, nextDirProp, lastStrong, beforeNeutral=L;
- UBiDiLevel numberLevel;
- uint8_t historyOfEN;
-
- /* initialize: current at sor, next at start (it is startisInverse) {
- /*
- * For "inverse BiDi", we set the levels of numbers just like for
- * regular L characters, plus a flag that ubidi_getRuns() will use
- * to set a similar flag on the corresponding output run.
- */
- numberLevel=levels[start];
- if(numberLevel&1) {
- ++numberLevel;
- }
- } else {
- /* normal BiDi: least greater even level */
- numberLevel=(UBiDiLevel)((levels[start]+2)&~1);
- }
-
- /*
- * In all steps of this implementation, BN and explicit embedding codes
- * must be treated as if they didn't exist (X9).
- * They will get levels set before a non-neutral character, and remain
- * undefined before a neutral one, but adjustWSLevels() will take care
- * of all of them.
- */
- while(DIRPROP_FLAG(nextDirProp)&MASK_BN_EXPLICIT) {
- if(++next>=EN_SHIFT;
- /*
- * Technically, this should be done before the switch() in the form
- * if(nextDirProp==NSM) {
- * dirProps[next]=nextDirProp=dirProp;
- * }
- *
- * - effectively one iteration ahead.
- * However, whether the next dirProp is NSM or is equal to the current dirProp
- * does not change the outcome of any condition in (W2)..(W7).
- */
- break;
- default:
- break;
- }
-
- /* here, it is always [prev,this,next]dirProp!=BN; it may be next>i+1 */
-
- /* perform (Nn) - here, only L, R, EN, AN, and neutrals are left */
- /* for "inverse BiDi", treat neutrals like L */
- /* this is one iteration late for the neutrals */
- if(DIRPROP_FLAG(dirProp)&MASK_N) {
- if(neutralStart<0) {
- /* start of a sequence of neutrals */
- neutralStart=i;
- beforeNeutral=prevDirProp;
- }
- } else /* not a neutral, can be only one of { L, R, EN, AN } */ {
- /*
- * Note that all levels[] values are still the same at this
- * point because this function is called for an entire
- * same-level run.
- * Therefore, we need to read only one actual level.
- */
- UBiDiLevel level=levels[i];
-
- if(neutralStart>=0) {
- UBiDiLevel final;
- /* end of a sequence of neutrals (dirProp is "afterNeutral") */
- if(!(pBiDi->isInverse)) {
- if(beforeNeutral==L) {
- if(dirProp==L) {
- final=0; /* make all neutrals L (N1) */
- } else {
- final=level; /* make all neutrals "e" (N2) */
- }
- } else /* beforeNeutral is one of { R, EN, AN } */ {
- if(dirProp==L) {
- final=level; /* make all neutrals "e" (N2) */
- } else {
- final=1; /* make all neutrals R (N1) */
- }
- }
- } else {
- /* "inverse BiDi": collapse [before]dirProps L, EN, AN into L */
- if(beforeNeutral!=R) {
- if(dirProp!=R) {
- final=0; /* make all neutrals L (N1) */
- } else {
- final=level; /* make all neutrals "e" (N2) */
- }
- } else /* beforeNeutral is one of { R, EN, AN } */ {
- if(dirProp!=R) {
- final=level; /* make all neutrals "e" (N2) */
- } else {
- final=1; /* make all neutrals R (N1) */
- }
- }
- }
- /* perform (In) on the sequence of neutrals */
- if((level^final)&1) {
- /* do something only if we need to _change_ the level */
- do {
- ++levels[neutralStart];
- } while(++neutralStart=0) {
- /*
- * Note that all levels[] values are still the same at this
- * point because this function is called for an entire
- * same-level run.
- * Therefore, we need to read only one actual level.
- */
- UBiDiLevel level=levels[neutralStart], final;
-
- /* end of a sequence of neutrals (eor is "afterNeutral") */
- if(!(pBiDi->isInverse)) {
- if(beforeNeutral==L) {
- if(eor==L) {
- final=0; /* make all neutrals L (N1) */
- } else {
- final=level; /* make all neutrals "e" (N2) */
- }
- } else /* beforeNeutral is one of { R, EN, AN } */ {
- if(eor==L) {
- final=level; /* make all neutrals "e" (N2) */
- } else {
- final=1; /* make all neutrals R (N1) */
- }
- }
- } else {
- /* "inverse BiDi": collapse [before]dirProps L, EN, AN into L */
- if(beforeNeutral!=R) {
- if(eor!=R) {
- final=0; /* make all neutrals L (N1) */
- } else {
- final=level; /* make all neutrals "e" (N2) */
- }
- } else /* beforeNeutral is one of { R, EN, AN } */ {
- if(eor!=R) {
- final=level; /* make all neutrals "e" (N2) */
- } else {
- final=1; /* make all neutrals R (N1) */
- }
- }
- }
- /* perform (In) on the sequence of neutrals */
- if((level^final)&1) {
- /* do something only if we need to _change_ the level */
- do {
- ++levels[neutralStart];
- } while(++neutralStartdirProps;
- UBiDiLevel *levels=pBiDi->levels;
- int32_t i;
-
- if(pBiDi->flags&MASK_WS) {
- UBiDiLevel paraLevel=pBiDi->paraLevel;
- Flags flag;
-
- i=pBiDi->trailingWSStart;
- while(i>0) {
- /* reset a sequence of WS/BN before eop and B/S to the paragraph paraLevel */
- while(i>0 && DIRPROP_FLAG(dirProps[--i])&MASK_WS) {
- levels[i]=paraLevel;
- }
-
- /* reset BN to the next character's paraLevel until B/S, which restarts above loop */
- /* here, i+1 is guaranteed to be 0) {
- flag=DIRPROP_FLAG(dirProps[--i]);
- if(flag&MASK_BN_EXPLICIT) {
- levels[i]=levels[i+1];
- } else if(flag&MASK_B_S) {
- levels[i]=paraLevel;
- break;
- }
- }
- }
- }
-
- /* now remove the UBIDI_LEVEL_OVERRIDE flags, if any */
- /* (a separate loop can be optimized more easily by a compiler) */
- if(pBiDi->flags&MASK_OVERRIDE) {
- for(i=pBiDi->trailingWSStart; i>0;) {
- levels[--i]&=~UBIDI_LEVEL_OVERRIDE;
- }
- }
-}
-
-/* -------------------------------------------------------------------------- */
-
-U_CAPI UBiDiDirection U_EXPORT2
-ubidi_getDirection(const UBiDi *pBiDi) {
- if(pBiDi!=NULL) {
- return pBiDi->direction;
- } else {
- return UBIDI_LTR;
- }
-}
-
-U_CAPI const UChar * U_EXPORT2
-ubidi_getText(const UBiDi *pBiDi) {
- if(pBiDi!=NULL) {
- return pBiDi->text;
- } else {
- return NULL;
- }
-}
-
-U_CAPI int32_t U_EXPORT2
-ubidi_getLength(const UBiDi *pBiDi) {
- if(pBiDi!=NULL) {
- return pBiDi->length;
- } else {
- return 0;
- }
-}
-
-U_CAPI UBiDiLevel U_EXPORT2
-ubidi_getParaLevel(const UBiDi *pBiDi) {
- if(pBiDi!=NULL) {
- return pBiDi->paraLevel;
- } else {
- return 0;
- }
-}
-
-/* statetable prototype ----------------------------------------------------- */
-
-/*
- * This is here for possible future
- * performance work and is not compiled right now.
- */
-
-#if 0
-/*
- * This is a piece of code that could be part of ubidi.c/resolveImplicitLevels().
- * It replaces in the (Wn) state machine the switch()-if()-cascade with
- * just a few if()s and a state table.
- */
-
-/* use the state table only for the following dirProp's */
-#define MASK_W_TABLE (FLAG(L)|FLAG(R)|FLAG(AL)|FLAG(EN)|FLAG(ES)|FLAG(CS)|FLAG(ET)|FLAG(AN))
-
-/*
- * inputs:
- *
- * 0..1 historyOfEN - 2b
- * 2 prevDirProp==AN - 1b
- * 3..4 lastStrong, one of { L, R, AL, none } - 2b
- * 5..7 dirProp, one of { L, R, AL, EN, ES, CS, ET, AN } - 3b
- * 8..9 nextDirProp, one of { EN, AN, other }
- *
- * total: 10b=1024 states
- */
-enum { _L, _R, _AL, _EN, _ES, _CS, _ET, _AN, _OTHER }; /* lastStrong, dirProp */
-enum { __EN, __AN, __OTHER }; /* nextDirProp */
-
-#define LAST_STRONG_SHIFT 3
-#define DIR_PROP_SHIFT 5
-#define NEXT_DIR_PROP_SHIFT 8
-
-/* masks after shifting */
-#define LAST_STRONG_MASK 3
-#define DIR_PROP_MASK 7
-#define STATE_MASK 0x1f
-
-/* convert dirProp into _dirProp (above enum) */
-static DirProp inputDirProp[dirPropCount]={ _X<>DIR_PROP_SHIFT];
- state&=STATE_MASK;
- } else if(dirProp==ET) {
- /* get sequence of ET; advance only next, not current, previous or historyOfEN */
- while(next>DIR_PROP_SHIFT];
- state&=STATE_MASK;
-
- /* apply the result of (W1), (W5)..(W7) to the entire sequence of ET */
- } else if(dirProp==NSM) {
- /* (W1) */
- dirProp=prevDirProp;
- /* keep prevDirProp's EN and AN states! */
- } else /* other */ {
- /* set EN and AN states to 0 */
- state&=LAST_STRONG_MASK<BiDi algorithm for ICU
- *
- * This is an implementation of the Unicode Bidirectional algorithm.
- * The algorithm is defined in the
- * Unicode Technical Report 9,
- * version 5, also described in The Unicode Standard, Version 3.0 .
- *
- *
General remarks about the API:
- *
- * In functions with an error code parameter,
- * the pErrorCode pointer must be valid
- * and the value that it points to must not indicate a failure before
- * the function call. Otherwise, the function returns immediately.
- * After the function call, the value indicates success or failure.
- *
- * The limit
of a sequence of characters is the position just after their
- * last character, i.e., one more than that position.
- *
- * Some of the API functions provide access to runs
.
- * Such a run
is defined as a sequence of characters
- * that are at the same embedding level
- * after performing the BiDi algorithm.
- *
- * @author Markus W. Scherer
- */
-DOCXX_TAG
-/*@{*/
-
-/**
- * UBiDiLevel is the type of the level values in this
- * BiDi implementation.
- * It holds an embedding level and indicates the visual direction
- * by its bit 0 (even/odd value).
- *
- * It can also hold non-level values for the
- * paraLevel and embeddingLevels
- * arguments of ubidi_setPara(); there:
- *
- * - bit 7 of an
embeddingLevels[]
- * value indicates whether the using application is
- * specifying the level of a character to override whatever the
- * BiDi implementation would resolve it to.
- * paraLevel can be set to the
- * pesudo-level values UBIDI_DEFAULT_LTR
- * and UBIDI_DEFAULT_RTL.The related constants are not real, valid level values.
- * UBIDI_DEFAULT_XXX can be used to specify
- * a default for the paragraph level for
- * when the ubidi_setPara() function
- * shall determine it but there is no
- * strongly typed character in the input.
- *
- * Note that the value for UBIDI_DEFAULT_LTR is even
- * and the one for UBIDI_DEFAULT_RTL is odd,
- * just like with normal LTR and RTL level values -
- * these special values are designed that way. Also, the implementation
- * assumes that UBIDI_MAX_EXPLICIT_LEVEL is odd.
- *
- * @see UBIDI_DEFAULT_LTR
- * @see UBIDI_DEFAULT_RTL
- * @see UBIDI_LEVEL_OVERRIDE
- * @see UBIDI_MAX_EXPLICIT_LEVEL
- */
-typedef uint8_t UBiDiLevel;
-
-/** @memo If there is no strong character, then set the paragraph level to 0 (left-to-right). */
-#define UBIDI_DEFAULT_LTR 0xfe
-
-/** @memo If there is no strong character, then set the paragraph level to 1 (right-to-left). */
-#define UBIDI_DEFAULT_RTL 0xff
-
-/**
- * @memo Maximum explicit embedding level
- * (The maximum resolved level can be up to UBIDI_MAX_EXPLICIT_LEVEL+1).
- */
-#define UBIDI_MAX_EXPLICIT_LEVEL 61
-
-/** @memo Bit flag for level input: overrides directional properties. */
-#define UBIDI_LEVEL_OVERRIDE 0x80
-
-/**
- * @memo UBiDiDirection values indicate the text direction.
- */
-enum UBiDiDirection {
- /** @memo All left-to-right text. This is a 0 value. */
- UBIDI_LTR,
- /** @memo All right-to-left text. This is a 1 value. */
- UBIDI_RTL,
- /** @memo Mixed-directional text. */
- UBIDI_MIXED
-};
-
-typedef enum UBiDiDirection UBiDiDirection;
-
-/**
- * Forward declaration of the UBiDi structure for the declaration of
- * the API functions. Its fields are implementation-specific.
- * This structure holds information about a paragraph of text
- * with BiDi-algorithm-related details, or about one line of
- * such a paragraph.
- * Reordering can be done on a line, or on a paragraph which is
- * then interpreted as one single line.
- */
-struct UBiDi;
-
-typedef struct UBiDi UBiDi;
-
-/**
- * Allocate a UBiDi structure.
- * Such an object is initially empty. It is assigned
- * the BiDi properties of a paragraph by ubidi_setPara()
- * or the BiDi properties of a line of a paragraph by
- * ubidi_getLine().
- * This object can be reused for as long as it is not deallocated
- * by calling ubidi_close().
- * ubidi_set() will allocate additional memory for
- * internal structures as necessary.
- *
- * @return An empty UBiDi object.
- */
-U_CAPI UBiDi * U_EXPORT2
-ubidi_open();
-
-/**
- * Allocate a UBiDi structure with preallocated memory
- * for internal structures.
- * This function provides a UBiDi object like ubidi_open()
- * with no arguments, but it also preallocates memory for internal structures
- * according to the sizings supplied by the caller.
- * Subsequent functions will not allocate any more memory, and are thus
- * guaranteed not to fail because of lack of memory.
- * The preallocation can be limited to some of the internal memory
- * by setting some values to 0 here. That means that if, e.g.,
- * maxRunCount cannot be reasonably predetermined and should not
- * be set to maxLength (the only failproof value) to avoid
- * wasting memory, then maxRunCount could be set to 0 here
- * and the internal structures that are associated with it will be allocated
- * on demand, just like with ubidi_open().
- *
- * @param maxLength is the maximum paragraph or line length that internal memory
- * will be preallocated for. An attempt to associate this object with a
- * longer text will fail, unless this value is 0, which leaves the allocation
- * up to the implementation.
- *
- * @param maxRunCount is the maximum anticipated number of same-level runs
- * that internal memory will be preallocated for. An attempt to access
- * visual runs on an object that was not preallocated for as many runs
- * as the text was actually resolved to will fail,
- * unless this value is 0, which leaves the allocation up to the implementation.
- * The number of runs depends on the actual text and maybe anywhere between
- * 1 and maxLength. It is typically small.
- *
- * @param pErrorCode must be a valid pointer to an error code value,
- * which must not indicate a failure before the function call.
- *
- * @return An empty UBiDi object with preallocated memory.
- */
-U_CAPI UBiDi * U_EXPORT2
-ubidi_openSized(int32_t maxLength, int32_t maxRunCount, UErrorCode *pErrorCode);
-
-/**
- * ubidi_close() must be called to free the memory
- * associated with a UBiDi object.
- *
- * Important:
- * If a UBiDi object is the child
- * of another one (its parent
), after calling
- * ubidi_setLine(), then the child object must
- * be destroyed (closed) or reused (by calling
- * ubidi_setPara() or ubidi_setLine())
- * before the parent object.
- *
- * @param pBiDi is a UBiDi object.
- *
- * @see ubidi_setPara
- * @see ubidi_setLine
- */
-U_CAPI void U_EXPORT2
-ubidi_close(UBiDi *pBiDi);
-
-/**
- * Perform the Unicode BiDi algorithm. It is defined in the
- * Unicode Technical Report 9,
- * version 5,
- * also described in The Unicode Standard, Version 3.0 .
- *
- * This function takes a single plain text paragraph with or without
- * externally specified embedding levels from styled
text
- * and computes the left-right-directionality of each character.
- *
- * If the entire paragraph consists of text of only one direction, then
- * the function may not perform all the steps described by the algorithm,
- * i.e., some levels may not be the same as if all steps were performed.
- * This is not relevant for unidirectional text.
- * For example, in pure LTR text with numbers the numbers would get
- * a resolved level of 2 higher than the surrounding text according to
- * the algorithm. This implementation may set all resolved levels to
- * the same value in such a case.
- *
- * The text must be externally split into separate paragraphs (rule P1).
- * Paragraph separators (B) should appear at most at the very end.
- *
- * @param pBiDi A UBiDi object allocated with ubidi_open()
- * which will be set to contain the reordering information,
- * especially the resolved levels for all the characters in text.
- *
- * @param text is a pointer to the single-paragraph text that the
- * BiDi algorithm will be performed on
- * (step (P1) of the algorithm is performed externally).
- * The text must be (at least) length long.
- *
- * @param length is the length of the text; if length==-1 then
- * the text must be zero-terminated.
- *
- * @param paraLevel specifies the default level for the paragraph;
- * it is typically 0 (LTR) or 1 (RTL).
- * If the function shall determine the paragraph level from the text,
- * then paraLevel can be set to
- * either UBIDI_DEFAULT_LTR
- * or UBIDI_DEFAULT_RTL;
- * if there is no strongly typed character, then
- * the desired default is used (0 for LTR or 1 for RTL).
- * Any other value between 0 and UBIDI_MAX_EXPLICIT_LEVEL is also valid,
- * with odd levels indicating RTL.
- *
- * @param embeddingLevels (in) may be used to preset the embedding and override levels,
- * ignoring characters like LRE and PDF in the text.
- * A level overrides the directional property of its corresponding
- * (same index) character if the level has the
- * UBIDI_LEVEL_OVERRIDE bit set.
- * Except for that bit, it must be
- * paraLevel<=embeddingLevels[]<=UBIDI_MAX_EXPLICIT_LEVEL.
- * Caution: A copy of this pointer, not of the levels,
- * will be stored in the UBiDi object;
- * the embeddingLevels array must not be
- * deallocated before the UBiDi structure is destroyed or reused,
- * and the embeddingLevels
- * should not be modified to avoid unexpected results on subsequent BiDi operations.
- * However, the ubidi_setPara() and
- * ubidi_setLine() functions may modify some or all of the levels.
- * After the UBiDi object is reused or destroyed, the caller
- * must take care of the deallocation of the embeddingLevels array.
- * The embeddingLevels array must be
- * at least length long.
- *
- * @param pErrorCode must be a valid pointer to an error code value,
- * which must not indicate a failure before the function call.
- */
-U_CAPI void U_EXPORT2
-ubidi_setPara(UBiDi *pBiDi, const UChar *text, int32_t length,
- UBiDiLevel paraLevel, UBiDiLevel *embeddingLevels,
- UErrorCode *pErrorCode);
-
-/**
- * ubidi_getLine() sets a UBiDi to
- * contain the reordering information, especially the resolved levels,
- * for all the characters in a line of text. This line of text is
- * specified by referring to a UBiDi object representing
- * this information for a paragraph of text, and by specifying
- * a range of indexes in this paragraph.
- * In the new line object, the indexes will range from 0 to limit-start.
- *
- * This is used after calling ubidi_setPara()
- * for a paragraph, and after line-breaking on that paragraph.
- * It is not necessary if the paragraph is treated as a single line.
- *
- * After line-breaking, rules (L1) and (L2) for the treatment of
- * trailing WS and for reordering are performed on
- * a UBiDi object that represents a line.
- *
- * Important: pLineBiDi shares data with
- * pParaBiDi.
- * You must destroy or reuse pLineBiDi before pParaBiDi.
- * In other words, you must destroy or reuse the UBiDi object for a line
- * before the object for its parent paragraph.
- *
- * @param pParaBiDi is the parent paragraph object.
- *
- * @param start is the line's first index into the paragraph text.
- *
- * @param limit is just behind the line's last index into the paragraph text
- * (its last index +1).
- * It must be 0<=start<=limit<=paragraph length.
- *
- * @param pLineBiDi is the object that will now represent a line of the paragraph.
- *
- * @param pErrorCode must be a valid pointer to an error code value,
- * which must not indicate a failure before the function call.
- *
- * @see ubidi_setPara
- */
-U_CAPI void U_EXPORT2
-ubidi_setLine(const UBiDi *pParaBiDi,
- int32_t start, int32_t limit,
- UBiDi *pLineBiDi,
- UErrorCode *pErrorCode);
-
-/**
- * Get the directionality of the text.
- *
- * @param pBiDi is the paragraph or line UBiDi object.
- *
- * @return A UBIDI_XXX value that indicates if the entire text
- * represented by this object is unidirectional,
- * and which direction, or if it is mixed-directional.
- *
- * @see UBiDiDirection
- */
-U_CAPI UBiDiDirection U_EXPORT2
-ubidi_getDirection(const UBiDi *pBiDi);
-
-/**
- * Get the length of the text.
- *
- * @param pBiDi is the paragraph or line UBiDi object.
- *
- * @return The length of the text that the UBiDi object was created for.
- */
-U_CAPI int32_t U_EXPORT2
-ubidi_getLength(const UBiDi *pBiDi);
-
-/**
- * Get the paragraph level of the text.
- *
- * @param pBiDi is the paragraph or line UBiDi object.
- *
- * @return The paragraph level.
- *
- * @see UBiDiLevel
- */
-U_CAPI UBiDiLevel U_EXPORT2
-ubidi_getParaLevel(const UBiDi *pBiDi);
-
-/**
- * Get the level for one character.
- *
- * @param pBiDi is the paragraph or line UBiDi object.
- *
- * @param charIndex the index of a character.
- *
- * @return The level for the character at charIndex.
- *
- * @see UBiDiLevel
- */
-U_CAPI UBiDiLevel U_EXPORT2
-ubidi_getLevelAt(const UBiDi *pBiDi, int32_t charIndex);
-
-/**
- * Get an array of levels for each character.
- *
- * Note that this function may allocate memory under some
- * circumstances, unlike ubidi_getLevelAt().
- *
- * @param pBiDi is the paragraph or line UBiDi object.
- *
- * @param pErrorCode must be a valid pointer to an error code value,
- * which must not indicate a failure before the function call.
- *
- * @return The levels array for the text,
- * or NULL if an error occurs.
- *
- * @see UBiDiLevel
- */
-U_CAPI const UBiDiLevel * U_EXPORT2
-ubidi_getLevels(UBiDi *pBiDi, UErrorCode *pErrorCode);
-
-/**
- * Get a logical run.
- * This function returns information about a run and is used
- * to retrieve runs in logical order.
- * This is especially useful for line-breaking on a paragraph.
- *
- * @param pBiDi is the paragraph or line UBiDi object.
- *
- * @param logicalStart is the first character of the run.
- *
- * @param pLogicalLimit will receive the limit of the run.
- * The l-value that you point to here may be the
- * same expression (variable) as the one for
- * logicalStart.
- * This pointer can be NULL if this
- * value is not necessary.
- *
- * @param pLevel will receive the level of the run.
- * This pointer can be NULL if this
- * value is not necessary.
- */
-U_CAPI void U_EXPORT2
-ubidi_getLogicalRun(const UBiDi *pBiDi, int32_t logicalStart,
- int32_t *pLogicalLimit, UBiDiLevel *pLevel);
-
-/**
- * Get the number of runs.
- * This function may invoke the actual reordering on the
- * UBiDi object, after ubidi_setPara()
- * may have resolved only the levels of the text. Therefore,
- * ubidi_countRuns() may have to allocate memory,
- * and may fail doing so.
- *
- * @param pBiDi is the paragraph or line UBiDi object.
- *
- * @param pErrorCode must be a valid pointer to an error code value,
- * which must not indicate a failure before the function call.
- *
- * @return The number of runs.
- */
-U_CAPI int32_t U_EXPORT2
-ubidi_countRuns(UBiDi *pBiDi, UErrorCode *pErrorCode);
-
-/**
- * Get one run's logical start, length, and directionality,
- * which can be 0 for LTR or 1 for RTL.
- * In an RTL run, the character at the logical start is
- * visually on the right of the displayed run.
- * The length is the number of characters in the run.
- * ubidi_countRuns() should be called
- * before the runs are retrieved.
- *
- * @param pBiDi is the paragraph or line UBiDi object.
- *
- * @param runIndex is the number of the run in visual order, in the
- * range [0..ubidi_countRuns(pBiDi)-1].
- *
- * @param pLogicalStart is the first logical character index in the text.
- * The pointer may be NULL if this index is not needed.
- *
- * @param pLength is the number of characters (at least one) in the run.
- * The pointer may be NULL if this is not needed.
- *
- * @return the directionality of the run,
- * UBIDI_LTR==0 or UBIDI_RTL==1,
- * never UBIDI_MIXED.
- *
- * @see ubidi_countRuns
- *
- * Example:
- *
- * int32_t i, count=ubidi_countRuns(pBiDi),
- * logicalStart, visualIndex=0, length;
- * for(i=0; i<count; ++i) {
- * if(UBIDI_LTR==ubidi_getVisualRun(pBiDi, i, &logicalStart, &length)) {
- * do { // LTR
- * show_char(text[logicalStart++], visualIndex++);
- * } while(--length>0);
- * } else {
- * logicalStart+=length; // logicalLimit
- * do { // RTL
- * show_char(text[--logicalStart], visualIndex++);
- * } while(--length>0);
- * }
- * }
- *
- *
- * Note that in right-to-left runs, code like this places
- * modifier letters before base characters and second surrogates
- * before first ones.
- */
-U_CAPI UBiDiDirection U_EXPORT2
-ubidi_getVisualRun(UBiDi *pBiDi, int32_t runIndex,
- int32_t *pLogicalStart, int32_t *pLength);
-
-/**
- * Get the visual position from a logical text position.
- * If such a mapping is used many times on the same
- * UBiDi object, then calling
- * ubidi_getLogicalMap() is more efficient.
- *
- * Note that in right-to-left runs, this mapping places
- * modifier letters before base characters and second surrogates
- * before first ones.
- *
- * @param pBiDi is the paragraph or line UBiDi object.
- *
- * @param logicalIndex is the index of a character in the text.
- *
- * @param pErrorCode must be a valid pointer to an error code value,
- * which must not indicate a failure before the function call.
- *
- * @return The visual position of this character.
- *
- * @see ubidi_getLogicalMap
- * @see ubidi_getLogicalIndex
- */
-U_CAPI int32_t U_EXPORT2
-ubidi_getVisualIndex(UBiDi *pBiDi, int32_t logicalIndex, UErrorCode *pErrorCode);
-
-/**
- * Get the logical text position from a visual position.
- * If such a mapping is used many times on the same
- * UBiDi object, then calling
- * ubidi_getVisualMap() is more efficient.
- *
- * This is the inverse function to ubidi_getVisualIndex().
- *
- * @param pBiDi is the paragraph or line UBiDi object.
- *
- * @param visualIndex is the visual position of a character.
- *
- * @param pErrorCode must be a valid pointer to an error code value,
- * which must not indicate a failure before the function call.
- *
- * @return The index of this character in the text.
- *
- * @see ubidi_getVisualMap
- * @see ubidi_getVisualIndex
- */
-U_CAPI int32_t U_EXPORT2
-ubidi_getLogicalIndex(UBiDi *pBiDi, int32_t visualIndex, UErrorCode *pErrorCode);
-
-/**
- * Get a logical-to-visual index map (array) for the characters in the UBiDi
- * (paragraph or line) object.
- *
- * @param pBiDi is the paragraph or line UBiDi object.
- *
- * @param indexMap is a pointer to an array of ubidi_getLength()
- * indexes which will reflect the reordering of the characters.
- * The array does not need to be initialized.
- * The index map will result in indexMap[logicalIndex]==visualIndex.
- *
- * @param pErrorCode must be a valid pointer to an error code value,
- * which must not indicate a failure before the function call.
- *
- * @see ubidi_getVisualMap
- * @see ubidi_getVisualIndex
- */
-U_CAPI void U_EXPORT2
-ubidi_getLogicalMap(UBiDi *pBiDi, int32_t *indexMap, UErrorCode *pErrorCode);
-
-/**
- * Get a visual-to-logical index map (array) for the characters in the UBiDi
- * (paragraph or line) object.
- *
- * @param pBiDi is the paragraph or line UBiDi object.
- *
- * @param indexMap is a pointer to an array of ubidi_getLength()
- * indexes which will reflect the reordering of the characters.
- * The array does not need to be initialized.
- * The index map will result in indexMap[visualIndex]==logicalIndex.
- *
- * @param pErrorCode must be a valid pointer to an error code value,
- * which must not indicate a failure before the function call.
- *
- * @see ubidi_getLogicalMap
- * @see ubidi_getLogicalIndex
- */
-U_CAPI void U_EXPORT2
-ubidi_getVisualMap(UBiDi *pBiDi, int32_t *indexMap, UErrorCode *pErrorCode);
-
-/**
- * This is a convenience function that does not use a UBiDi object.
- * It is intended to be used for when an application has determined the levels
- * of objects (character sequences) and just needs to have them reordered (L2).
- * This is equivalent to using ubidi_getLogicalMap on a
- * UBiDi object.
- *
- * @param levels is an array with length levels that have been determined by
- * the application.
- *
- * @param length is the number of levels in the array, or, semantically,
- * the number of objects to be reordered.
- * It must be length>0.
- *
- * @param indexMap is a pointer to an array of length
- * indexes which will reflect the reordering of the characters.
- * The array does not need to be initialized.
- * The index map will result in indexMap[logicalIndex]==visualIndex.
- */
-U_CAPI void U_EXPORT2
-ubidi_reorderLogical(const UBiDiLevel *levels, int32_t length, int32_t *indexMap);
-
-/**
- * This is a convenience function that does not use a UBiDi object.
- * It is intended to be used for when an application has determined the levels
- * of objects (character sequences) and just needs to have them reordered (L2).
- * This is equivalent to using ubidi_getVisualMap on a
- * UBiDi object.
- *
- * @param levels is an array with length levels that have been determined by
- * the application.
- *
- * @param length is the number of levels in the array, or, semantically,
- * the number of objects to be reordered.
- * It must be length>0.
- *
- * @param indexMap is a pointer to an array of length
- * indexes which will reflect the reordering of the characters.
- * The array does not need to be initialized.
- * The index map will result in indexMap[visualIndex]==logicalIndex.
- */
-U_CAPI void U_EXPORT2
-ubidi_reorderVisual(const UBiDiLevel *levels, int32_t length, int32_t *indexMap);
-
-/**
- * Invert an index map.
- * The one-to-one index mapping of the first map is inverted and written to
- * the second one.
- *
- * @param srcMap is an array with length indexes
- * which define the original mapping.
- *
- * @param destMap is an array with length indexes
- * which will be filled with the inverse mapping.
- *
- * @param length is the length of each array.
- */
-U_CAPI void U_EXPORT2
-ubidi_invertMap(const int32_t *srcMap, int32_t *destMap, int32_t length);
-
-/**
- * @name Sample code for the ICU BiDi API
- *
- *
Rendering a paragraph with the ICU BiDi API
- *
- * This is (hypothetical) sample code that illustrates
- * how the ICU BiDi API could be used to render a paragraph of text.
- * Rendering code depends highly on the graphics system,
- * therefore this sample code must make a lot of assumptions,
- * which may or may not match any existing graphics system's properties.
- *
- * The basic assumptions are:
- *
- * - Rendering is done from left to right on a horizontal line.
- * - A run of single-style, unidirectional text can be rendered at once.
- * - Such a run of text is passed to the graphics system with
- * characters (code units) in logical order.
- * - The line-breaking algorithm is very complicated
- * and Locale-dependent -
- * and therefore its implementation omitted from this sample code.
- *
- *
- *
- * #include "ubidi.h"
- *
- * typedef enum {
- * styleNormal=0, styleSelected=1,
- * styleBold=2, styleItalics=4,
- * styleSuper=8, styleSub=16
- * } Style;
- *
- * typedef struct { int32_t limit; Style style; } StyleRun;
- *
- * int getTextWidth(const UChar *text, int32_t start, int32_t limit,
- * const StyleRun *styleRuns, int styleRunCount);
- *
- * // set *pLimit and *pStyleRunLimit for a line
- * // from text[start] and from styleRuns[styleRunStart]
- * // using ubidi_getLogicalRun(para, ...)
- * void getLineBreak(const UChar *text, int32_t start, int32_t *pLimit,
- * UBiDi *para,
- * const StyleRun *styleRuns, int styleRunStart, int *pStyleRunLimit,
- * int *pLineWidth);
- *
- * // render runs on a line sequentially, always from left to right
- *
- * // prepare rendering a new line
- * void startLine(UBiDiDirection textDirection, int lineWidth);
- *
- * // render a run of text and advance to the right by the run width
- * // the text[start..limit-1] is always in logical order
- * void renderRun(const UChar *text, int32_t start, int32_t limit,
- * UBiDiDirection textDirection, Style style);
- *
- * // We could compute a cross-product
- * // from the style runs with the directional runs
- * // and then reorder it.
- * // Instead, here we iterate over each run type
- * // and render the intersections -
- * // with shortcuts in simple (and common) cases.
- * // renderParagraph() is the main function.
- *
- * // render a directional run with
- * // (possibly) multiple style runs intersecting with it
- * void renderDirectionalRun(const UChar *text,
- * int32_t start, int32_t limit,
- * UBiDiDirection direction,
- * const StyleRun *styleRuns, int styleRunCount) {
- * int i;
- *
- * // iterate over style runs
- * if(direction==UBIDI_LTR) {
- * int styleLimit;
- *
- * for(i=0; i<styleRunCount; ++i) {
- * styleLimit=styleRun[i].limit;
- * if(start<styleLimit) {
- * if(styleLimit>limit) { styleLimit=limit; }
- * renderRun(text, start, styleLimit,
- * direction, styleRun[i].style);
- * if(styleLimit==limit) { break; }
- * start=styleLimit;
- * }
- * }
- * } else {
- * int styleStart;
- *
- * for(i=styleRunCount-1; i>=0; --i) {
- * if(i>0) {
- * styleStart=styleRun[i-1].limit;
- * } else {
- * styleStart=0;
- * }
- * if(limit>=styleStart) {
- * if(styleStart<start) { styleStart=start; }
- * renderRun(text, styleStart, limit,
- * direction, styleRun[i].style);
- * if(styleStart==start) { break; }
- * limit=styleStart;
- * }
- * }
- * }
- * }
- *
- * // the line object represents text[start..limit-1]
- * void renderLine(UBiDi *line, const UChar *text,
- * int32_t start, int32_t limit,
- * const StyleRun *styleRuns, int styleRunCount) {
- * UBiDiDirection direction=ubidi_getDirection(line);
- * if(direction!=UBIDI_MIXED) {
- * // unidirectional
- * if(styleRunCount<=1) {
- * renderRun(text, start, limit, direction, styleRuns[0].style);
- * } else {
- * renderDirectionalRun(text, start, limit,
- * direction, styleRuns, styleRunCount);
- * }
- * } else {
- * // mixed-directional
- * int32_t count, i, length;
- * UBiDiLevel level;
- *
- * count=ubidi_countRuns(para, pErrorCode);
- * if(U_SUCCESS(*pErrorCode)) {
- * if(styleRunCount<=1) {
- * Style style=styleRuns[0].style;
- *
- * // iterate over directional runs
- * for(i=0; i<count; ++i) {
- * direction=ubidi_getVisualRun(para, i, &start, &length);
- * renderRun(text, start, start+length, direction, style);
- * }
- * } else {
- * int32_t j;
- *
- * // iterate over both directional and style runs
- * for(i=0; i<count; ++i) {
- * direction=ubidi_getVisualRun(line, i, &start, &length);
- * renderDirectionalRun(text, start, start+length,
- * direction, styleRuns, styleRunCount);
- * }
- * }
- * }
- * }
- * }
- *
- * void renderParagraph(const UChar *text, int32_t length,
- * UBiDiDirection textDirection,
- * const StyleRun *styleRuns, int styleRunCount,
- * int lineWidth,
- * UErrorCode *pErrorCode) {
- * UBiDi *para;
- *
- * if(pErrorCode==NULL || U_FAILURE(*pErrorCode) || length<=0) {
- * return;
- * }
- *
- * para=ubidi_openSized(length, 0, pErrorCode);
- * if(para==NULL) { return; }
- *
- * ubidi_setPara(para, text, length,
- * textDirection ? UBIDI_DEFAULT_RTL : UBIDI_DEFAULT_LTR,
- * NULL, pErrorCode);
- * if(U_SUCCESS(*pErrorCode)) {
- * UBiDiLevel paraLevel=1&ubidi_getParaLevel(para);
- * StyleRun styleRun={ length, styleNormal };
- * int width;
- *
- * if(styleRuns==NULL || styleRunCount<=0) {
- * styleRunCount=1;
- * styleRuns=&styleRun;
- * }
- *
- * // assume styleRuns[styleRunCount-1].limit>=length
- *
- * width=getTextWidth(text, 0, length, styleRuns, styleRunCount);
- * if(width<=lineWidth) {
- * // everything fits onto one line
- *
- * // prepare rendering a new line from either left or right
- * startLine(paraLevel, width);
- *
- * renderLine(para, text, 0, length,
- * styleRuns, styleRunCount);
- * } else {
- * UBiDi *line;
- *
- * // we need to render several lines
- * line=ubidi_openSized(length, 0, pErrorCode);
- * if(line!=NULL) {
- * int32_t start=0, limit;
- * int styleRunStart=0, styleRunLimit;
- *
- * for(;;) {
- * limit=length;
- * styleRunLimit=styleRunCount;
- * getLineBreak(text, start, &limit, para,
- * styleRuns, styleRunStart, &styleRunLimit,
- * &width);
- * ubidi_setLine(para, start, limit, line, pErrorCode);
- * if(U_SUCCESS(*pErrorCode)) {
- * // prepare rendering a new line
- * // from either left or right
- * startLine(paraLevel, width);
- *
- * renderLine(line, text, start, limit,
- * styleRuns+styleRunStart,
- * styleRunLimit-styleRunStart);
- * }
- * if(limit==length) { break; }
- * start=limit;
- * styleRunStart=styleRunLimit-1;
- * if(start>=styleRuns[styleRunStart].limit) {
- * ++styleRunStart;
- * }
- * }
- *
- * ubidi_close(line);
- * }
- * }
- * }
- *
- * ubidi_close(para);
- * }
- *
- */
-BIDI_SAMPLE_CODE
-/*@{*/
-/*@}*/
-
-/*@}*/
-
-#endif
diff --git a/jdk/src/share/native/sun/font/bidi/ubidiimp.h b/jdk/src/share/native/sun/font/bidi/ubidiimp.h
deleted file mode 100644
index e961aad84ec..00000000000
--- a/jdk/src/share/native/sun/font/bidi/ubidiimp.h
+++ /dev/null
@@ -1,246 +0,0 @@
-/*
- * Portions Copyright 2000-2003 Sun Microsystems, Inc. All Rights Reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Sun designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-/*
- * (C) Copyright IBM Corp. 1999-2003 - All Rights Reserved
- *
- * The original version of this source code and documentation is
- * copyrighted and owned by IBM. These materials are provided
- * under terms of a License Agreement between IBM and Sun.
- * This technology is protected by multiple US and International
- * patents. This notice and attribution to IBM may not be removed.
- */
-
-/*
-* file name: ubidiimp.h
-* encoding: US-ASCII
-* tab size: 8 (not used)
-* indentation:4
-*
-* created on: 1999aug06
-* created by: Markus W. Scherer
-*/
-
-#ifndef UBIDIIMP_H
-#define UBIDIIMP_H
-
-/* set import/export definitions */
-#ifdef U_COMMON_IMPLEMENTATION
-
-#include "utypes.h"
-#include "uchardir.h"
-
-/* miscellaneous definitions ---------------------------------------------- */
-
-typedef uint8_t DirProp;
-typedef uint32_t Flags;
-
-/* Comparing the description of the BiDi algorithm with this implementation
- is easier with the same names for the BiDi types in the code as there.
- See UCharDirection in uchar.h .
-*/
-enum {
- L= U_LEFT_TO_RIGHT,
- R= U_RIGHT_TO_LEFT,
- EN= U_EUROPEAN_NUMBER,
- ES= U_EUROPEAN_NUMBER_SEPARATOR,
- ET= U_EUROPEAN_NUMBER_TERMINATOR,
- AN= U_ARABIC_NUMBER,
- CS= U_COMMON_NUMBER_SEPARATOR,
- B= U_BLOCK_SEPARATOR,
- S= U_SEGMENT_SEPARATOR,
- WS= U_WHITE_SPACE_NEUTRAL,
- ON= U_OTHER_NEUTRAL,
- LRE=U_LEFT_TO_RIGHT_EMBEDDING,
- LRO=U_LEFT_TO_RIGHT_OVERRIDE,
- AL= U_RIGHT_TO_LEFT_ARABIC,
- RLE=U_RIGHT_TO_LEFT_EMBEDDING,
- RLO=U_RIGHT_TO_LEFT_OVERRIDE,
- PDF=U_POP_DIRECTIONAL_FORMAT,
- NSM=U_DIR_NON_SPACING_MARK,
- BN= U_BOUNDARY_NEUTRAL,
- dirPropCount
-};
-
-/*
- * Sometimes, bit values are more appropriate
- * to deal with directionality properties.
- * Abbreviations in these macro names refer to names
- * used in the BiDi algorithm.
- */
-#define DIRPROP_FLAG(dir) (1UL<<(dir))
-
-/* special flag for multiple runs from explicit embedding codes */
-#define DIRPROP_FLAG_MULTI_RUNS (1UL<<31)
-
-/* are there any characters that are LTR or RTL? */
-#define MASK_LTR (DIRPROP_FLAG(L)|DIRPROP_FLAG(EN)|DIRPROP_FLAG(AN)|DIRPROP_FLAG(LRE)|DIRPROP_FLAG(LRO))
-#define MASK_RTL (DIRPROP_FLAG(R)|DIRPROP_FLAG(AL)|DIRPROP_FLAG(RLE)|DIRPROP_FLAG(RLO))
-
-/* explicit embedding codes */
-#define MASK_LRX (DIRPROP_FLAG(LRE)|DIRPROP_FLAG(LRO))
-#define MASK_RLX (DIRPROP_FLAG(RLE)|DIRPROP_FLAG(RLO))
-#define MASK_OVERRIDE (DIRPROP_FLAG(LRO)|DIRPROP_FLAG(RLO))
-
-#define MASK_EXPLICIT (MASK_LRX|MASK_RLX|DIRPROP_FLAG(PDF))
-#define MASK_BN_EXPLICIT (DIRPROP_FLAG(BN)|MASK_EXPLICIT)
-
-/* paragraph and segment separators */
-#define MASK_B_S (DIRPROP_FLAG(B)|DIRPROP_FLAG(S))
-
-/* all types that are counted as White Space or Neutral in some steps */
-#define MASK_WS (MASK_B_S|DIRPROP_FLAG(WS)|MASK_BN_EXPLICIT)
-#define MASK_N (DIRPROP_FLAG(ON)|MASK_WS)
-
-/* all types that are included in a sequence of European Terminators for (W5) */
-#define MASK_ET_NSM_BN (DIRPROP_FLAG(ET)|DIRPROP_FLAG(NSM)|MASK_BN_EXPLICIT)
-
-/* types that are neutrals or could becomes neutrals in (Wn) */
-#define MASK_POSSIBLE_N (DIRPROP_FLAG(CS)|DIRPROP_FLAG(ES)|DIRPROP_FLAG(ET)|MASK_N)
-
-/*
- * These types may be changed to "e",
- * the embedding type (L or R) of the run,
- * in the BiDi algorithm (N2)
- */
-#define MASK_EMBEDDING (DIRPROP_FLAG(NSM)|MASK_POSSIBLE_N)
-
-/* the dirProp's L and R are defined to 0 and 1 values in UCharDirection */
-#define GET_LR_FROM_LEVEL(level) ((DirProp)((level)&1))
-
-#define IS_DEFAULT_LEVEL(level) (((level)&0xfe)==0xfe)
-
-/* handle surrogate pairs --------------------------------------------------- */
-/* Note: dlf added for java */
-#define IS_FIRST_SURROGATE(uchar) (((uchar)&0xfc00)==0xd800)
-#define IS_SECOND_SURROGATE(uchar) (((uchar)&0xfc00)==0xdc00)
-
-/* get the UTF-32 value directly from the surrogate pseudo-characters */
-#define SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000)
-#define GET_UTF_32(first, second) (((first)<<10UL)+(second)-SURROGATE_OFFSET)
-
-/* Run structure for reordering --------------------------------------------- */
-
-typedef struct Run {
- int32_t logicalStart, /* first character of the run; b31 indicates even/odd level */
- visualLimit; /* last visual position of the run +1 */
-} Run;
-
-/* in a Run, logicalStart will get this bit set if the run level is odd */
-#define INDEX_ODD_BIT (1UL<<31)
-
-#define MAKE_INDEX_ODD_PAIR(index, level) (index|((uint32_t)level<<31))
-#define ADD_ODD_BIT_FROM_LEVEL(x, level) ((x)|=((uint32_t)level<<31))
-#define REMOVE_ODD_BIT(x) ((x)&=~INDEX_ODD_BIT)
-
-#define GET_INDEX(x) (x&~INDEX_ODD_BIT)
-#define GET_ODD_BIT(x) ((uint32_t)x>>31)
-#define IS_ODD_RUN(x) ((x&INDEX_ODD_BIT)!=0)
-#define IS_EVEN_RUN(x) ((x&INDEX_ODD_BIT)==0)
-
-U_CFUNC bool_t
-ubidi_getRuns(UBiDi *pBiDi);
-
-/* UBiDi structure ----------------------------------------------------------- */
-
-struct UBiDi {
- /* alias pointer to the current text */
- const UChar *text;
-
- /* length of the current text */
- int32_t length;
-
- /* memory sizes in bytes */
- int32_t dirPropsSize, levelsSize, runsSize;
-
- /* allocated memory */
- DirProp *dirPropsMemory;
- UBiDiLevel *levelsMemory;
- Run *runsMemory;
-
- /* indicators for whether memory may be allocated after ubidi_open() */
- bool_t mayAllocateText, mayAllocateRuns;
-
- /* arrays with one value per text-character */
- const DirProp *dirProps;
- UBiDiLevel *levels;
-
- /* are we performing an approximation of the "inverse BiDi" algorithm? */
- bool_t isInverse;
-
- /* the paragraph level */
- UBiDiLevel paraLevel;
-
- /* the overall paragraph or line directionality - see UBiDiDirection */
- UBiDiDirection direction;
-
- /* flags is a bit set for which directional properties are in the text */
- Flags flags;
-
- /* characters after trailingWSStart are WS and are */
- /* implicitly at the paraLevel (rule (L1)) - levels may not reflect that */
- int32_t trailingWSStart;
-
- /* fields for line reordering */
- int32_t runCount; /* ==-1: runs not set up yet */
- Run *runs;
-
- /* for non-mixed text, we only need a tiny array of runs (no malloc()) */
- Run simpleRuns[1];
-};
-
-/* helper function to (re)allocate memory if allowed */
-extern bool_t
-ubidi_getMemory(void **pMemory, int32_t *pSize, bool_t mayAllocate, int32_t sizeNeeded);
-
-/* helper macros for each allocated array in UBiDi */
-#define getDirPropsMemory(pBiDi, length) \
- ubidi_getMemory((void **)&(pBiDi)->dirPropsMemory, &(pBiDi)->dirPropsSize, \
- (pBiDi)->mayAllocateText, (length))
-
-#define getLevelsMemory(pBiDi, length) \
- ubidi_getMemory((void **)&(pBiDi)->levelsMemory, &(pBiDi)->levelsSize, \
- (pBiDi)->mayAllocateText, (length))
-
-#define getRunsMemory(pBiDi, length) \
- ubidi_getMemory((void **)&(pBiDi)->runsMemory, &(pBiDi)->runsSize, \
- (pBiDi)->mayAllocateRuns, (length)*sizeof(Run))
-
-/* additional macros used by ubidi_open() - always allow allocation */
-#define getInitialDirPropsMemory(pBiDi, length) \
- ubidi_getMemory((void **)&(pBiDi)->dirPropsMemory, &(pBiDi)->dirPropsSize, \
- TRUE, (length))
-
-#define getInitialLevelsMemory(pBiDi, length) \
- ubidi_getMemory((void **)&(pBiDi)->levelsMemory, &(pBiDi)->levelsSize, \
- TRUE, (length))
-
-#define getInitialRunsMemory(pBiDi, length) \
- ubidi_getMemory((void **)&(pBiDi)->runsMemory, &(pBiDi)->runsSize, \
- TRUE, (length)*sizeof(Run))
-
-#endif
-
-#endif
diff --git a/jdk/src/share/native/sun/font/bidi/ubidiln.c b/jdk/src/share/native/sun/font/bidi/ubidiln.c
deleted file mode 100644
index 538c492404b..00000000000
--- a/jdk/src/share/native/sun/font/bidi/ubidiln.c
+++ /dev/null
@@ -1,996 +0,0 @@
-/*
- * Portions Copyright 2000-2003 Sun Microsystems, Inc. All Rights Reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Sun designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-/*
- * (C) Copyright IBM Corp. 1999-2003 - All Rights Reserved
- *
- * The original version of this source code and documentation is
- * copyrighted and owned by IBM. These materials are provided
- * under terms of a License Agreement between IBM and Sun.
- * This technology is protected by multiple US and International
- * patents. This notice and attribution to IBM may not be removed.
- */
-
-/*
-* file name: ubidiln.c
-* encoding: US-ASCII
-* tab size: 8 (not used)
-* indentation:4
-*
-* created on: 1999aug06
-* created by: Markus W. Scherer
-*/
-
-/* set import/export definitions */
-#ifndef U_COMMON_IMPLEMENTATION
-# define U_COMMON_IMPLEMENTATION
-#endif
-
-#include "cmemory.h"
-#include "utypes.h"
-#include "uchardir.h"
-#include "ubidi.h"
-#include "ubidiimp.h"
-
-/*
- * General remarks about the functions in this file:
- *
- * These functions deal with the aspects of potentially mixed-directional
- * text in a single paragraph or in a line of a single paragraph
- * which has already been processed according to
- * the Unicode 3.0 BiDi algorithm as defined in
- * http://www.unicode.org/unicode/reports/tr9/ , version 5,
- * also described in The Unicode Standard, Version 3.0 .
- *
- * This means that there is a UBiDi object with a levels
- * and a dirProps array.
- * paraLevel and direction are also set.
- * Only if the length of the text is zero, then levels==dirProps==NULL.
- *
- * The overall directionality of the paragraph
- * or line is used to bypass the reordering steps if possible.
- * Even purely RTL text does not need reordering there because
- * the ubidi_getLogical/VisualIndex() functions can compute the
- * index on the fly in such a case.
- *
- * The implementation of the access to same-level-runs and of the reordering
- * do attempt to provide better performance and less memory usage compared to
- * a direct implementation of especially rule (L2) with an array of
- * one (32-bit) integer per text character.
- *
- * Here, the levels array is scanned as soon as necessary, and a vector of
- * same-level-runs is created. Reordering then is done on this vector.
- * For each run of text positions that were resolved to the same level,
- * only 8 bytes are stored: the first text position of the run and the visual
- * position behind the run after reordering.
- * One sign bit is used to hold the directionality of the run.
- * This is inefficient if there are many very short runs. If the average run
- * length is <2, then this uses more memory.
- *
- * In a further attempt to save memory, the levels array is never changed
- * after all the resolution rules (Xn, Wn, Nn, In).
- * Many functions have to consider the field trailingWSStart:
- * if it is less than length, then there is an implicit trailing run
- * at the paraLevel,
- * which is not reflected in the levels array.
- * This allows a line UBiDi object to use the same levels array as
- * its paragraph parent object.
- *
- * When a UBiDi object is created for a line of a paragraph, then the
- * paragraph's levels and dirProps arrays are reused by way of setting
- * a pointer into them, not by copying. This again saves memory and forbids to
- * change the now shared levels for (L1).
- */
-
-/* prototypes --------------------------------------------------------------- */
-
-static void
-setTrailingWSStart(UBiDi *pBiDi);
-
-static void
-getSingleRun(UBiDi *pBiDi, UBiDiLevel level);
-
-static void
-reorderLine(UBiDi *pBiDi, UBiDiLevel minLevel, UBiDiLevel maxLevel);
-
-static bool_t
-prepareReorder(const UBiDiLevel *levels, int32_t length,
- int32_t *indexMap,
- UBiDiLevel *pMinLevel, UBiDiLevel *pMaxLevel);
-
-/* ubidi_setLine ------------------------------------------------------------ */
-
-U_CAPI void U_EXPORT2
-ubidi_setLine(const UBiDi *pParaBiDi,
- int32_t start, int32_t limit,
- UBiDi *pLineBiDi,
- UErrorCode *pErrorCode) {
- int32_t length;
-
- /* check the argument values */
- if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
- return;
- } else if(pParaBiDi==NULL || pLineBiDi==NULL) {
- *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
- return;
- } else if(start<0 || start>limit || limit>pParaBiDi->length) {
- *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
- return;
- }
-
- /* set the values in pLineBiDi from its pParaBiDi parent */
- pLineBiDi->text=pParaBiDi->text+start;
- length=pLineBiDi->length=limit-start;
- pLineBiDi->paraLevel=pParaBiDi->paraLevel;
-
- pLineBiDi->runs=NULL;
- pLineBiDi->flags=0;
-
- if(length>0) {
- pLineBiDi->dirProps=pParaBiDi->dirProps+start;
- pLineBiDi->levels=pParaBiDi->levels+start;
- pLineBiDi->runCount=-1;
-
- if(pParaBiDi->direction!=UBIDI_MIXED) {
- /* the parent is already trivial */
- pLineBiDi->direction=pParaBiDi->direction;
-
- /*
- * The parent's levels are all either
- * implicitly or explicitly ==paraLevel;
- * do the same here.
- */
- if(pParaBiDi->trailingWSStart<=start) {
- pLineBiDi->trailingWSStart=0;
- } else if(pParaBiDi->trailingWSStarttrailingWSStart=pParaBiDi->trailingWSStart-start;
- } else {
- pLineBiDi->trailingWSStart=length;
- }
- } else {
- const UBiDiLevel *levels=pLineBiDi->levels;
- int32_t i, trailingWSStart;
- UBiDiLevel level;
-
- setTrailingWSStart(pLineBiDi);
- trailingWSStart=pLineBiDi->trailingWSStart;
-
- /* recalculate pLineBiDi->direction */
- if(trailingWSStart==0) {
- /* all levels are at paraLevel */
- pLineBiDi->direction=(UBiDiDirection)(pLineBiDi->paraLevel&1);
- } else {
- /* get the level of the first character */
- level=(UBiDiLevel)(levels[0]&1);
-
- /* if there is anything of a different level, then the line is mixed */
- if(trailingWSStartparaLevel&1)!=level) {
- /* the trailing WS is at paraLevel, which differs from levels[0] */
- pLineBiDi->direction=UBIDI_MIXED;
- } else {
- /* see if levels[1..trailingWSStart-1] have the same direction as levels[0] and paraLevel */
- i=1;
- for(;;) {
- if(i==trailingWSStart) {
- /* the direction values match those in level */
- pLineBiDi->direction=(UBiDiDirection)level;
- break;
- } else if((levels[i]&1)!=level) {
- pLineBiDi->direction=UBIDI_MIXED;
- break;
- }
- ++i;
- }
- }
- }
-
- switch(pLineBiDi->direction) {
- case UBIDI_LTR:
- /* make sure paraLevel is even */
- pLineBiDi->paraLevel=(UBiDiLevel)((pLineBiDi->paraLevel+1)&~1);
-
- /* all levels are implicitly at paraLevel (important for ubidi_getLevels()) */
- pLineBiDi->trailingWSStart=0;
- break;
- case UBIDI_RTL:
- /* make sure paraLevel is odd */
- pLineBiDi->paraLevel|=1;
-
- /* all levels are implicitly at paraLevel (important for ubidi_getLevels()) */
- pLineBiDi->trailingWSStart=0;
- break;
- default:
- break;
- }
- }
- } else {
- /* create an object for a zero-length line */
- pLineBiDi->direction=pLineBiDi->paraLevel&1 ? UBIDI_RTL : UBIDI_LTR;
- pLineBiDi->trailingWSStart=pLineBiDi->runCount=0;
-
- pLineBiDi->dirProps=NULL;
- pLineBiDi->levels=NULL;
- }
- return;
-}
-
-U_CAPI UBiDiLevel U_EXPORT2
-ubidi_getLevelAt(const UBiDi *pBiDi, int32_t charIndex) {
- /* return paraLevel if in the trailing WS run, otherwise the real level */
- if(pBiDi==NULL || charIndex<0 || pBiDi->length<=charIndex) {
- return 0;
- } else if(pBiDi->direction!=UBIDI_MIXED || charIndex>=pBiDi->trailingWSStart) {
- return pBiDi->paraLevel;
- } else {
- return pBiDi->levels[charIndex];
- }
-}
-
-U_CAPI const UBiDiLevel * U_EXPORT2
-ubidi_getLevels(UBiDi *pBiDi, UErrorCode *pErrorCode) {
- int32_t start, length;
-
- if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
- return NULL;
- } else if(pBiDi==NULL || (length=pBiDi->length)<=0) {
- *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
- return NULL;
- }
-
- if((start=pBiDi->trailingWSStart)==length) {
- /* the current levels array reflects the WS run */
- return pBiDi->levels;
- }
-
- /*
- * After the previous if(), we know that the levels array
- * has an implicit trailing WS run and therefore does not fully
- * reflect itself all the levels.
- * This must be a UBiDi object for a line, and
- * we need to create a new levels array.
- */
-
- if(getLevelsMemory(pBiDi, length)) {
- UBiDiLevel *levels=pBiDi->levelsMemory;
-
- if(start>0 && levels!=pBiDi->levels) {
- icu_memcpy(levels, pBiDi->levels, start);
- }
- icu_memset(levels+start, pBiDi->paraLevel, length-start);
-
- /* this new levels array is set for the line and reflects the WS run */
- pBiDi->trailingWSStart=length;
- return pBiDi->levels=levels;
- } else {
- /* out of memory */
- *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
- return NULL;
- }
-}
-
-U_CAPI void U_EXPORT2
-ubidi_getLogicalRun(const UBiDi *pBiDi, int32_t logicalStart,
- int32_t *pLogicalLimit, UBiDiLevel *pLevel) {
- int32_t length;
-
- if(pBiDi==NULL || logicalStart<0 || (length=pBiDi->length)<=logicalStart) {
- return;
- }
-
- if(pBiDi->direction!=UBIDI_MIXED || logicalStart>=pBiDi->trailingWSStart) {
- if(pLogicalLimit!=NULL) {
- *pLogicalLimit=length;
- }
- if(pLevel!=NULL) {
- *pLevel=pBiDi->paraLevel;
- }
- } else {
- UBiDiLevel *levels=pBiDi->levels;
- UBiDiLevel level=levels[logicalStart];
-
- /* search for the end of the run */
- length=pBiDi->trailingWSStart;
- while(++logicalStartdirection!=UBIDI_MIXED */
-
- const DirProp *dirProps=pBiDi->dirProps;
- UBiDiLevel *levels=pBiDi->levels;
- int32_t start=pBiDi->length;
- UBiDiLevel paraLevel=pBiDi->paraLevel;
-
- /* go backwards across all WS, BN, explicit codes */
- while(start>0 && DIRPROP_FLAG(dirProps[start-1])&MASK_WS) {
- --start;
- }
-
- /* if the WS run can be merged with the previous run then do so here */
- while(start>0 && levels[start-1]==paraLevel) {
- --start;
- }
-
- pBiDi->trailingWSStart=start;
-}
-
-/* runs API functions ------------------------------------------------------- */
-
-U_CAPI int32_t U_EXPORT2
-ubidi_countRuns(UBiDi *pBiDi, UErrorCode *pErrorCode) {
- if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
- return -1;
- } else if(pBiDi==NULL || (pBiDi->runCount<0 && !ubidi_getRuns(pBiDi))) {
- *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
- return -1;
- } else {
- return pBiDi->runCount;
- }
-}
-
-U_CAPI UBiDiDirection U_EXPORT2
-ubidi_getVisualRun(UBiDi *pBiDi, int32_t runIndex,
- int32_t *pLogicalStart, int32_t *pLength) {
- if( pBiDi==NULL || runIndex<0 ||
- (pBiDi->runCount==-1 && !ubidi_getRuns(pBiDi)) ||
- runIndex>=pBiDi->runCount
- ) {
- return UBIDI_LTR;
- } else {
- int32_t start=pBiDi->runs[runIndex].logicalStart;
- if(pLogicalStart!=NULL) {
- *pLogicalStart=GET_INDEX(start);
- }
- if(pLength!=NULL) {
- if(runIndex>0) {
- *pLength=pBiDi->runs[runIndex].visualLimit-
- pBiDi->runs[runIndex-1].visualLimit;
- } else {
- *pLength=pBiDi->runs[0].visualLimit;
- }
- }
- return (UBiDiDirection)GET_ODD_BIT(start);
- }
-}
-
-/* compute the runs array --------------------------------------------------- */
-
-/*
- * Compute the runs array from the levels array.
- * After ubidi_getRuns() returns TRUE, runCount is guaranteed to be >0
- * and the runs are reordered.
- * Odd-level runs have visualStart on their visual right edge and
- * they progress visually to the left.
- */
-U_CFUNC bool_t
-ubidi_getRuns(UBiDi *pBiDi) {
- if(pBiDi->direction!=UBIDI_MIXED) {
- /* simple, single-run case - this covers length==0 */
- getSingleRun(pBiDi, pBiDi->paraLevel);
- } else /* UBIDI_MIXED, length>0 */ {
- /* mixed directionality */
- int32_t length=pBiDi->length, limit;
-
- /*
- * If there are WS characters at the end of the line
- * and the run preceding them has a level different from
- * paraLevel, then they will form their own run at paraLevel (L1).
- * Count them separately.
- * We need some special treatment for this in order to not
- * modify the levels array which a line UBiDi object shares
- * with its paragraph parent and its other line siblings.
- * In other words, for the trailing WS, it may be
- * levels[]!=paraLevel but we have to treat it like it were so.
- */
- limit=pBiDi->trailingWSStart;
- if(limit==0) {
- /* there is only WS on this line */
- getSingleRun(pBiDi, pBiDi->paraLevel);
- } else {
- UBiDiLevel *levels=pBiDi->levels;
- int32_t i, runCount;
- UBiDiLevel level=UBIDI_DEFAULT_LTR; /* initialize with no valid level */
-
- /* count the runs, there is at least one non-WS run, and limit>0 */
- runCount=0;
- for(i=0; i1 || limit1 */
- if(getRunsMemory(pBiDi, runCount)) {
- runs=pBiDi->runsMemory;
- } else {
- return FALSE;
- }
-
- /* set the runs */
- /* this could be optimized, e.g.: 464->444, 484->444, 575->555, 595->555 */
- /* however, that would take longer and make other functions more complicated */
- runIndex=0;
-
- /* search for the run limits and initialize visualLimit values with the run lengths */
- i=0;
- do {
- /* prepare this run */
- start=i;
- level=levels[i];
- if(levelmaxLevel) {
- maxLevel=level;
- }
-
- /* look for the run limit */
- while(++iparaLevelparaLevel;
- }
- }
-
- /* set the object fields */
- pBiDi->runs=runs;
- pBiDi->runCount=runCount;
-
- reorderLine(pBiDi, minLevel, maxLevel);
-
- /* now add the direction flags and adjust the visualLimit's to be just that */
- ADD_ODD_BIT_FROM_LEVEL(runs[0].logicalStart, levels[runs[0].logicalStart]);
- limit=runs[0].visualLimit;
- for(i=1; iparaLevel);
- runs[runIndex].visualLimit+=limit;
- }
- }
- }
- }
- return TRUE;
-}
-
-/* in trivial cases there is only one trivial run; called by ubidi_getRuns() */
-static void
-getSingleRun(UBiDi *pBiDi, UBiDiLevel level) {
- /* simple, single-run case */
- pBiDi->runs=pBiDi->simpleRuns;
- pBiDi->runCount=1;
-
- /* fill and reorder the single run */
- pBiDi->runs[0].logicalStart=MAKE_INDEX_ODD_PAIR(0, level);
- pBiDi->runs[0].visualLimit=pBiDi->length;
-}
-
-/* reorder the runs array (L2) ---------------------------------------------- */
-
-/*
- * Reorder the same-level runs in the runs array.
- * Here, runCount>1 and maxLevel>=minLevel>=paraLevel.
- * All the visualStart fields=logical start before reordering.
- * The "odd" bits are not set yet.
- *
- * Reordering with this data structure lends itself to some handy shortcuts:
- *
- * Since each run is moved but not modified, and since at the initial maxLevel
- * each sequence of same-level runs consists of only one run each, we
- * don't need to do anything there and can predecrement maxLevel.
- * In many simple cases, the reordering is thus done entirely in the
- * index mapping.
- * Also, reordering occurs only down to the lowest odd level that occurs,
- * which is minLevel|1. However, if the lowest level itself is odd, then
- * in the last reordering the sequence of the runs at this level or higher
- * will be all runs, and we don't need the elaborate loop to search for them.
- * This is covered by ++minLevel instead of minLevel|=1 followed
- * by an extra reorder-all after the reorder-some loop.
- * About a trailing WS run:
- * Such a run would need special treatment because its level is not
- * reflected in levels[] if this is not a paragraph object.
- * Instead, all characters from trailingWSStart on are implicitly at
- * paraLevel.
- * However, for all maxLevel>paraLevel, this run will never be reordered
- * and does not need to be taken into account. maxLevel==paraLevel is only reordered
- * if minLevel==paraLevel is odd, which is done in the extra segment.
- * This means that for the main reordering loop we don't need to consider
- * this run and can --runCount. If it is later part of the all-runs
- * reordering, then runCount is adjusted accordingly.
- */
-static void
-reorderLine(UBiDi *pBiDi, UBiDiLevel minLevel, UBiDiLevel maxLevel) {
- Run *runs;
- UBiDiLevel *levels;
- int32_t firstRun, endRun, limitRun, runCount,
- temp;
-
- /* nothing to do? */
- if(maxLevel<=(minLevel|1)) {
- return;
- }
-
- /*
- * Reorder only down to the lowest odd level
- * and reorder at an odd minLevel in a separate, simpler loop.
- * See comments above for why minLevel is always incremented.
- */
- ++minLevel;
-
- runs=pBiDi->runs;
- levels=pBiDi->levels;
- runCount=pBiDi->runCount;
-
- /* do not include the WS run at paraLevel<=old minLevel except in the simple loop */
- if(pBiDi->trailingWSStartlength) {
- --runCount;
- }
-
- while(--maxLevel>=minLevel) {
- firstRun=0;
-
- /* loop for all sequences of runs */
- for(;;) {
- /* look for a sequence of runs that are all at >=maxLevel */
- /* look for the first run of such a sequence */
- while(firstRun=runCount) {
- break; /* no more such runs */
- }
-
- /* look for the limit run of such a sequence (the run behind it) */
- for(limitRun=firstRun; ++limitRun=maxLevel;) {}
-
- /* Swap the entire sequence of runs from firstRun to limitRun-1. */
- endRun=limitRun-1;
- while(firstRuntrailingWSStart==pBiDi->length) {
- --runCount;
- }
-
- /* Swap the entire sequence of all runs. (endRun==runCount) */
- while(firstRun=maxLevel */
- /* look for the first index of such a sequence */
- while(start=length) {
- break; /* no more such sequences */
- }
-
- /* look for the limit of such a sequence (the index behind it) */
- for(limit=start; ++limit=maxLevel;) {}
-
- /*
- * sos=start of sequence, eos=end of sequence
- *
- * The closed (inclusive) interval from sos to eos includes all the logical
- * and visual indexes within this sequence. They are logically and
- * visually contiguous and in the same range.
- *
- * For each run, the new visual index=sos+eos-old visual index;
- * we pre-add sos+eos into sumOfSosEos ->
- * new visual index=sumOfSosEos-old visual index;
- */
- sumOfSosEos=start+limit-1;
-
- /* reorder each index in the sequence */
- do {
- indexMap[start]=sumOfSosEos-indexMap[start];
- } while(++start=minLevel);
-}
-
-U_CAPI void U_EXPORT2
-ubidi_reorderVisual(const UBiDiLevel *levels, int32_t length, int32_t *indexMap) {
- int32_t start, end, limit, temp;
- UBiDiLevel minLevel, maxLevel;
-
- if(indexMap==NULL || !prepareReorder(levels, length, indexMap, &minLevel, &maxLevel)) {
- return;
- }
-
- /* nothing to do? */
- if(minLevel==maxLevel && (minLevel&1)==0) {
- return;
- }
-
- /* reorder only down to the lowest odd level */
- minLevel|=1;
-
- /* loop maxLevel..minLevel */
- do {
- start=0;
-
- /* loop for all sequences of levels to reorder at the current maxLevel */
- for(;;) {
- /* look for a sequence of levels that are all at >=maxLevel */
- /* look for the first index of such a sequence */
- while(start=length) {
- break; /* no more such runs */
- }
-
- /* look for the limit of such a sequence (the index behind it) */
- for(limit=start; ++limit=maxLevel;) {}
-
- /*
- * Swap the entire interval of indexes from start to limit-1.
- * We don't need to swap the levels for the purpose of this
- * algorithm: the sequence of levels that we look at does not
- * move anyway.
- */
- end=limit-1;
- while(start=minLevel);
-}
-
-static bool_t
-prepareReorder(const UBiDiLevel *levels, int32_t length,
- int32_t *indexMap,
- UBiDiLevel *pMinLevel, UBiDiLevel *pMaxLevel) {
- int32_t start;
- UBiDiLevel level, minLevel, maxLevel;
-
- if(levels==NULL || length<=0) {
- return FALSE;
- }
-
- /* determine minLevel and maxLevel */
- minLevel=UBIDI_MAX_EXPLICIT_LEVEL+1;
- maxLevel=0;
- for(start=length; start>0;) {
- level=levels[--start];
- if(level>UBIDI_MAX_EXPLICIT_LEVEL+1) {
- return FALSE;
- }
- if(levelmaxLevel) {
- maxLevel=level;
- }
- }
- *pMinLevel=minLevel;
- *pMaxLevel=maxLevel;
-
- /* initialize the index map */
- for(start=length; start>0;) {
- --start;
- indexMap[start]=start;
- }
-
- return TRUE;
-}
-
-/* API functions for logical<->visual mapping ------------------------------- */
-
-U_CAPI int32_t U_EXPORT2
-ubidi_getVisualIndex(UBiDi *pBiDi, int32_t logicalIndex, UErrorCode *pErrorCode) {
- if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
- return 0;
- } else if(pBiDi==NULL) {
- *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
- return 0;
- } else if(logicalIndex<0 || pBiDi->length<=logicalIndex) {
- *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
- return 0;
- } else {
- /* we can do the trivial cases without the runs array */
- switch(pBiDi->direction) {
- case UBIDI_LTR:
- return logicalIndex;
- case UBIDI_RTL:
- return pBiDi->length-logicalIndex-1;
- default:
- if(pBiDi->runCount<0 && !ubidi_getRuns(pBiDi)) {
- *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
- return 0;
- } else {
- Run *runs=pBiDi->runs;
- int32_t i, visualStart=0, offset, length;
-
- /* linear search for the run, search on the visual runs */
- for(i=0;; ++i) {
- length=runs[i].visualLimit-visualStart;
- offset=logicalIndex-GET_INDEX(runs[i].logicalStart);
- if(offset>=0 && offsetlength<=visualIndex) {
- *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
- return 0;
- } else {
- /* we can do the trivial cases without the runs array */
- switch(pBiDi->direction) {
- case UBIDI_LTR:
- return visualIndex;
- case UBIDI_RTL:
- return pBiDi->length-visualIndex-1;
- default:
- if(pBiDi->runCount<0 && !ubidi_getRuns(pBiDi)) {
- *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
- return 0;
- } else {
- Run *runs=pBiDi->runs;
- int32_t i, runCount=pBiDi->runCount, start;
-
- if(runCount<=10) {
- /* linear search for the run */
- for(i=0; visualIndex>=runs[i].visualLimit; ++i) {}
- } else {
- /* binary search for the run */
- int32_t begin=0, limit=runCount;
-
- /* the middle if() will guaranteed find the run, we don't need a loop limit */
- for(;;) {
- i=(begin+limit)/2;
- if(visualIndex>=runs[i].visualLimit) {
- begin=i+1;
- } else if(i==0 || visualIndex>=runs[i-1].visualLimit) {
- break;
- } else {
- limit=i;
- }
- }
- }
-
- start=runs[i].logicalStart;
- if(IS_EVEN_RUN(start)) {
- /* LTR */
- /* the offset in runs[i] is visualIndex-runs[i-1].visualLimit */
- if(i>0) {
- visualIndex-=runs[i-1].visualLimit;
- }
- return GET_INDEX(start)+visualIndex;
- } else {
- /* RTL */
- return GET_INDEX(start)+runs[i].visualLimit-visualIndex-1;
- }
- }
- }
- }
-}
-
-U_CAPI void U_EXPORT2
-ubidi_getLogicalMap(UBiDi *pBiDi, int32_t *indexMap, UErrorCode *pErrorCode) {
- UBiDiLevel *levels;
-
- /* ubidi_getLevels() checks all of its and our arguments */
- if((levels=(UBiDiLevel *)ubidi_getLevels(pBiDi, pErrorCode))==NULL) {
- /* no op */
- } else if(indexMap==NULL) {
- *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
- } else {
- ubidi_reorderLogical(levels, pBiDi->length, indexMap);
- }
-}
-
-U_CAPI void U_EXPORT2
-ubidi_getVisualMap(UBiDi *pBiDi, int32_t *indexMap, UErrorCode *pErrorCode) {
- /* ubidi_countRuns() checks all of its and our arguments */
- if(ubidi_countRuns(pBiDi, pErrorCode)<=0) {
- /* no op */
- } else if(indexMap==NULL) {
- *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
- } else {
- /* fill a visual-to-logical index map using the runs[] */
- Run *runs=pBiDi->runs, *runsLimit=runs+pBiDi->runCount;
- int32_t logicalStart, visualStart, visualLimit;
-
- visualStart=0;
- for(; runslogicalStart;
- visualLimit=runs->visualLimit;
- if(IS_EVEN_RUN(logicalStart)) {
- do { /* LTR */
- *indexMap++ = logicalStart++;
- } while(++visualStart0) {
- destMap[*--srcMap]=--length;
- }
- }
-}
diff --git a/jdk/src/share/native/sun/font/bidi/uchardir.c b/jdk/src/share/native/sun/font/bidi/uchardir.c
deleted file mode 100644
index c13b7be351e..00000000000
--- a/jdk/src/share/native/sun/font/bidi/uchardir.c
+++ /dev/null
@@ -1,652 +0,0 @@
-/*
- * Portions Copyright 2000-2005 Sun Microsystems, Inc. All Rights Reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Sun designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-/*
- * (C) Copyright IBM Corp. 1999-2003 - All Rights Reserved
- *
- * The original version of this source code and documentation is
- * copyrighted and owned by IBM. These materials are provided
- * under terms of a License Agreement between IBM and Sun.
- * This technology is protected by multiple US and International
- * patents. This notice and attribution to IBM may not be removed.
- */
-
-/*
-*
-* File UCHAR.CPP
-*
-* Modification History:
-*
-* Date Name Description
-* 11/30/1999 dfelt Creation. Extract from uchar.c, reduce to data
-* query only.
-********************************************************************************
-*/
-
-#include "uchardir.h"
-
-/* new 4.0 surrogate data */
-static uint32_t ASCII_START = 0x0;
-static uint32_t ASCII_LIMIT = 0x80;
-static uint8_t ASCII[] = {
- (uint8_t)0x12, (uint8_t)0x12, (uint8_t)0x12, (uint8_t)0x12, (uint8_t)0x12, (uint8_t)0x12, (uint8_t)0x12, (uint8_t)0x12,
- (uint8_t)0x12, (uint8_t)0x08, (uint8_t)0x07, (uint8_t)0x08, (uint8_t)0x09, (uint8_t)0x07, (uint8_t)0x12, (uint8_t)0x12,
- (uint8_t)0x12, (uint8_t)0x12, (uint8_t)0x12, (uint8_t)0x12, (uint8_t)0x12, (uint8_t)0x12, (uint8_t)0x12, (uint8_t)0x12,
- (uint8_t)0x12, (uint8_t)0x12, (uint8_t)0x12, (uint8_t)0x12, (uint8_t)0x07, (uint8_t)0x07, (uint8_t)0x07, (uint8_t)0x08,
- (uint8_t)0x09, (uint8_t)0x0a, (uint8_t)0x0a, (uint8_t)0x04, (uint8_t)0x04, (uint8_t)0x04, (uint8_t)0x0a, (uint8_t)0x0a,
- (uint8_t)0x0a, (uint8_t)0x0a, (uint8_t)0x0a, (uint8_t)0x04, (uint8_t)0x06, (uint8_t)0x04, (uint8_t)0x06, (uint8_t)0x03,
- (uint8_t)0x02, (uint8_t)0x02, (uint8_t)0x02, (uint8_t)0x02, (uint8_t)0x02, (uint8_t)0x02, (uint8_t)0x02, (uint8_t)0x02,
- (uint8_t)0x02, (uint8_t)0x02, (uint8_t)0x06, (uint8_t)0x0a, (uint8_t)0x0a, (uint8_t)0x0a, (uint8_t)0x0a, (uint8_t)0x0a,
- (uint8_t)0x0a, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x0a, (uint8_t)0x0a, (uint8_t)0x0a, (uint8_t)0x0a, (uint8_t)0x0a,
- (uint8_t)0x0a, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x0a, (uint8_t)0x0a, (uint8_t)0x0a, (uint8_t)0x0a, (uint8_t)0x12,
-};
-static uint32_t RTL_START = 0x591;
-static uint32_t RTL_LIMIT = 0x671;
-static uint8_t RTL[] = {
- (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11,
- (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11,
- (uint8_t)0x11, (uint8_t)0x01, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11,
- (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11,
- (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11,
- (uint8_t)0x11, (uint8_t)0x01, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x01, (uint8_t)0x11, (uint8_t)0x01,
- (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x01, (uint8_t)0x11, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01,
- (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01,
- (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01,
- (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01,
- (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01,
- (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01,
- (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01,
- (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x01, (uint8_t)0x0d,
- (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d,
- (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x06, (uint8_t)0x0d, (uint8_t)0x0a, (uint8_t)0x0a, (uint8_t)0x11,
- (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d,
- (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d,
- (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d,
- (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d,
- (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d,
- (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d,
- (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d,
- (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11,
- (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11,
- (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x05,
- (uint8_t)0x05, (uint8_t)0x05, (uint8_t)0x05, (uint8_t)0x05, (uint8_t)0x05, (uint8_t)0x05, (uint8_t)0x05, (uint8_t)0x05,
- (uint8_t)0x05, (uint8_t)0x04, (uint8_t)0x05, (uint8_t)0x05, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x11,
-};
-static uint8_t t0[] = {
- (uint8_t)0x99, (uint8_t)0x99, (uint8_t)0x99, (uint8_t)0x99, (uint8_t)0x9b, (uint8_t)0xab, (uint8_t)0xca, (uint8_t)0x99,
- (uint8_t)0x99, (uint8_t)0x99, (uint8_t)0x99, (uint8_t)0x99, (uint8_t)0x99, (uint8_t)0x99, (uint8_t)0xaa, (uint8_t)0xab,
- (uint8_t)0xcd, (uint8_t)0xd5, (uint8_t)0x55, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xd5, (uint8_t)0x75, (uint8_t)0x74,
- (uint8_t)0x33, (uint8_t)0x33, (uint8_t)0x33, (uint8_t)0x33, (uint8_t)0x33, (uint8_t)0x7d, (uint8_t)0xdd, (uint8_t)0xdd,
- (uint8_t)0xd0, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x0d, (uint8_t)0xdd, (uint8_t)0xdd,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x0d, (uint8_t)0xdd, (uint8_t)0xd9,
- (uint8_t)0x99, (uint8_t)0x99, (uint8_t)0x9a, (uint8_t)0x99, (uint8_t)0x99, (uint8_t)0x99, (uint8_t)0x99, (uint8_t)0x99,
- (uint8_t)0x99, (uint8_t)0x99, (uint8_t)0x99, (uint8_t)0x99, (uint8_t)0x99, (uint8_t)0x99, (uint8_t)0x99, (uint8_t)0x99,
- (uint8_t)0x7d, (uint8_t)0x55, (uint8_t)0x55, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0x0d, (uint8_t)0xdd, (uint8_t)0xdd,
- (uint8_t)0x55, (uint8_t)0x33, (uint8_t)0xd0, (uint8_t)0xdd, (uint8_t)0xd3, (uint8_t)0x0d, (uint8_t)0xdd, (uint8_t)0xdd,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x0d, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x0d, (uint8_t)0xd0, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x0d, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0x0d,
- (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd,
- (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88,
- (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x08, (uint8_t)0x88,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0xdd, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0xd0,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0xdd, (uint8_t)0x0d, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0xd0, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x08, (uint8_t)0x88, (uint8_t)0x80, (uint8_t)0x88, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0xd0, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x18, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88,
- (uint8_t)0x88, (uint8_t)0x18, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88,
- (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x18, (uint8_t)0x88, (uint8_t)0x18,
- (uint8_t)0x18, (uint8_t)0x81, (uint8_t)0x81, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11,
- (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11,
- (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x72, (uint8_t)0xdd,
- (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22,
- (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22,
- (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x28, (uint8_t)0x88, (uint8_t)0x88,
- (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x82, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22,
- (uint8_t)0x66, (uint8_t)0x66, (uint8_t)0x66, (uint8_t)0x66, (uint8_t)0x66, (uint8_t)0x56, (uint8_t)0x62, (uint8_t)0x22,
- (uint8_t)0x82, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22,
- (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x82, (uint8_t)0x88,
- (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x82, (uint8_t)0x28, (uint8_t)0x8d, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x22,
- (uint8_t)0x33, (uint8_t)0x33, (uint8_t)0x33, (uint8_t)0x33, (uint8_t)0x33, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22,
- (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x29,
- (uint8_t)0x28, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22,
- (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x82, (uint8_t)0x22, (uint8_t)0x22,
- (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88,
- (uint8_t)0x08, (uint8_t)0x80, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x80, (uint8_t)0x00,
- (uint8_t)0x08, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x80, (uint8_t)0x00, (uint8_t)0x08, (uint8_t)0x00,
- (uint8_t)0x08, (uint8_t)0x88, (uint8_t)0x80, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x88, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x08, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x08, (uint8_t)0x88, (uint8_t)0x80, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x08, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x55, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x08, (uint8_t)0x80, (uint8_t)0x00, (uint8_t)0x08, (uint8_t)0x80, (uint8_t)0x08, (uint8_t)0x88, (uint8_t)0x00,
- (uint8_t)0x88, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x08, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x08, (uint8_t)0x80, (uint8_t)0x00, (uint8_t)0x08, (uint8_t)0x00,
- (uint8_t)0x05, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x80, (uint8_t)0x08,
- (uint8_t)0x08, (uint8_t)0x88, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x08, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x80, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x80, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x80, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x08, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x0d, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xd5, (uint8_t)0xd0, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x88,
- (uint8_t)0x80, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x88, (uint8_t)0x80, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x08, (uint8_t)0x80, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x88, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x80, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x88, (uint8_t)0x80, (uint8_t)0x80, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x08, (uint8_t)0x00, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x80, (uint8_t)0x00, (uint8_t)0x05,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x08, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x80,
- (uint8_t)0x08, (uint8_t)0x00, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x08, (uint8_t)0x80, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x88, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x08, (uint8_t)0x08, (uint8_t)0x08, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0x00,
- (uint8_t)0x08, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x80,
- (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x80, (uint8_t)0x88, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x08, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88,
- (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x80, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x08, (uint8_t)0x88,
- (uint8_t)0x80, (uint8_t)0x80, (uint8_t)0x00, (uint8_t)0x88, (uint8_t)0x08, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0xc0, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x0d, (uint8_t)0xd0, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x88, (uint8_t)0x80, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x08, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x80, (uint8_t)0x08, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88,
- (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x05, (uint8_t)0x08, (uint8_t)0x00,
- (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xd8, (uint8_t)0x88, (uint8_t)0xc0,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x08, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x88, (uint8_t)0x80, (uint8_t)0x00, (uint8_t)0x08, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x80, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x08, (uint8_t)0x88, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0xd0, (uint8_t)0x00, (uint8_t)0xdd, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x0d, (uint8_t)0x0d,
- (uint8_t)0xdd, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x0d, (uint8_t)0xdd,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x0d, (uint8_t)0xdd,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x0d, (uint8_t)0xd0,
- (uint8_t)0xcc, (uint8_t)0xcc, (uint8_t)0xcc, (uint8_t)0xcc, (uint8_t)0xcc, (uint8_t)0xc9, (uint8_t)0x99, (uint8_t)0x01,
- (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xca, (uint8_t)0xee, (uint8_t)0xee, (uint8_t)0xec,
- (uint8_t)0x55, (uint8_t)0x55, (uint8_t)0x5d, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd,
- (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xd0, (uint8_t)0x0d, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x0c,
- (uint8_t)0x99, (uint8_t)0x99, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x99, (uint8_t)0x99, (uint8_t)0x99,
- (uint8_t)0x30, (uint8_t)0x00, (uint8_t)0x33, (uint8_t)0x33, (uint8_t)0x33, (uint8_t)0x55, (uint8_t)0xdd, (uint8_t)0xd0,
- (uint8_t)0x33, (uint8_t)0x33, (uint8_t)0x33, (uint8_t)0x33, (uint8_t)0x33, (uint8_t)0x55, (uint8_t)0xdd, (uint8_t)0xd0,
- (uint8_t)0x55, (uint8_t)0x55, (uint8_t)0x55, (uint8_t)0x55, (uint8_t)0x55, (uint8_t)0x55, (uint8_t)0x55, (uint8_t)0x55,
- (uint8_t)0x55, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x80, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0xdd, (uint8_t)0x0d, (uint8_t)0xdd, (uint8_t)0xd0, (uint8_t)0xdd, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0xd0, (uint8_t)0xdd, (uint8_t)0xd0, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0xdd,
- (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x0d, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x50,
- (uint8_t)0x00, (uint8_t)0xd0, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0xdd, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xd0, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0xdd, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x0d, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd,
- (uint8_t)0xdd, (uint8_t)0x55, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd,
- (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xd0, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd,
- (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xd0, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xd0, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x33, (uint8_t)0x33, (uint8_t)0x33, (uint8_t)0x33, (uint8_t)0x33, (uint8_t)0x33, (uint8_t)0x33, (uint8_t)0x33,
- (uint8_t)0x33, (uint8_t)0x33, (uint8_t)0x33, (uint8_t)0x33, (uint8_t)0x33, (uint8_t)0x33, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x3d, (uint8_t)0xdd, (uint8_t)0xdd,
- (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0x0d, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd,
- (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0x00,
- (uint8_t)0xdd, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x0d, (uint8_t)0xdd, (uint8_t)0xd0, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0x00, (uint8_t)0xdd, (uint8_t)0xdd,
- (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0x0d, (uint8_t)0x0d,
- (uint8_t)0xdd, (uint8_t)0xd0, (uint8_t)0x00, (uint8_t)0xd0, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xd0,
- (uint8_t)0x0d, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd,
- (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xd0, (uint8_t)0x00, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd,
- (uint8_t)0x0d, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xd0,
- (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0x0d, (uint8_t)0xdd, (uint8_t)0xdd,
- (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0xcd, (uint8_t)0xdd, (uint8_t)0xd0, (uint8_t)0x00, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd,
- (uint8_t)0xd0, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88,
- (uint8_t)0xd0, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0xdd, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x0d, (uint8_t)0xdd,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x08, (uint8_t)0x8d, (uint8_t)0xd0, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x0d, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0xdd, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0xdd, (uint8_t)0xdd,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x0d, (uint8_t)0xdd, (uint8_t)0xd0, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0xdd,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x0d,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x01, (uint8_t)0x81,
- (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x15, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11,
- (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0xdd,
- (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x22, (uint8_t)0x2d, (uint8_t)0x22,
- (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x7d, (uint8_t)0x70, (uint8_t)0xd7, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xd5,
- (uint8_t)0xdd, (uint8_t)0x55, (uint8_t)0xdd, (uint8_t)0xd0, (uint8_t)0xd5, (uint8_t)0x5d, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x0d, (uint8_t)0xd5, (uint8_t)0x55, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xd5, (uint8_t)0x75, (uint8_t)0x74,
- (uint8_t)0x55, (uint8_t)0xdd, (uint8_t)0xd5, (uint8_t)0x50, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xdd, (uint8_t)0xd0,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x09, (uint8_t)0x99, (uint8_t)0xdd, (uint8_t)0x00,
- (uint8_t)0x0d, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x08, (uint8_t)0x88, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x09, (uint8_t)0x99, (uint8_t)0x99, (uint8_t)0x99, (uint8_t)0x98, (uint8_t)0x88, (uint8_t)0x88,
- (uint8_t)0x88, (uint8_t)0x80, (uint8_t)0x08, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x00, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x88, (uint8_t)0x88, (uint8_t)0x00,
- (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x33,
- (uint8_t)0x09, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00, (uint8_t)0x00,
-};
-
-static uint8_t t1[] = {
- (uint8_t)0x00, (uint8_t)0x01, (uint8_t)0x02, (uint8_t)0x03, (uint8_t)0x04, (uint8_t)0x05, (uint8_t)0x04, (uint8_t)0x06,
- (uint8_t)0x07, (uint8_t)0x08, (uint8_t)0x09, (uint8_t)0x0a, (uint8_t)0x0b, (uint8_t)0x0c, (uint8_t)0x0b, (uint8_t)0x0c,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0d, (uint8_t)0x0e, (uint8_t)0x0e, (uint8_t)0x0f, (uint8_t)0x10,
- (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x12, (uint8_t)0x11, (uint8_t)0x13,
- (uint8_t)0x14, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x15,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x16, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x17, (uint8_t)0x18, (uint8_t)0x19, (uint8_t)0x1a, (uint8_t)0x1b, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c,
- (uint8_t)0x1d, (uint8_t)0x1e, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x20, (uint8_t)0x21, (uint8_t)0x22, (uint8_t)0x23,
- (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x24, (uint8_t)0x25, (uint8_t)0x26,
- (uint8_t)0x27, (uint8_t)0x28, (uint8_t)0x1f, (uint8_t)0x11, (uint8_t)0x29, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f,
- (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x2a, (uint8_t)0x23, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c,
- (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c,
- (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c,
- (uint8_t)0x2b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x2c, (uint8_t)0x2d, (uint8_t)0x2e, (uint8_t)0x2f, (uint8_t)0x0b,
- (uint8_t)0x30, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x2c, (uint8_t)0x31, (uint8_t)0x0b, (uint8_t)0x2f, (uint8_t)0x32,
- (uint8_t)0x2b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x2c, (uint8_t)0x33, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x34,
- (uint8_t)0x2b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x2c, (uint8_t)0x35, (uint8_t)0x0b, (uint8_t)0x2f, (uint8_t)0x36,
- (uint8_t)0x30, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x37, (uint8_t)0x38, (uint8_t)0x39, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x3a, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x3b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x3c,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x3d, (uint8_t)0x3e, (uint8_t)0x3f, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x2c, (uint8_t)0x40, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x38, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x41, (uint8_t)0x42, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x43, (uint8_t)0x44, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x45, (uint8_t)0x46, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x47, (uint8_t)0x0b, (uint8_t)0x48, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x49,
- (uint8_t)0x4a, (uint8_t)0x4b, (uint8_t)0x11, (uint8_t)0x4c, (uint8_t)0x39, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x4d, (uint8_t)0x4e, (uint8_t)0x0b, (uint8_t)0x47, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x4f, (uint8_t)0x50, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x51, (uint8_t)0x0b, (uint8_t)0x51, (uint8_t)0x0b, (uint8_t)0x2f, (uint8_t)0x0b, (uint8_t)0x2f,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x52, (uint8_t)0x53, (uint8_t)0x54, (uint8_t)0x0b, (uint8_t)0x55,
- (uint8_t)0x56, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x57, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x58, (uint8_t)0x59, (uint8_t)0x5a, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x10, (uint8_t)0x10,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x5b, (uint8_t)0x5c, (uint8_t)0x5d, (uint8_t)0x5d, (uint8_t)0x5e,
- (uint8_t)0x5f, (uint8_t)0x10, (uint8_t)0x60, (uint8_t)0x61, (uint8_t)0x10, (uint8_t)0x62, (uint8_t)0x63, (uint8_t)0x64,
- (uint8_t)0x65, (uint8_t)0x0b, (uint8_t)0x66, (uint8_t)0x67, (uint8_t)0x0b, (uint8_t)0x11, (uint8_t)0x68, (uint8_t)0x0b,
- (uint8_t)0x69, (uint8_t)0x6a, (uint8_t)0x6b, (uint8_t)0x6c, (uint8_t)0x6d, (uint8_t)0x6e, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10,
- (uint8_t)0x10, (uint8_t)0x6f, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10,
- (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10,
- (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x70, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x05,
- (uint8_t)0x10, (uint8_t)0x71, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x04, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x72, (uint8_t)0x0b, (uint8_t)0x73, (uint8_t)0x0b, (uint8_t)0x74, (uint8_t)0x74,
- (uint8_t)0x74, (uint8_t)0x75, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x76, (uint8_t)0x10,
- (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10,
- (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10,
- (uint8_t)0x10, (uint8_t)0x77, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x78,
- (uint8_t)0x10, (uint8_t)0x79, (uint8_t)0x79, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x7a, (uint8_t)0x10, (uint8_t)0x77, (uint8_t)0x10, (uint8_t)0x7b, (uint8_t)0x7c, (uint8_t)0x7d, (uint8_t)0x10,
- (uint8_t)0x10, (uint8_t)0x7e, (uint8_t)0x10, (uint8_t)0x7f, (uint8_t)0x0b, (uint8_t)0x10, (uint8_t)0x80, (uint8_t)0x10,
- (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10,
- (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10,
- (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10,
- (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10,
- (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10,
- (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10,
- (uint8_t)0x78, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x10, (uint8_t)0x81, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x82,
- (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10,
- (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x70, (uint8_t)0x0b, (uint8_t)0x80,
- (uint8_t)0x83, (uint8_t)0x10, (uint8_t)0x84, (uint8_t)0x85, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x86, (uint8_t)0x04, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x87,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x5e, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x10, (uint8_t)0x0b, (uint8_t)0x88,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x7d, (uint8_t)0x89, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x8a,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x8b, (uint8_t)0x0b, (uint8_t)0x8c,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x72, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x8d, (uint8_t)0x8e, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f,
- (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f,
- (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f,
- (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f,
- (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x8f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f,
- (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x90,
- (uint8_t)0x11, (uint8_t)0x0b, (uint8_t)0x91, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x92, (uint8_t)0x93, (uint8_t)0x1f,
- (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x1f, (uint8_t)0x27,
- (uint8_t)0x94, (uint8_t)0x03, (uint8_t)0x04, (uint8_t)0x05, (uint8_t)0x04, (uint8_t)0x05, (uint8_t)0x70, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x95, (uint8_t)0x96,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x97, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c,
- (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c,
- (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c,
- (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c,
- (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c,
- (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c,
- (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c,
- (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c,
- (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c,
- (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c,
- (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c,
- (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c,
- (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c,
- (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c,
- (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c,
- (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c, (uint8_t)0x1c,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x98, (uint8_t)0x99,
- (uint8_t)0x9a, (uint8_t)0x0b, (uint8_t)0x9b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x10, (uint8_t)0x72, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x9c, (uint8_t)0x74, (uint8_t)0x74, (uint8_t)0x74,
- (uint8_t)0x9d, (uint8_t)0x0b, (uint8_t)0x08, (uint8_t)0x08, (uint8_t)0x08, (uint8_t)0x08, (uint8_t)0x08, (uint8_t)0x08,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11,
- (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x11, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
- (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b, (uint8_t)0x0b,
-};
-
-static uint8_t ix[] = {
- (uint8_t)0x01, (uint8_t)0x23, (uint8_t)0x45, (uint8_t)0x67, (uint8_t)0x78, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x97, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x7a,
- (uint8_t)0xbc, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0xd7, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0xe7, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
- (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77, (uint8_t)0x77,
-};
-
-#define LOWBITS 4
-#define MEDBITS 7
-#define HIGHBITS (21 - MEDBITS - LOWBITS)
-
-#define HIGHSHIFT (LOWBITS + MEDBITS)
-
-#define BLOCKSIZE (1 << LOWBITS)
-#define IBLOCKSIZE (1 << MEDBITS)
-#define ISIZE (1 << HIGHBITS)
-
-#define BLOCKMASK (BLOCKSIZE - 1)
-#define IBLOCKMASK (IBLOCKSIZE - 1)
-#define IMASK (ISIZE - 1)
-
-static uint8_t jx2i[] = {
- 0, 1, 13, 2, 3, 4, 5, 6, 17, 18, 7, 8, 9, 10
-};
-
-static uint8_t x2i[] = {
- /* LRE RLE PDF LRO RLO */
- 11, 14, 16, 12, 15
-};
-
-static UCharDirection u_getDirectionInternal(uint32_t cp) {
- int dc;
- int n;
- int bi = cp & BLOCKMASK;
- int ibi = (cp >> LOWBITS) & IBLOCKMASK;
- int i = (cp >> HIGHSHIFT) & IMASK;
-
- n = ix[i >> 1];
- if ((i & 1) == 0) {
- n >>= 4;
- }
- n &= 0x0f;
- n = t1[n * IBLOCKSIZE + ibi];
- n = n * BLOCKSIZE + bi;
- dc = t0[n >> 1];
- if ((n & 1) == 0) {
- dc >>= 4;
- }
- dc &= 0x0f;
- if (dc > 13) {
- dc = x2i[cp - 0x202a];
- } else {
- dc = jx2i[dc];
- }
- return dc;
-}
-
-UCharDirection u_getDirection(uint32_t cp) {
- if (cp < ASCII_LIMIT) {
- return ASCII[cp];
- }
- if (cp < RTL_START) {
- return u_getDirectionInternal(cp);
- }
- if (cp < RTL_LIMIT) {
- return RTL[cp - RTL_START];
- }
- if (cp < 0x110000) {
- return u_getDirectionInternal(cp);
- }
- return 0;
-}
-
-UCharDirection
-u_charDirection(UChar ch) {
- return u_getDirection(ch);
-}
-
-#define LEAD_SURROGATE_SHIFT 10
-#define SURROGATE_OFFSET (0x010000 - (0xd800 << 10) - 0xdc00)
-
-UCharDirection
-u_surrogatePairDirection(UChar lead, UChar trail) {
- uint32_t cp = ((uint32_t)lead << LEAD_SURROGATE_SHIFT) + trail + SURROGATE_OFFSET;
- return u_getDirection(cp);
-}
diff --git a/jdk/src/share/native/sun/font/bidi/uchardir.h b/jdk/src/share/native/sun/font/bidi/uchardir.h
deleted file mode 100644
index 126da6e778f..00000000000
--- a/jdk/src/share/native/sun/font/bidi/uchardir.h
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * Portions Copyright 2000-2003 Sun Microsystems, Inc. All Rights Reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Sun designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-/*
- * (C) Copyright IBM Corp. 1999-2003 - All Rights Reserved
- *
- * The original version of this source code and documentation is
- * copyrighted and owned by IBM. These materials are provided
- * under terms of a License Agreement between IBM and Sun.
- * This technology is protected by multiple US and International
- * patents. This notice and attribution to IBM may not be removed.
- */
-
-/*
-*
-* File UCHARDIR.H
-*
-* Modification History:
-*
-* Date Name Description
-* 11/30/1999 dfelt Creation. Copied UCharDirection from uchar.h
-********************************************************************************
-*/
-
-#ifndef UCHARDIR_H
-#define UCHARDIR_H
-
-#include "utypes.h"
-
-/*===========================================================================*/
-/* Unicode version number */
-/*===========================================================================*/
-#define UNICODE_VERSION "3.0.0.beta"
-
-enum UCharDirection {
- U_LEFT_TO_RIGHT = 0,
- U_RIGHT_TO_LEFT = 1,
- U_EUROPEAN_NUMBER = 2,
- U_EUROPEAN_NUMBER_SEPARATOR = 3,
- U_EUROPEAN_NUMBER_TERMINATOR = 4,
- U_ARABIC_NUMBER = 5,
- U_COMMON_NUMBER_SEPARATOR = 6,
- U_BLOCK_SEPARATOR = 7,
- U_SEGMENT_SEPARATOR = 8,
- U_WHITE_SPACE_NEUTRAL = 9,
- U_OTHER_NEUTRAL = 10,
- U_LEFT_TO_RIGHT_EMBEDDING = 11,
- U_LEFT_TO_RIGHT_OVERRIDE = 12,
- U_RIGHT_TO_LEFT_ARABIC = 13,
- U_RIGHT_TO_LEFT_EMBEDDING = 14,
- U_RIGHT_TO_LEFT_OVERRIDE = 15,
- U_POP_DIRECTIONAL_FORMAT = 16,
- U_DIR_NON_SPACING_MARK = 17,
- U_BOUNDARY_NEUTRAL = 18,
- U_CHAR_DIRECTION_COUNT
-};
-
-typedef enum UCharDirection UCharDirection;
-
-/**
- * Returns the linguistic direction property of a character.
- *
- * Returns the linguistic direction property of a character.
- * For example, 0x0041 (letter A) has the LEFT_TO_RIGHT directional
- * property.
- * @see UCharDirection
- */
-U_CAPI UCharDirection U_EXPORT2
-u_charDirection(UChar c);
-
-U_CAPI UCharDirection U_EXPORT2
-u_getDirection(uint32_t cp);
-
-U_CAPI UCharDirection U_EXPORT2
-u_surrogatePairDirection(UChar lead, UChar trail);
-
-#endif /*_UCHAR*/
-/*eof*/
diff --git a/jdk/src/share/native/sun/font/bidi/utypes.h b/jdk/src/share/native/sun/font/bidi/utypes.h
deleted file mode 100644
index 92cd4bed617..00000000000
--- a/jdk/src/share/native/sun/font/bidi/utypes.h
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
- * Portions Copyright 2000-2003 Sun Microsystems, Inc. All Rights Reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Sun designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-/*
- * (C) Copyright Taligent, Inc., 1996, 1997 *
- * (C) Copyright IBM Corp. 1998-2003 - All Rights Reserved
- *
- * The original version of this source code and documentation is
- * copyrighted and owned by IBM. These materials are provided
- * under terms of a License Agreement between IBM and Sun.
- * This technology is protected by multiple US and International
- * patents. This notice and attribution to IBM may not be removed.
- */
-
-/*
-*
-* FILE NAME : UTYPES.H (formerly ptypes.h)
-*
-* Date Name Description
-* 12/11/96 helena Creation.
-* 02/27/97 aliu Added typedefs for UClassID, int8, int16, int32,
-* uint8, uint16, and uint32.
-* 04/01/97 aliu Added XP_CPLUSPLUS and modified to work under C as
-* well as C++.
-* Modified to use memcpy() for icu_arrayCopy() fns.
-* 04/14/97 aliu Added TPlatformUtilities.
-* 05/07/97 aliu Added import/export specifiers (replacing the old
-* broken EXT_CLASS). Added version number for our
-* code. Cleaned up header.
-* 6/20/97 helena Java class name change.
-* 08/11/98 stephen UErrorCode changed from typedef to enum
-* 08/12/98 erm Changed T_ANALYTIC_PACKAGE_VERSION to 3
-* 08/14/98 stephen Added icu_arrayCopy() for int8_t, int16_t, int32_t
-* 12/09/98 jfitz Added BUFFER_OVERFLOW_ERROR (bug 1100066)
-* 04/20/99 stephen Cleaned up & reworked for autoconf.
-* Renamed to utypes.h.
-* 05/05/99 stephen Changed to use
-* 10/12/00 dfelt Adapted to use javavm types (plus juint from j2d)
-*******************************************************************************
-*/
-
-#ifndef UTYPES_H
-#define UTYPES_H
-
-// doesn't seem to be a way of getting around this
-
-//#if defined(WIN32) || defined(_WIN32)
-// not needed since we don't export to another dll
-
-#if 0
-
-#define U_EXPORT __declspec(dllexport)
-#define U_EXPORT2
-#define U_IMPORT __declspec(dllimport)
-
-#else
-
-#define U_EXPORT
-#define U_EXPORT2
-#define U_IMPORT
-
-#endif
-
-#ifdef XP_CPLUSPLUS
-# define U_CFUNC extern "C"
-# define U_CDECL_BEGIN extern "C" {
-# define U_CDECL_END }
-#else
-# define U_CFUNC
-# define U_CDECL_BEGIN
-# define U_CDECL_END
-#endif
-#define U_CAPI U_CFUNC U_EXPORT
-
-// defines jboolean, jchar, jshort, and jint via jni_md.h
-#include "jni.h"
-// defines jubyte, jushort, juint
-#include "j2d_md.h"
-
-typedef jboolean bool_t;
-
-/*
- * win32 does not have standard definitions for the following:
- */
-#ifdef WIN32
-
-#ifndef __int8_t_defined
-typedef jbyte int8_t;
-typedef jshort int16_t;
-typedef jint int32_t;
-#endif
-
-typedef jubyte uint8_t;
-typedef jushort uint16_t;
-typedef juint uint32_t;
-
-#endif /* WIN32 */
-
-/*===========================================================================*/
-/* Unicode character */
-/*===========================================================================*/
-typedef uint16_t UChar;
-
-
-/** Error code to replace exception handling */
-enum UErrorCode {
- U_ERROR_INFO_START = -128, /* Start of information results (semantically successful) */
- U_USING_FALLBACK_ERROR = -128,
- U_USING_DEFAULT_ERROR = -127,
- U_ERROR_INFO_LIMIT,
-
- U_ZERO_ERROR = 0, /* success */
-
- U_ILLEGAL_ARGUMENT_ERROR = 1, /* Start of codes indicating failure */
- U_MISSING_RESOURCE_ERROR = 2,
- U_INVALID_FORMAT_ERROR = 3,
- U_FILE_ACCESS_ERROR = 4,
- U_INTERNAL_PROGRAM_ERROR = 5, /* Indicates a bug in the library code */
- U_MESSAGE_PARSE_ERROR = 6,
- U_MEMORY_ALLOCATION_ERROR = 7, /* Memory allocation error */
- U_INDEX_OUTOFBOUNDS_ERROR = 8,
- U_PARSE_ERROR = 9, /* Equivalent to Java ParseException */
- U_INVALID_CHAR_FOUND = 10, /* In the Character conversion routines: Invalid character or sequence was encountered*/
- U_TRUNCATED_CHAR_FOUND = 11, /* In the Character conversion routines: More bytes are required to complete the conversion successfully*/
- U_ILLEGAL_CHAR_FOUND = 12, /* In codeset conversion: a sequence that does NOT belong in the codepage has been encountered*/
- U_INVALID_TABLE_FORMAT = 13, /* Conversion table file found, but corrupted*/
- U_INVALID_TABLE_FILE = 14, /* Conversion table file not found*/
- U_BUFFER_OVERFLOW_ERROR = 15, /* A result would not fit in the supplied buffer */
- U_UNSUPPORTED_ERROR = 16, /* Requested operation not supported in current context */
- U_ERROR_LIMIT
-};
-
-#ifndef XP_CPLUSPLUS
-typedef enum UErrorCode UErrorCode;
-#endif
-
-/* Use the following to determine if an UErrorCode represents */
-/* operational success or failure. */
-#ifdef XP_CPLUSPLUS
-inline bool_t U_SUCCESS(UErrorCode code) { return (bool_t)(code<=U_ZERO_ERROR); }
-inline bool_t U_FAILURE(UErrorCode code) { return (bool_t)(code>U_ZERO_ERROR); }
-#else
-#define U_SUCCESS(x) ((x)<=U_ZERO_ERROR)
-#define U_FAILURE(x) ((x)>U_ZERO_ERROR)
-#endif
-
-#ifndef TRUE
-# define TRUE 1
-#endif
-#ifndef FALSE
-# define FALSE 0
-#endif
-
-// UTYPES_H
-#endif
diff --git a/jdk/src/share/native/sun/font/layout/LETypes.h b/jdk/src/share/native/sun/font/layout/LETypes.h
index 8a0de62fa6c..db66c5b0b7a 100644
--- a/jdk/src/share/native/sun/font/layout/LETypes.h
+++ b/jdk/src/share/native/sun/font/layout/LETypes.h
@@ -36,7 +36,8 @@
#define LE_USE_CMEMORY
#ifdef LE_USE_CMEMORY
-#include "cmemory.h"
+#include
+#include
#endif
#ifndef _LP64
diff --git a/jdk/test/java/text/Bidi/BidiBug.java b/jdk/test/java/text/Bidi/BidiBug.java
index 36ffcd7e440..ad9130557b1 100644
--- a/jdk/test/java/text/Bidi/BidiBug.java
+++ b/jdk/test/java/text/Bidi/BidiBug.java
@@ -23,7 +23,7 @@
/*
* @test
- * @bug 4827312
+ * @bug 4827312 6850113
* @summary verify that argument validity check is not fooled by overflow
*/
public class BidiBug {
@@ -33,9 +33,9 @@ public class BidiBug {
java.text.Bidi bidi = new java.text.Bidi(new char[20],10,buff,Integer.MAX_VALUE-3,4,1);
}
catch (IllegalArgumentException e) {
- System.out.println(e);
+ System.out.println("Passed: " + e);
return; // success
}
- throw new RuntimeException("didn't throw error, though we didn't crash either");
+ throw new RuntimeException("Failed: Bidi didn't throw error, though we didn't crash either");
}
}
diff --git a/jdk/test/java/text/Bidi/BidiConformance.java b/jdk/test/java/text/Bidi/BidiConformance.java
new file mode 100644
index 00000000000..1504f783b87
--- /dev/null
+++ b/jdk/test/java/text/Bidi/BidiConformance.java
@@ -0,0 +1,2334 @@
+/*
+ * Copyright (c) 2009 Sun Microsystems, Inc. All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+/*
+ * @test
+ * @bug 6850113
+ * @summary confirm the behavior of new Bidi implementation. (Backward compatibility)
+ */
+
+import java.awt.font.NumericShaper;
+import java.awt.font.TextAttribute;
+import java.text.AttributedString;
+import java.text.Bidi;
+import java.util.Arrays;
+
+public class BidiConformance {
+
+ /* internal flags */
+ private static boolean error = false;
+ private static boolean verbose = false;
+ private static boolean abort = false;
+
+ public static void main(String[] args) {
+ for (int i = 0; i < args.length; i++) {
+ String arg = args[i];
+ if (arg.equals("-verbose")) {
+ verbose = true;
+ } else if (arg.equals("-abort")) {
+ abort = true;
+ }
+ }
+
+ BidiConformance bc = new BidiConformance();
+ bc.test();
+
+ if (error) {
+ throw new RuntimeException("Failed.");
+ } else {
+ System.out.println("Passed.");
+ }
+ }
+
+ private void test() {
+ testConstants();
+ testConstructors();
+ testMethods();
+
+ testMethods4Constructor1(); // Bidi(AttributedCharacterIterator)
+ testMethods4Constructor2(); // Bidi(String, int)
+ testMethods4Constructor3(); // Bidi(char[], ...)
+ }
+
+ private void testConstants() {
+ System.out.println("*** Test constants");
+
+ checkResult("Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT",
+ -2, Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
+ checkResult("Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT",
+ -1, Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT);
+ checkResult("Bidi.DIRECTION_LEFT_TO_RIGHT",
+ 0, Bidi.DIRECTION_LEFT_TO_RIGHT);
+ checkResult("Bidi.DIRECTION_RIGHT_TO_LEFT",
+ 1, Bidi.DIRECTION_RIGHT_TO_LEFT);
+ }
+
+ private void testConstructors() {
+ System.out.println("*** Test constructors");
+
+ testConstructor1(); // Bidi(AttributedCharacterIterator)
+ testConstructor2(); // Bidi(String, int)
+ testConstructor3(); // Bidi(char[], ...)
+ }
+
+ private void testMethods() {
+ System.out.println("*** Test methods");
+
+ testMethod_createLineBidi1();
+ testMethod_createLineBidi2();
+ testMethod_getLevelAt();
+ testMethod_getRunLevel();
+ testMethod_getRunLimit();
+ testMethod_getRunStart();
+ testMethod_reorderVisually1();
+ testMethod_reorderVisually2();
+ testMethod_requiresBidi();
+ }
+
+ private void testMethods4Constructor1() {
+ System.out.println("*** Test methods for constructor 1");
+
+ String paragraph;
+ Bidi bidi;
+ NumericShaper ns = NumericShaper.getShaper(NumericShaper.ARABIC);
+
+ for (int textNo = 0; textNo < data4Constructor1.length; textNo++) {
+ paragraph = data4Constructor1[textNo][0];
+ int start = paragraph.indexOf('<')+1;
+ int limit = paragraph.indexOf('>');
+ int testNo;
+
+ System.out.println("*** Test textNo=" + textNo +
+ ": Bidi(AttributedCharacterIterator\"" +
+ toReadableString(paragraph) + "\") " +
+ " start=" + start + ", limit=" + limit);
+
+ // Test 0
+ testNo = 0;
+ System.out.println(" Test#" + testNo +": RUN_DIRECTION_LTR");
+ AttributedString astr = new AttributedString(paragraph);
+ astr.addAttribute(TextAttribute.RUN_DIRECTION,
+ TextAttribute.RUN_DIRECTION_LTR);
+ bidi = new Bidi(astr.getIterator());
+
+ callTestEachMethod4Constructor1(textNo, testNo, bidi);
+
+ // Test 1
+ ++testNo;
+ System.out.println(" Test#" + testNo +
+ ": RUN_DIRECTION_LTR, BIDI_EMBEDDING(1)");
+ astr = new AttributedString(paragraph);
+ astr.addAttribute(TextAttribute.RUN_DIRECTION,
+ TextAttribute.RUN_DIRECTION_LTR);
+ astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(1),
+ start, limit);
+ bidi = new Bidi(astr.getIterator());
+ callTestEachMethod4Constructor1(textNo, testNo, bidi);
+
+ // Test 2
+ ++testNo;
+ System.out.println(" Test#" + testNo +
+ ": RUN_DIERCTION_LTR, BIDI_EMBEDDING(2)");
+ astr = new AttributedString(paragraph);
+ astr.addAttribute(TextAttribute.RUN_DIRECTION,
+ TextAttribute.RUN_DIRECTION_LTR);
+ astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(2),
+ start, limit);
+ bidi = new Bidi(astr.getIterator());
+ callTestEachMethod4Constructor1(textNo, testNo, bidi);
+
+ // Test 3
+ ++testNo;
+ System.out.println(" Test#" + testNo +
+ ": RUN_DIRECTIOIN_LTR, BIDI_EMBEDDING(-3)");
+ astr = new AttributedString(paragraph);
+ astr.addAttribute(TextAttribute.RUN_DIRECTION,
+ TextAttribute.RUN_DIRECTION_LTR);
+ astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(-3),
+ start, limit);
+ bidi = new Bidi(astr.getIterator());
+ callTestEachMethod4Constructor1(textNo, testNo, bidi);
+
+ // Test 4
+ ++testNo;
+ System.out.println(" Test#" + testNo +
+ ": RUN_DIRECTION_LTR, BIDI_EMBEDDING(-4)");
+ astr = new AttributedString(paragraph);
+ astr.addAttribute(TextAttribute.RUN_DIRECTION,
+ TextAttribute.RUN_DIRECTION_LTR);
+ astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(-4),
+ start, limit);
+ bidi = new Bidi(astr.getIterator());
+ callTestEachMethod4Constructor1(textNo, testNo, bidi);
+
+ // Test 5
+ ++testNo;
+ System.out.println(" Test#" + testNo + ": RUN_DIRECTION_RTL");
+ astr = new AttributedString(paragraph);
+ astr.addAttribute(TextAttribute.RUN_DIRECTION,
+ TextAttribute.RUN_DIRECTION_RTL);
+ bidi = new Bidi(astr.getIterator());
+ callTestEachMethod4Constructor1(textNo, testNo, bidi);
+
+ // Test 6
+ ++testNo;
+ System.out.println(" Test#" + testNo +
+ ": RUN_DIRECTION_RTL, BIDI_EMBEDDING(1)");
+ astr = new AttributedString(paragraph);
+ astr.addAttribute(TextAttribute.RUN_DIRECTION,
+ TextAttribute.RUN_DIRECTION_RTL);
+ astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(1),
+ start, limit);
+ try {
+ bidi = new Bidi(astr.getIterator());
+ callTestEachMethod4Constructor1(textNo, testNo, bidi);
+ }
+ catch (IllegalArgumentException e) {
+ errorHandling(" Unexpected exception: " + e);
+ }
+
+ // Test 7
+ ++testNo;
+ System.out.println(" Test#" + testNo +
+ ": RUN_DIRECTION_RTL, BIDI_EMBEDDING(2)");
+ astr = new AttributedString(paragraph);
+ astr.addAttribute(TextAttribute.RUN_DIRECTION,
+ TextAttribute.RUN_DIRECTION_RTL);
+ astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(2),
+ start, limit);
+ try {
+ bidi = new Bidi(astr.getIterator());
+ callTestEachMethod4Constructor1(textNo, testNo, bidi);
+ }
+ catch (IllegalArgumentException e) {
+ errorHandling(" Unexpected exception: " + e);
+ }
+
+ // Test 8
+ ++testNo;
+ System.out.println(" Test#" + testNo +
+ ": RUN_DIRECTION_RTL, BIDI_EMBEDDING(-3)");
+ astr = new AttributedString(paragraph);
+ astr.addAttribute(TextAttribute.RUN_DIRECTION,
+ TextAttribute.RUN_DIRECTION_RTL);
+ astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(-3),
+ start, limit);
+ try {
+ bidi = new Bidi(astr.getIterator());
+ callTestEachMethod4Constructor1(textNo, testNo, bidi);
+ }
+ catch (IllegalArgumentException e) {
+ errorHandling(" Unexpected exception: " + e);
+ }
+
+ // Test 9
+ ++testNo;
+ System.out.println(" Test#" + testNo +
+ ": RUN_DIRECTION_RTL, BIDI_EMBEDDING(-4)");
+ astr = new AttributedString(paragraph);
+ astr.addAttribute(TextAttribute.RUN_DIRECTION,
+ TextAttribute.RUN_DIRECTION_RTL);
+ astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(-4),
+ start, limit);
+ try {
+ bidi = new Bidi(astr.getIterator());
+ callTestEachMethod4Constructor1(textNo, testNo, bidi);
+ }
+ catch (IllegalArgumentException e) {
+ errorHandling(" Unexpected exception: " + e);
+ }
+
+ // Test 10
+ ++testNo;
+ System.out.println(" Test#" + testNo +
+ ": TextAttribute not specified");
+ astr = new AttributedString(paragraph);
+ bidi = new Bidi(astr.getIterator());
+ callTestEachMethod4Constructor1(textNo, testNo, bidi);
+
+ // Test 11
+ ++testNo;
+ System.out.println(" Test#" + testNo +
+ ": RUN_DIRECTION_LTR, NUMERIC_SHAPING(ARABIC)");
+ astr = new AttributedString(paragraph);
+ astr.addAttribute(TextAttribute.RUN_DIRECTION,
+ TextAttribute.RUN_DIRECTION_LTR);
+ astr.addAttribute(TextAttribute.NUMERIC_SHAPING, ns);
+ bidi = new Bidi(astr.getIterator());
+ callTestEachMethod4Constructor1(textNo, testNo, bidi);
+
+ // Test 12
+ ++testNo;
+ System.out.println(" Test#" + testNo +
+ ": RUN_DIRECTION_RTL, NUMERIC_SHAPING(ARABIC)");
+ astr = new AttributedString(paragraph);
+ astr.addAttribute(TextAttribute.RUN_DIRECTION,
+ TextAttribute.RUN_DIRECTION_RTL);
+ astr.addAttribute(TextAttribute.NUMERIC_SHAPING, ns);
+ bidi = new Bidi(astr.getIterator());
+ callTestEachMethod4Constructor1(textNo, testNo, bidi);
+ }
+ }
+
+ private void testMethods4Constructor2() {
+ System.out.println("*** Test methods for constructor 2");
+
+ String paragraph;
+ Bidi bidi;
+
+ for (int textNo = 0; textNo < data4Constructor2.length; textNo++) {
+ paragraph = data4Constructor2[textNo][0];
+ for (int flagNo = 0; flagNo < FLAGS.length; flagNo++) {
+ int flag = FLAGS[flagNo];
+
+ System.out.println("*** Test textNo=" + textNo +
+ ": Bidi(\"" + toReadableString(paragraph) +
+ "\", " + getFlagName(flag) + ")");
+
+ bidi = new Bidi(paragraph, flag);
+ callTestEachMethod4Constructor2(textNo, flagNo, bidi);
+ }
+ }
+ }
+
+ private void testMethods4Constructor3() {
+ System.out.println("*** Test methods for constructor 3");
+
+ String paragraph;
+ Bidi bidi;
+
+ for (int textNo = 0; textNo < data4Constructor3.length; textNo++) {
+ paragraph = data4Constructor3[textNo][0];
+ char[] c = paragraph.toCharArray();
+ int start = paragraph.indexOf('<')+1;
+ byte[][] embeddings = (c.length < emb4Constructor3[1][0].length) ?
+ emb4Constructor3[0] : emb4Constructor3[1];
+ for (int flagNo = 0; flagNo < FLAGS.length; flagNo++) {
+ int flag = FLAGS[flagNo];
+ for (int embNo = 0; embNo < embeddings.length; embNo++) {
+ int dataNo = flagNo * FLAGS.length + embNo;
+
+ System.out.println("*** Test textNo=" + textNo +
+ ": Bidi(char[]\"" + toReadableString(paragraph) +
+ "\", 0, embeddings={" + toString(embeddings[embNo]) +
+ "}, " + c.length + ", " +
+ getFlagName(flag) + ")" + " dataNo=" + dataNo);
+
+ try {
+ bidi = new Bidi(c, 0, embeddings[embNo], 0,
+ c.length, flag);
+ callTestEachMethod4Constructor3(textNo, dataNo, bidi);
+ }
+ catch (Exception e) {
+ errorHandling(" Unexpected exception: " + e);
+ }
+ }
+ }
+ }
+ }
+
+ private void testConstructor1() {
+ Bidi bidi;
+
+ try {
+ bidi = new Bidi(null);
+ errorHandling("Bidi((AttributedCharacterIterator)null) " +
+ "should throw an IAE.");
+ }
+ catch (IllegalArgumentException e) {
+ }
+ catch (NullPointerException e) {
+ errorHandling("Bidi((AttributedCharacterIterator)null) " +
+ "should not throw an NPE but an IAE.");
+ }
+
+ String paragraph = data4Constructor1[1][0];
+ int start = paragraph.indexOf('<')+1;
+ int limit = paragraph.indexOf('>');
+ AttributedString astr = new AttributedString(paragraph);
+ astr.addAttribute(TextAttribute.RUN_DIRECTION,
+ TextAttribute.RUN_DIRECTION_RTL);
+ astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(-61),
+ start, limit);
+ try {
+ bidi = new Bidi(astr.getIterator());
+ for (int i = start; i < limit; i++) {
+ if (bidi.getLevelAt(i) != 61) {
+ errorHandling("Bidi(AttributedCharacterIterator).getLevelAt(" +
+ i + ") should not be " + bidi.getLevelAt(i) +
+ " but 60 when BIDI_EMBEDDING is -61.");
+ }
+ }
+ }
+ catch (Exception e) {
+ errorHandling(" Unexpected exception: " + e);
+ }
+
+ astr = new AttributedString(paragraph);
+ astr.addAttribute(TextAttribute.RUN_DIRECTION,
+ TextAttribute.RUN_DIRECTION_RTL);
+ astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(-62),
+ start, limit);
+ try {
+ bidi = new Bidi(astr.getIterator());
+ for (int i = start; i < limit; i++) {
+ if (bidi.getLevelAt(i) != 1) {
+ errorHandling("Bidi(AttributedCharacterIterator).getLevelAt() " +
+ "should be 1 when BIDI_EMBEDDING is -62.");
+ }
+ }
+ }
+ catch (Exception e) {
+ errorHandling(" Unexpected exception: " + e);
+ }
+
+ astr = new AttributedString(paragraph);
+ astr.addAttribute(TextAttribute.RUN_DIRECTION,
+ TextAttribute.RUN_DIRECTION_RTL);
+ astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(60),
+ start, limit);
+ try {
+ bidi = new Bidi(astr.getIterator());
+ for (int i = start; i < limit; i++) {
+ if (bidi.getLevelAt(i) != 61) {
+ errorHandling("Bidi(AttributedCharacterIterator).getLevelAt() " +
+ "should be 61 when BIDI_EMBEDDING is 60.");
+ }
+ }
+ }
+ catch (Exception e) {
+ errorHandling(" Unexpected exception: " + e);
+ }
+
+ astr = new AttributedString(paragraph);
+ astr.addAttribute(TextAttribute.RUN_DIRECTION,
+ TextAttribute.RUN_DIRECTION_RTL);
+ astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(61),
+ start, limit);
+ try {
+ bidi = new Bidi(astr.getIterator());
+ for (int i = start; i < limit; i++) {
+ if (bidi.getLevelAt(i) != 61) {
+ errorHandling("Bidi(AttributedCharacterIterator).getLevelAt(" +
+ i + ") should not be " + bidi.getLevelAt(i) +
+ " but 61 when BIDI_EMBEDDING is 61.");
+ }
+ }
+ }
+ catch (Exception e) {
+ errorHandling(" Unexpected exception: " + e);
+ }
+
+ astr = new AttributedString(paragraph);
+ astr.addAttribute(TextAttribute.RUN_DIRECTION,
+ TextAttribute.RUN_DIRECTION_RTL);
+ astr.addAttribute(TextAttribute.BIDI_EMBEDDING, new Integer(62),
+ start, limit);
+ try {
+ bidi = new Bidi(astr.getIterator());
+ for (int i = start; i < limit; i++) {
+ if (bidi.getLevelAt(i) != 1) {
+ errorHandling("Bidi(AttributedCharacterIterator).getLevelAt()" +
+ " should not be " + bidi.getLevelAt(i) +
+ " but 1 when BIDI_EMBEDDING is 62.");
+ }
+ }
+ }
+ catch (Exception e) {
+ errorHandling(" Unexpected exception: " + e);
+ }
+ }
+
+ private void testConstructor2() {
+ Bidi bidi;
+
+ try {
+ bidi = new Bidi(null, Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
+ errorHandling("Bidi((String)null, DIRECTION_DEFAULT_LEFT_TO_RIGHT)" +
+ " should throw an IAE.");
+ }
+ catch (IllegalArgumentException e) {
+ }
+ catch (NullPointerException e) {
+ errorHandling("Bidi((String)null, DIRECTION_DEFAULT_LEFT_TO_RIGHT) " +
+ "should not throw an NPE but an IAE.");
+ }
+
+ try {
+ bidi = new Bidi("abc", -3);
+ }
+ catch (Exception e) {
+ errorHandling("Bidi(\"abc\", -3) should not throw an exception: " +
+ e);
+ }
+
+ try {
+ bidi = new Bidi("abc", 2);
+ }
+ catch (Exception e) {
+ errorHandling("Bidi(\"abc\", 2) should not throw an exception: " +
+ e);
+ }
+ }
+
+ private void testConstructor3() {
+ char[] text = {'a', 'b', 'c', 'd', 'e'};
+ byte[] embeddings = {0, 0, 0, 0, 0};
+ Bidi bidi;
+
+ try {
+ bidi = new Bidi(null, 0, embeddings, 0, 5,
+ Bidi.DIRECTION_LEFT_TO_RIGHT);
+ errorHandling("Bidi(char[], ...) should throw an IAE " +
+ "when text=null.");
+ }
+ catch (IllegalArgumentException e) {
+ }
+ catch (NullPointerException e) {
+ errorHandling("Bidi(char[], ...) should not throw an NPE " +
+ "but an IAE when text=null.");
+ }
+
+ try {
+ bidi = new Bidi(text, -1, embeddings, 0, 5,
+ Bidi.DIRECTION_LEFT_TO_RIGHT);
+ errorHandling("Bidi(char[], ...) should throw an IAE " +
+ "when textStart is incorrect(-1: too small).");
+ }
+ catch (IllegalArgumentException e) {
+ }
+ catch (ArrayIndexOutOfBoundsException e) {
+ errorHandling("Bidi(char[], ...) should not throw an NPE " +
+ "but an IAE when textStart is incorrect(-1: too small).");
+ }
+
+ try {
+ bidi = new Bidi(text, 4, embeddings, 0, 2,
+ Bidi.DIRECTION_LEFT_TO_RIGHT);
+ errorHandling("Bidi(char[], ...) should throw an IAE " +
+ "when textStart is incorrect(4: too large).");
+ }
+ catch (IllegalArgumentException e) {
+ }
+ catch (ArrayIndexOutOfBoundsException e) {
+ errorHandling("Bidi(char[], ...) should not throw an NPE " +
+ "but an IAE when textStart is incorrect(4: too large).");
+ }
+
+ byte[] actualLevels = new byte[text.length];
+ byte[] validEmbeddings1 = {0, -61, -60, -2, -1};
+ byte[] expectedLevels1 = {0, 61, 60, 2, 1};
+ try {
+ bidi = new Bidi(text, 0, validEmbeddings1, 0, 5,
+ Bidi.DIRECTION_LEFT_TO_RIGHT);
+ for (int i = 0; i < text.length; i++) {
+ actualLevels[i] = (byte)bidi.getLevelAt(i);
+ }
+ if (!Arrays.equals(expectedLevels1, actualLevels)) {
+ errorHandling("Bidi(char[], ...).getLevelAt()" +
+ " should be {" + toString(actualLevels) +
+ "} when embeddings are {" +
+ toString(expectedLevels1) + "}.");
+ }
+ }
+ catch (Exception e) {
+ errorHandling("Bidi(char[], ...) should not throw an exception " +
+ "when embeddings is valid(-61).");
+ }
+
+ byte[] validEmbeddings2 = {0, 61, 60, 2, 1};
+ byte[] expectedLevels2 = {0, 62, 60, 2, 2};
+ try {
+ bidi = new Bidi(text, 0, validEmbeddings2, 0, 5,
+ Bidi.DIRECTION_LEFT_TO_RIGHT);
+ for (int i = 0; i < text.length; i++) {
+ actualLevels[i] = (byte)bidi.getLevelAt(i);
+ }
+ if (!Arrays.equals(expectedLevels2, actualLevels)) {
+ errorHandling("Bidi(char[], ...).getLevelAt()" +
+ " should be {" + toString(actualLevels) +
+ "} when embeddings are {" +
+ toString(expectedLevels2) + "}.");
+ }
+ }
+ catch (Exception e) {
+ errorHandling("Bidi(char[], ...) should not throw an exception " +
+ "when embeddings is valid(61).");
+ }
+
+ byte[] invalidEmbeddings1 = {0, -62, 0, 0, 0};
+ try {
+ bidi = new Bidi(text, 0, invalidEmbeddings1, 0, 5,
+ Bidi.DIRECTION_LEFT_TO_RIGHT);
+ if (bidi.getLevelAt(1) != 0) {
+ errorHandling("Bidi(char[], ...).getLevelAt(1) should be 0 " +
+ "when embeddings[1] is -62.");
+ }
+ }
+ catch (Exception e) {
+ errorHandling("Bidi(char[], ...) should not throw an exception " +
+ "even when embeddings includes -62.");
+ }
+
+ byte[] invalidEmbeddings2 = {0, 62, 0, 0, 0};
+ try {
+ bidi = new Bidi(text, 0, invalidEmbeddings2, 0, 5,
+ Bidi.DIRECTION_LEFT_TO_RIGHT);
+ if (bidi.getLevelAt(1) != 0) {
+ errorHandling("Bidi(char[], ...).getLevelAt(1) should be 0 " +
+ "when embeddings[1] is 62.");
+ }
+ }
+ catch (Exception e) {
+ errorHandling("Bidi(char[], ...) should not throw an exception " +
+ "even when embeddings includes 62.");
+ }
+
+ try {
+ bidi = new Bidi(text, 0, embeddings, 0, -1,
+ Bidi.DIRECTION_LEFT_TO_RIGHT);
+ errorHandling("Bidi(char[], ...) should throw an IAE " +
+ "when paragraphLength=-1(too small).");
+ }
+ catch (IllegalArgumentException e) {
+ }
+ catch (NegativeArraySizeException e) {
+ errorHandling("Bidi(char[], ...) should not throw an NASE " +
+ "but an IAE when paragraphLength=-1(too small).");
+ }
+
+ try {
+ bidi = new Bidi(text, 0, embeddings, 0, 6,
+ Bidi.DIRECTION_LEFT_TO_RIGHT);
+ errorHandling("Bidi(char[], ...) should throw an IAE " +
+ "when paragraphLength=6(too large).");
+ }
+ catch (IllegalArgumentException e) {
+ }
+ catch (ArrayIndexOutOfBoundsException e) {
+ errorHandling("Bidi(char[], ...) should not throw an AIOoBE " +
+ "but an IAE when paragraphLength=6(too large).");
+ }
+
+ try {
+ bidi = new Bidi(text, 0, embeddings, 0, 4, -3);
+ }
+ catch (Exception e) {
+ errorHandling("Bidi(char[], ...) should not throw an exception " +
+ "even when flag=-3(too small).");
+ }
+
+ try {
+ bidi = new Bidi(text, 0, embeddings, 0, 5, 2);
+ }
+ catch (Exception e) {
+ errorHandling("Bidi(char[], ...) should not throw an exception " +
+ "even when flag=2(too large).");
+ }
+ }
+
+ private void callTestEachMethod4Constructor1(int textNo,
+ int testNo,
+ Bidi bidi) {
+ testEachMethod(bidi,
+ data4Constructor1[textNo][0],
+ data4Constructor1[textNo][testNo+1],
+ baseIsLTR4Constructor1[textNo][testNo],
+ isLTR_isRTL4Constructor1[textNo][0][testNo],
+ isLTR_isRTL4Constructor1[textNo][1][testNo]);
+System.out.println(bidi.toString());
+ }
+
+ private void callTestEachMethod4Constructor2(int textNo,
+ int flagNo,
+ Bidi bidi) {
+ testEachMethod(bidi,
+ data4Constructor2[textNo][0],
+ data4Constructor2[textNo][flagNo+1],
+ baseIsLTR4Constructor2[textNo][flagNo],
+ isLTR_isRTL4Constructor2[textNo][0][flagNo],
+ isLTR_isRTL4Constructor2[textNo][1][flagNo]);
+System.out.println(bidi.toString());
+ }
+
+ private void callTestEachMethod4Constructor3(int textNo,
+ int dataNo,
+ Bidi bidi) {
+ testEachMethod(bidi,
+ data4Constructor3[textNo][0],
+ data4Constructor3[textNo][dataNo+1],
+ baseIsLTR4Constructor3[textNo][dataNo],
+ isLTR_isRTL4Constructor3[textNo][0][dataNo],
+ isLTR_isRTL4Constructor3[textNo][1][dataNo]);
+System.out.println(bidi.toString());
+ }
+
+ private StringBuilder sb = new StringBuilder();
+ private void testEachMethod(Bidi bidi,
+ String text,
+ String expectedLevels,
+ boolean expectedBaseIsLTR,
+ boolean expectedIsLTR,
+ boolean expectedIsRTL
+ ) {
+ /* Test baseIsLeftToRight() */
+ boolean actualBoolean = bidi.baseIsLeftToRight();
+ checkResult("baseIsLeftToRight()", expectedBaseIsLTR, actualBoolean);
+
+ /* Test getBaseLevel() */
+ int expectedInt = (expectedBaseIsLTR) ? 0 : 1;
+ int actualInt = bidi.getBaseLevel();
+ checkResult("getBaseLevel()", expectedInt, actualInt);
+
+ /* Test getLength() */
+ expectedInt = text.length();
+ actualInt = bidi.getLength();
+ checkResult("getLength()", expectedInt, actualInt);
+
+ /* Test getLevelAt() */
+ sb.setLength(0);
+ for (int i = 0; i < text.length(); i++) {
+ sb.append(bidi.getLevelAt(i));
+ }
+ checkResult("getLevelAt()", expectedLevels, sb.toString());
+
+ /* Test getRunCount() */
+ expectedInt = getRunCount(expectedLevels);
+ actualInt = bidi.getRunCount();
+ checkResult("getRunCount()", expectedInt, actualInt);
+
+ /* Test getRunLevel(), getRunLimit() and getRunStart() */
+ if (expectedInt == actualInt) {
+ int runCount = expectedInt;
+ int[] expectedRunLevels = getRunLevels_int(runCount, expectedLevels);
+ int[] expectedRunLimits = getRunLimits(runCount, expectedLevels);
+ int[] expectedRunStarts = getRunStarts(runCount, expectedLevels);
+ int[] actualRunLevels = new int[runCount];
+ int[] actualRunLimits = new int[runCount];
+ int[] actualRunStarts = new int[runCount];
+
+ for (int k = 0; k < runCount; k++) {
+ actualRunLevels[k] = bidi.getRunLevel(k);
+ actualRunLimits[k] = bidi.getRunLimit(k);
+ actualRunStarts[k] = bidi.getRunStart(k);
+ }
+
+ checkResult("getRunLevel()", expectedRunLevels, actualRunLevels);
+ checkResult("getRunStart()", expectedRunStarts, actualRunStarts);
+ checkResult("getRunLimit()", expectedRunLimits, actualRunLimits);
+ }
+
+ /* Test isLeftToRight() */
+ boolean expectedBoolean = expectedIsLTR;
+ actualBoolean = bidi.isLeftToRight();
+ checkResult("isLeftToRight()", expectedBoolean, actualBoolean);
+
+ /* Test isMixed() */
+ expectedBoolean = !(expectedIsLTR || expectedIsRTL);
+ actualBoolean = bidi.isMixed();
+ checkResult("isMixed()", expectedBoolean, actualBoolean);
+
+ /* Test isRightToLeft() */
+ expectedBoolean = expectedIsRTL;
+ actualBoolean = bidi.isRightToLeft();
+ checkResult("isRightToLeft()", expectedBoolean, actualBoolean);
+ }
+
+ private int getRunCount(String levels) {
+ int len = levels.length();
+ char c = levels.charAt(0);
+ int runCount = 1;
+
+ for (int index = 1; index < len; index++) {
+ if (levels.charAt(index) != c) {
+ runCount++;
+ c = levels.charAt(index);
+ }
+ }
+
+ return runCount;
+ }
+
+ private int[] getRunLevels_int(int runCount, String levels) {
+ int[] array = new int[runCount];
+ int len = levels.length();
+ char c = levels.charAt(0);
+ int i = 0;
+ array[i++] = c - '0';
+
+ for (int index = 1; index < len; index++) {
+ if (levels.charAt(index) != c) {
+ c = levels.charAt(index);
+ array[i++] = c - '0';
+ }
+ }
+
+ return array;
+ }
+
+ private byte[] getRunLevels_byte(int runCount, String levels) {
+ byte[] array = new byte[runCount];
+ int len = levels.length();
+ char c = levels.charAt(0);
+ int i = 0;
+ array[i++] = (byte)(c - '0');
+
+ for (int index = 1; index < len; index++) {
+ if (levels.charAt(index) != c) {
+ c = levels.charAt(index);
+ array[i++] = (byte)(c - '0');
+ }
+ }
+
+ return array;
+ }
+
+ private int[] getRunLimits(int runCount, String levels) {
+ int[] array = new int[runCount];
+ int len = levels.length();
+ char c = levels.charAt(0);
+ int i = 0;
+
+ for (int index = 1; index < len; index++) {
+ if (levels.charAt(index) != c) {
+ c = levels.charAt(index);
+ array[i++] = index;
+ }
+ }
+ array[i] = len;
+
+ return array;
+ }
+
+ private int[] getRunStarts(int runCount, String levels) {
+ int[] array = new int[runCount];
+ int len = levels.length();
+ char c = levels.charAt(0);
+ int i = 1;
+
+ for (int index = 1; index < len; index++) {
+ if (levels.charAt(index) != c) {
+ c = levels.charAt(index);
+ array[i++] = index;
+ }
+ }
+
+ return array;
+ }
+
+ private String[] getObjects(int runCount, String text, String levels) {
+ String[] array = new String[runCount];
+ int[] runLimits = getRunLimits(runCount, levels);
+ int runStart = 0;
+
+ for (int i = 0; i < runCount; i++) {
+ array[i] = text.substring(runStart, runLimits[i]);
+ runStart = runLimits[i];
+ }
+
+ return array;
+ }
+
+ private void testMethod_createLineBidi1() {
+ System.out.println("*** Test createLineBidi() 1");
+
+ String str = " ABC 123. " + HebrewABC + " " + NKo123 + ". ABC 123";
+
+ int lineStart = str.indexOf('.') + 2;
+ int lineLimit = str.lastIndexOf('.') + 2;
+ Bidi bidi = new Bidi(str, FLAGS[0]);
+ Bidi lineBidi = bidi.createLineBidi(lineStart, lineLimit);
+
+ checkResult("getBaseLevel()",
+ bidi.getBaseLevel(), lineBidi.getBaseLevel());
+ checkResult("getLevelAt(5)",
+ bidi.getLevelAt(lineStart+5), lineBidi.getLevelAt(5));
+ }
+
+ private void testMethod_createLineBidi2() {
+ System.out.println("*** Test createLineBidi() 2");
+
+ Bidi bidi = new Bidi(data4Constructor1[0][0], FLAGS[0]);
+ int len = data4Constructor1[0][0].length();
+
+ try {
+ Bidi lineBidi = bidi.createLineBidi(0, len);
+ }
+ catch (Exception e) {
+ errorHandling("createLineBidi(0, textLength)" +
+ " should not throw an exception.");
+ }
+
+ try {
+ Bidi lineBidi = bidi.createLineBidi(-1, len);
+ errorHandling("createLineBidi(-1, textLength)" +
+ " should throw an IAE.");
+ }
+ catch (IllegalArgumentException e) {
+ }
+
+ try {
+ Bidi lineBidi = bidi.createLineBidi(0, len+1);
+ errorHandling("createLineBidi(0, textLength+1)" +
+ " should throw an IAE.");
+ }
+ catch (IllegalArgumentException e) {
+ }
+ }
+
+ /*
+ * Confirm that getLevelAt() doesn't throw an exception for invalid offset
+ * unlike ICU4J.
+ */
+ private void testMethod_getLevelAt() {
+ System.out.println("*** Test getLevelAt()");
+
+ Bidi bidi = new Bidi(data4Constructor1[1][0], FLAGS[0]);
+ int len = data4Constructor1[1][0].length();
+
+ try {
+ int level = bidi.getLevelAt(-1);
+ if (level != bidi.getBaseLevel()) {
+ errorHandling("getLevelAt(-1) returned a wrong level." +
+ " Expected=" + bidi.getBaseLevel() + ", got=" + level);
+ }
+ }
+ catch (Exception e) {
+ errorHandling("getLevelAt(-1) should not throw an exception.");
+ }
+
+ try {
+ int level = bidi.getLevelAt(len+1);
+ if (level != bidi.getBaseLevel()) {
+ errorHandling("getLevelAt(textLength+1)" +
+ " returned a wrong level." +
+ " Expected=" + bidi.getBaseLevel() + ", got=" + level);
+ }
+ }
+ catch (Exception e) {
+ errorHandling("getLevelAt(-1) should not throw an exception.");
+ }
+ }
+
+ private void testMethod_getRunLevel() {
+ System.out.println("*** Test getRunLevel()");
+
+ String str = "ABC 123";
+ int length = str.length();
+ Bidi bidi = new Bidi(str, Bidi.DIRECTION_LEFT_TO_RIGHT);
+
+ try {
+ if (bidi.getRunLevel(-1) != 0 || // runCount - 2
+ bidi.getRunLevel(0) != 0 || // runCount - 1
+ bidi.getRunLevel(1) != 0 || // runCount
+ bidi.getRunLevel(2) != 0) { // runCount + 1
+ errorHandling("getRunLevel() should return 0" +
+ " when getRunCount() is 1.");
+ }
+ }
+ catch (Exception e) {
+ errorHandling("getRunLevel() should not throw an exception " +
+ "when getRunCount() is 1.");
+ }
+
+ str = "ABC " + HebrewABC + " 123";
+ length = str.length();
+ bidi = new Bidi(str, Bidi.DIRECTION_LEFT_TO_RIGHT);
+
+ try {
+ bidi.getRunLevel(-1);
+ errorHandling("getRunLevel() should throw an AIOoBE " +
+ "when run is -1(too small).");
+ }
+ catch (ArrayIndexOutOfBoundsException e) {
+ }
+ catch (IllegalArgumentException e) {
+ errorHandling("getRunLevel() should not throw an IAE " +
+ "but an AIOoBE when run is -1(too small).");
+ }
+
+ try {
+ bidi.getRunLevel(0);
+ bidi.getRunLevel(1);
+ bidi.getRunLevel(2);
+ }
+ catch (Exception e) {
+ errorHandling("getRunLevel() should not throw an exception" +
+ " when run is from 0 to 2(runCount-1).");
+ }
+
+ try {
+ bidi.getRunLevel(3);
+ errorHandling("getRunLevel() should throw an AIOoBE" +
+ " when run is 3(same as runCount).");
+ }
+ catch (ArrayIndexOutOfBoundsException e) {
+ }
+ catch (IllegalArgumentException e) {
+ errorHandling("getRunLevel() should not throw an IAE " +
+ "but an AIOoBE when run is 3(same as runCount).");
+ }
+ }
+
+ private void testMethod_getRunLimit() {
+ System.out.println("*** Test getRunLimit()");
+
+ String str = "ABC 123";
+ int length = str.length();
+ Bidi bidi = new Bidi(str, Bidi.DIRECTION_LEFT_TO_RIGHT);
+
+ try {
+ if (bidi.getRunLimit(-1) != length || // runCount - 2
+ bidi.getRunLimit(0) != length || // runCount - 1
+ bidi.getRunLimit(1) != length || // runCount
+ bidi.getRunLimit(2) != length) { // runCount + 1
+ errorHandling("getRunLimit() should return " + length +
+ " when getRunCount() is 1.");
+ }
+ }
+ catch (Exception e) {
+ errorHandling("getRunLimit() should not throw an exception " +
+ "when getRunCount() is 1.");
+ }
+
+ str = "ABC " + ArabicABC + " 123";
+ length = str.length();
+ bidi = new Bidi(str, Bidi.DIRECTION_LEFT_TO_RIGHT);
+
+ try {
+ bidi.getRunLimit(-1);
+ errorHandling("getRunLimit() should throw an AIOoBE " +
+ "when run is -1(too small).");
+ }
+ catch (ArrayIndexOutOfBoundsException e) {
+ }
+ catch (IllegalArgumentException e) {
+ errorHandling("getRunLimit() should not throw an IAE " +
+ "but an AIOoBE when run is -1(too small).");
+ }
+
+ try {
+ bidi.getRunLimit(0);
+ bidi.getRunLimit(1);
+ bidi.getRunLimit(2);
+ }
+ catch (ArrayIndexOutOfBoundsException e) {
+ errorHandling("getRunLimit() should not throw an AIOOBE " +
+ "when run is from 0 to 2(runCount-1).");
+ }
+
+ try {
+ bidi.getRunLimit(3);
+ errorHandling("getRunLimit() should throw an AIOoBE " +
+ "when run is 3(same as runCount).");
+ }
+ catch (ArrayIndexOutOfBoundsException e) {
+ }
+ catch (IllegalArgumentException e) {
+ errorHandling("getRunLimit() should not throw an IAE " +
+ "but an AIOoBE when run is 3(same as runCount).");
+ }
+ }
+
+ private void testMethod_getRunStart() {
+ System.out.println("*** Test getRunStart()");
+
+ String str = "ABC 123";
+ int length = str.length();
+ Bidi bidi = new Bidi(str, Bidi.DIRECTION_LEFT_TO_RIGHT);
+
+ try {
+ if (bidi.getRunStart(-1) != 0 || // runCount - 2
+ bidi.getRunStart(0) != 0 || // runCount - 1
+ bidi.getRunStart(1) != 0 || // runCount
+ bidi.getRunStart(2) != 0) { // runCount + 1
+ errorHandling("getRunStart() should return 0" +
+ " when getRunCount() is 1.");
+ }
+ }
+ catch (Exception e) {
+ errorHandling("getRunLimit() should not throw an exception" +
+ " when getRunCount() is 1.");
+ }
+
+ str = "ABC " + NKoABC + " 123";
+ length = str.length();
+ bidi = new Bidi(str, Bidi.DIRECTION_LEFT_TO_RIGHT);
+
+ try {
+ bidi.getRunStart(-1);
+ errorHandling("getRunStart() should throw an AIOoBE" +
+ " when run is -1(too small).");
+ }
+ catch (ArrayIndexOutOfBoundsException e) {
+ }
+ catch (IllegalArgumentException e) {
+ errorHandling("getRunStart() should not throw an IAE " +
+ "but an AIOoBE when run is -1(too small).");
+ }
+
+ try {
+ bidi.getRunStart(0);
+ bidi.getRunStart(1);
+ bidi.getRunStart(2);
+ }
+ catch (ArrayIndexOutOfBoundsException e) {
+ errorHandling("getRunStart() should not throw an AIOOBE " +
+ "when run is from 0 to 2(runCount-1).");
+ }
+
+ try {
+ if (bidi.getRunStart(3) != length) {
+ errorHandling("getRunStart() should return " + length +
+ " when run is 3(same as runCount).");
+ }
+ }
+ catch (Exception e) {
+ errorHandling("getRunStart() should not throw an exception " +
+ "when run is 3(same as runCount).");
+ }
+
+ try {
+ bidi.getRunStart(4);
+ errorHandling("getRunStart() should throw an AIOoBE " +
+ "when run is runCount+1(too large).");
+ }
+ catch (ArrayIndexOutOfBoundsException e) {
+ }
+ catch (IllegalArgumentException e) {
+ errorHandling("getRunStart() should not throw an IAE " +
+ "but an AIOoBE when run is runCount+1(too large).");
+ }
+ }
+
+ private void testMethod_reorderVisually1() {
+ System.out.println("*** Test reorderVisually() 1");
+
+ for (int textNo = 0; textNo < data4reorderVisually.length; textNo++) {
+ Object[] objects = data4reorderVisually[textNo][0];
+ byte[] levels = getLevels(data4reorderVisually[textNo]);
+ Object[] expectedObjects = data4reorderVisually[textNo][2];
+
+ Bidi.reorderVisually(levels, 0, objects, 0, objects.length);
+
+ checkResult("textNo=" + textNo + ": reorderVisually(levels=[" +
+ toString(levels) + "], objects=[" + toString(objects) + "])",
+ expectedObjects, objects);
+ }
+ }
+
+ private void testMethod_reorderVisually2() {
+ System.out.println("*** Test reorderVisually() 2");
+
+ Object[] objects = data4reorderVisually[0][0];
+ byte[] levels = getLevels(data4reorderVisually[0]);
+ int count = objects.length;
+ int llen = levels.length;
+ int olen = objects.length;
+
+ try {
+ Bidi.reorderVisually(null, 0, objects, 0, count);
+ errorHandling("reorderVisually() should throw a NPE " +
+ "when levels is null.");
+ }
+ catch (NullPointerException e) {
+ }
+
+ try {
+ Bidi.reorderVisually(levels, -1, objects, 0, count);
+ errorHandling("reorderVisually() should throw an IAE " +
+ "when levelStart is -1.");
+ }
+ catch (IllegalArgumentException e) {
+ }
+ catch (ArrayIndexOutOfBoundsException e) {
+ errorHandling("reorderVisually() should not throw an AIOoBE " +
+ "but an IAE when levelStart is -1.");
+ }
+
+ try {
+ Bidi.reorderVisually(levels, llen, objects, 0, count);
+ errorHandling("reorderVisually() should throw an IAE " +
+ "when levelStart is 6(levels.length).");
+ }
+ catch (IllegalArgumentException e) {
+ }
+ catch (ArrayIndexOutOfBoundsException e) {
+ errorHandling("reorderVisually() should not throw an AIOoBE " +
+ "but an IAE when levelStart is 6(levels.length).");
+ }
+
+ try {
+ Bidi.reorderVisually(levels, 0, null, 0, count);
+ errorHandling("reorderVisually() should throw a NPE" +
+ " when objects is null.");
+ }
+ catch (NullPointerException e) {
+ }
+
+ try {
+ Bidi.reorderVisually(levels, 0, objects, -1, count);
+ errorHandling("reorderVisually() should throw an IAE" +
+ " when objectStart is -1.");
+ }
+ catch (IllegalArgumentException e) {
+ }
+ catch (ArrayIndexOutOfBoundsException e) {
+ errorHandling("reorderVisually() should not throw an AIOoBE " +
+ "but an IAE when objectStart is -1.");
+ }
+
+ try {
+ Bidi.reorderVisually(levels, 0, objects, 6, objects.length);
+ errorHandling("reorderVisually() should throw an IAE " +
+ "when objectStart is 6(objects.length).");
+ }
+ catch (IllegalArgumentException e) {
+ }
+
+ try {
+ Bidi.reorderVisually(levels, 0, objects, 0, -1);
+ errorHandling("reorderVisually() should throw an IAE " +
+ "when count is -1.");
+ }
+ catch (IllegalArgumentException e) {
+ }
+ catch (NegativeArraySizeException e) {
+ errorHandling("reorderVisually() should not throw an NASE " +
+ "but an IAE when count is -1.");
+ }
+
+ try {
+ Bidi.reorderVisually(levels, 0, objects, 0, count+1);
+ errorHandling("reorderVisually() should throw an IAE " +
+ "when count is 7(objects.length+1).");
+ }
+ catch (IllegalArgumentException e) {
+ }
+ catch (ArrayIndexOutOfBoundsException e) {
+ errorHandling("reorderVisually() should not throw an AIOoBE " +
+ "but an IAE when count is 7(objects.length+1).");
+ }
+
+ try {
+ Bidi.reorderVisually(levels, 0, objects, 0, 0);
+ checkResult("reorderVisually(count=0)",
+ data4reorderVisually[0][0], objects);
+ }
+ catch (Exception e) {
+ errorHandling("reorderVisually() should not throw an exception" +
+ " when count is 0.");
+ }
+ }
+
+ private void testMethod_requiresBidi() {
+ System.out.println("*** Test requiresBidi()");
+
+ String paragraph;
+ char[] text;
+ Bidi bidi;
+
+ for (int textNo = 0; textNo < data4Constructor2.length; textNo++) {
+ paragraph = data4Constructor2[textNo][0];
+ text = paragraph.toCharArray();
+ boolean rBidi = Bidi.requiresBidi(text, 0, text.length);
+ if (rBidi != requiresBidi4Constructor2[textNo]) {
+ error = true;
+ System.err.println("Unexpected requiresBidi() value" +
+ " for requiresBidi(\"" + paragraph + "\", " + 0 + ", " +
+ text.length + ")." +
+ "\n Expected: " + requiresBidi4Constructor2[textNo] +
+ "\n Got : " + rBidi);
+ } else if (verbose) {
+ System.out.println(" Okay : requiresBidi() for" +
+ " requiresBidi(\"" + paragraph + "\", " + 0 + ", " +
+ text.length + ") Got: " + rBidi);
+ }
+ }
+
+ char[] txt = {'A', 'B', 'C', 'D', 'E'};
+ int textLength = txt.length;
+
+ try {
+ Bidi.requiresBidi(txt, -1, textLength);
+ errorHandling("requiresBidi() should throw an IAE" +
+ " when start is -1(too small).");
+ }
+ catch (IllegalArgumentException e) {
+ }
+ catch (ArrayIndexOutOfBoundsException e) {
+ errorHandling("requiresBidi() should not throw an AIOoBE " +
+ "but an IAE when start is -1(too small).");
+ }
+
+ try {
+ Bidi.requiresBidi(txt, textLength, textLength);
+ }
+ catch (Exception e) {
+ errorHandling("requiresBidi() should not throw an exception " +
+ "when start is textLength.");
+ }
+
+ try {
+ Bidi.requiresBidi(txt, textLength+1, textLength);
+ errorHandling("requiresBidi() should throw an IAE" +
+ " when start is textLength+1(too large).");
+ }
+ catch (IllegalArgumentException e) {
+ }
+
+ try {
+ Bidi.requiresBidi(txt, 0, -1);
+ errorHandling("requiresBidi() should throw an IAE" +
+ " when limit is -1(too small).");
+ }
+ catch (IllegalArgumentException e) {
+ }
+
+ try {
+ Bidi.requiresBidi(txt, 0, textLength+1);
+ errorHandling("requiresBidi() should throw an IAE" +
+ " when limit is textLength+1(too large).");
+ }
+ catch (IllegalArgumentException e) {
+ }
+ catch (ArrayIndexOutOfBoundsException e) {
+ errorHandling("requiresBidi() should not throw an AIOoBE " +
+ "but an IAE when limit is textLength+1(too large).");
+ }
+ }
+
+ private void checkResult(String name,
+ int expectedValue,
+ int actualValue) {
+ if (expectedValue != actualValue) {
+ errorHandling("Unexpected " + name + " value." +
+ " Expected: " + expectedValue + " Got: " + actualValue);
+ } else if (verbose) {
+ System.out.println(" Okay : " + name + " = " + actualValue);
+ }
+ }
+
+ private void checkResult(String name,
+ boolean expectedValue,
+ boolean actualValue) {
+ if (expectedValue != actualValue) {
+ errorHandling("Unexpected " + name + " value." +
+ " Expected: " + expectedValue + " Got: " + actualValue);
+ } else if (verbose) {
+ System.out.println(" Okay : " + name + " = " + actualValue);
+ }
+ }
+
+ private void checkResult(String name,
+ String expectedValue,
+ String actualValue) {
+ if (!expectedValue.equals(actualValue)) {
+ errorHandling("Unexpected " + name + " value." +
+ "\n\tExpected: \"" + expectedValue + "\"" +
+ "\n\tGot: \"" + actualValue + "\"");
+ } else if (verbose) {
+ System.out.println(" Okay : " + name + " = \"" +
+ actualValue + "\"");
+ }
+ }
+
+ private void checkResult(String name,
+ int[] expectedValues,
+ int[] actualValues) {
+ if (!Arrays.equals(expectedValues, actualValues)) {
+ errorHandling("Unexpected " + name + " value." +
+ "\n\tExpected: " + toString(expectedValues) + "" +
+ "\n\tGot: " + toString(actualValues) + "");
+ } else if (verbose) {
+ System.out.println(" Okay : " + name + " = " +
+ toString(actualValues));
+ }
+ }
+
+ private void checkResult(String name,
+ Object[] expectedValues,
+ Object[] actualValues) {
+ if (!Arrays.equals(expectedValues, actualValues)) {
+ errorHandling("Unexpected " + name + " value." +
+ "\n\tExpected: [" + toString(expectedValues) +
+ "]\n\tGot: [" + toString(actualValues) + "]");
+ } else if (verbose) {
+ System.out.println(" Okay : " + name + " Reordered objects = [" +
+ toString(actualValues) + "]");
+ }
+ }
+
+ private void errorHandling(String msg) {
+ if (abort) {
+ throw new RuntimeException("Error: " + msg);
+ } else {
+ error = true;
+ System.err.println("**Error:" + msg);
+ }
+ }
+
+ private String toString(int[] values) {
+ StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < values.length-1; i++) {
+ sb.append((int)values[i]);
+ sb.append(' ');
+ }
+ sb.append((int)values[values.length-1]);
+
+ return sb.toString();
+ }
+
+ private String toString(byte[] values) {
+ StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < values.length-1; i++) {
+ sb.append((byte)values[i]);
+ sb.append(' ');
+ }
+ sb.append((byte)values[values.length-1]);
+
+ return sb.toString();
+ }
+
+ private String toString(Object[] values) {
+ StringBuilder sb = new StringBuilder();
+ String name;
+
+ for (int i = 0; i < values.length-1; i++) {
+ if ((name = getStringName((String)values[i])) != null) {
+ sb.append(name);
+ sb.append(", ");
+ } else {
+ sb.append('"');
+ sb.append((String)values[i]);
+ sb.append("\", ");
+ }
+ }
+ if ((name = getStringName((String)values[values.length-1])) != null) {
+ sb.append(name);
+ } else {
+ sb.append('"');
+ sb.append((String)values[values.length-1]);
+ sb.append('\"');
+ }
+
+ return sb.toString();
+ }
+
+ private String getStringName(String str) {
+ if (ArabicABC.equals(str)) return "ArabicABC";
+ else if (Arabic123.equals(str)) return "Arabic123";
+ else if (PArabicABC.equals(str)) return "ArabicABC(Presentation form)";
+ else if (HebrewABC.equals(str)) return "HebrewABC";
+ else if (KharoshthiABC.equals(str)) return "KharoshthiABC(RTL)";
+ else if (Kharoshthi123.equals(str)) return "Kharoshthi123(RTL)";
+ else if (NKoABC.equals(str)) return "NKoABC(RTL)";
+ else if (NKo123.equals(str)) return "NKo123(RTL)";
+ else if (OsmanyaABC.equals(str)) return "OsmanyaABC(LTR)";
+ else if (Osmanya123.equals(str)) return "Osmanya123(LTR)";
+ else return null;
+ }
+
+ private String getFlagName(int flag) {
+ if (flag == -2 || flag == 0x7e) return FLAGNAMES[0];
+ else if (flag == -1 || flag == 0x7f) return FLAGNAMES[1];
+ else if (flag == 0) return FLAGNAMES[2];
+ else if (flag == 1) return FLAGNAMES[3];
+ else return "Unknown(0x" + Integer.toHexString(flag) + ")";
+ }
+
+ private String toReadableString(String str) {
+ String s = str;
+
+ s = s.replaceAll(ArabicABC, "ArabicABC");
+ s = s.replaceAll(Arabic123, "Arabic123");
+ s = s.replaceAll(PArabicABC, "ArabicABC(Presentation form)");
+ s = s.replaceAll(HebrewABC, "HebrewABC");
+ s = s.replaceAll(KharoshthiABC, "KharoshthiABC");
+ s = s.replaceAll(Kharoshthi123, "Kharoshthi123");
+ s = s.replaceAll(NKoABC, "NKoABC");
+ s = s.replaceAll(NKo123, "NKo123");
+ s = s.replaceAll(OsmanyaABC, "OsmanyaABC");
+ s = s.replaceAll(Osmanya123, "Osmanya123");
+
+ return s;
+ }
+
+ private byte[] getLevels(Object[][] data) {
+ int levelLength = data[0].length;
+ byte[] array = new byte[levelLength];
+ int textIndex = 0;
+
+ for (int i = 0; i < levelLength; i++) {
+ array[i] = (byte)(((String)data[1][0]).charAt(textIndex) - '0');
+ textIndex += ((String)data[0][i]).length();
+ }
+
+ return array;
+ }
+
+
+ /* Bidi pubilc constants */
+ private static final int[] FLAGS = {
+ Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT, // -2 (0x7e in ICU4J)
+ Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT, // -1 (0x7f in ICU4J)
+ Bidi.DIRECTION_LEFT_TO_RIGHT, // 0
+ Bidi.DIRECTION_RIGHT_TO_LEFT // 1
+ };
+
+ /* Bidi pubilc constants names */
+ private static final String[] FLAGNAMES = {
+ "DIRECTION_DEFAULT_LEFT_TO_RIGHT", // -2
+ "DIRECTION_DEFAULT_RIGHT_TO_LEFT", // -1
+ "DIRECTION_LEFT_TO_RIGHT", // 0
+ "DIRECTION_RIGHT_TO_LEFT", // 1
+ };
+
+ /* Bidirectional Character Types */
+ private static final char L = '\u200E';
+ private static final char R = '\u202F';
+ private static final char LRE = '\u202A';
+ private static final char RLE = '\u202B';
+ private static final char PDF = '\u202C';
+ private static final char LRO = '\u202D';
+ private static final char RLO = '\u202E';
+
+ /*
+ * 0x05D0-0x05EA: [R] Hewbrew letters (Strong)
+ * 0x0627-0x063A: [AL] Arabic letters (Strong)
+ * 0x0660-0x0669: [AN] Arabic-Indic digits (Weak)
+ * 0x07CA-0x07E7: [R] NKo letters (Strong)
+ * 0x07C0-0x07C9: [R] NKo digits (Strong)
+ * 0xFE50-0xFEFF: [AL] Arabic presentaion form (Strong)
+ * 0x10480-0x1049D: [L] Osmanya letters (Strong)
+ * 0x104A0-0x104A9: [L] Osmanya digits (Strong)
+ * 0x10A10-0x10A33: [R] Kharoshthi letters (Strong)
+ * 0x10A40-0x10A43: [R] Kharoshthi digits (Strong)
+ *
+ * 0x200E: [L] Left-to-right mark (Implicit, Strong)
+ * 0x200F: [R] Right-to-left mark (Implicit, Strong)
+ * 0x202A: [LRE] Left-to-right embedding (Explicit, Strong)
+ * 0x202B: [RLE] Right-to-left embedding (Explicit, Strong)
+ * 0x202C: [PDF] Pop directional formatting (Explicit, Weak)
+ * 0x202D: [LRO] Left-to-right override (Explicit, Strong)
+ * 0x202E: [RLO] Right-to-left override (Explicit, Strong)
+ */
+
+ /* Right-to-left */
+ private static String ArabicABC = "\u0627\u0628\u0629";
+ private static String Arabic123 = "\u0661\u0662\u0663";
+ private static String PArabicABC = "\uFE97\uFE92\uFE8E";
+ private static String HebrewABC = "\u05D0\u05D1\u05D2";
+ private static String KharoshthiABC =
+ new String(Character.toChars(0x10A10)) +
+ new String(Character.toChars(0x10A11)) +
+ new String(Character.toChars(0x10A12));
+ private static String Kharoshthi123 =
+ new String(Character.toChars(0x10A40)) +
+ new String(Character.toChars(0x10A41)) +
+ new String(Character.toChars(0x10A42));
+ private static String NKoABC = "\u07CA\u07CB\u07CC";
+ private static String NKo123 = "\u07C1\u07C2\u07C3";
+
+ /* Left-to-right */
+ private static String OsmanyaABC =
+ new String(Character.toChars(0x10480)) +
+ new String(Character.toChars(0x10481)) +
+ new String(Character.toChars(0x10482));
+ private static String Osmanya123 =
+ new String(Character.toChars(0x104A0)) +
+ new String(Character.toChars(0x104A1)) +
+ new String(Character.toChars(0x104A2));
+
+ /* --------------------------------------------------------------------- */
+
+ /*
+ * Test data for Bidi(char[], ...) constructor and methods
+ */
+
+ /* Text for Bidi processing and its levels */
+ private static String[][] data4Constructor1 = {
+ /* For Text #0 */
+ {"abc xyz.",
+ "000000000000000000", "000002222222000000", "000000000000000000",
+ "000003333333000000", "000000000000000000",
+ "222222222222222221", "222222222222222221", "222222222222222221",
+ "222113333333112221", "222224444444222221",
+ "000000000000000000", "000000000000000000", "222222222222222221"},
+
+ /* For Text #1 */
+ {"ABC <" + HebrewABC + " " + NKo123 + "> XYZ.",
+ "000001111111000000", "000001111111000000", "000003333333000000",
+ "000003333333000000", "000000000000000000",
+ "222111111111112221", "222111111111112221", "222223333333222221",
+ "222113333333112221", "222224444444222221",
+ "000001111111000000", "000001111111000000", "222111111111112221"},
+
+ /* For Text #2 */
+ {NKoABC + " " + NKo123 + ".",
+ "111000000000001110", "111112222222111110", "111002222222001110",
+ "111113333333111110", "111004444444001110",
+ "111112222222111111", "111112222222111111", "111112222222111111",
+ "111111111111111111", "111114444444111111",
+ "111112222222111111", "111000000000001110", "111112222222111111"},
+
+ /* For Text #3 */
+ {HebrewABC + " <" + ArabicABC + " " + Arabic123 + "> " + NKo123 + ".",
+ "111111111222111110", "111111111222111110", "111003333444001110",
+ "111113333333111110", "111004444444001110",
+ "111111111222111111", "111111111222111111", "111113333444111111",
+ "111111111111111111", "111114444444111111",
+ "111111111222111111", "111111111222111110", "111111111222111111"},
+
+ /* For Text #4 */
+ {"abc <" + NKoABC + " 123> xyz.",
+ "000001111222000000", "000001111222000000", "000003333444000000",
+ "000003333333000000", "000000000000000000",
+ "222111111222112221", "222111111222112221", "222223333444222221",
+ "222113333333112221", "222224444444222221",
+ "000001111222000000", "000001111222000000", "222111111222112221"},
+
+ /* For Text #5 */
+ {"abc xyz.",
+ "000000000111000000", "000002221111000000", "000002222333000000",
+ "000003333333000000", "000000000000000000",
+ "222222221111112221", "222222221111112221", "222222222333222221",
+ "222113333333112221", "222224444444222221",
+ "000000000111000000", "000000000111000000", "222222221111112221"},
+
+ /* For Text #6 */
+ {ArabicABC + " <" + NKoABC + " 123" + "> " + Arabic123 + ".",
+ "111111111222112220", "111111111222112220", "111003333444002220",
+ "111113333333112220", "111004444444002220",
+ "111111111222112221", "111111111222112221", "111113333444112221",
+ "111113333333112221", "111114444444112221",
+ "111111111222112221", "111111111222112220", "111111111222112221"},
+
+ /* For Text #7 */
+ {ArabicABC + " " + Arabic123 + ".",
+ "111000000111112220", "111112221111112220", "111002222333002220",
+ "111113333333112220", "111004444444002220",
+ "111112221111112221", "111112221111112221", "111112222333112221",
+ "111113333333112221", "111114444444112221",
+ "111112221111112221", "111000000111112220", "111112221111112221"},
+
+ /* For Text #8 */
+ {OsmanyaABC + " <" + KharoshthiABC + " " + Kharoshthi123 + "> " +
+ Osmanya123 + ".",
+ "000000001111111111111000000000", "000000001111111111111000000000",
+ "000000003333333333333000000000", "000000003333333333333000000000",
+ "000000000000000000000000000000",
+ "222222111111111111111112222221", "222222111111111111111112222221",
+ "222222223333333333333222222221", "222222113333333333333112222221",
+ "222222224444444444444222222221",
+ "000000001111111111111000000000", "000000001111111111111000000000",
+ "222222111111111111111112222221"},
+
+ /* For Text #9 */
+ {KharoshthiABC + " <" + OsmanyaABC + " " + Osmanya123 + "> " +
+ Kharoshthi123 + ".",
+ "111111000000000000000001111110", "111111112222222222222111111110",
+ "111111002222222222222001111110", "111111113333333333333111111110",
+ "111111004444444444444001111110",
+ "111111112222222222222111111111", "111111112222222222222111111111",
+ "111111112222222222222111111111", "111111111111111111111111111111",
+ "111111114444444444444111111111",
+ "111111112222222222222111111111", "111111000000000000000001111110",
+ "111111112222222222222111111111"},
+ };
+
+ /* Golden data for baseIsLeftToRight() results */
+ private static boolean[][] baseIsLTR4Constructor1 = {
+ /* For Text #0 */
+ {true, true, true, true, true,
+ false, false, false, false, false,
+ true, true, false},
+
+ /* For Text #1 */
+ {true, true, true, true, true,
+ false, false, false, false, false,
+ true, true, false},
+
+ /* For Text #2 */
+ {true, true, true, true, true,
+ false, false, false, false, false,
+ false, true, false},
+
+ /* For Text #3 */
+ {true, true, true, true, true,
+ false, false, false, false, false,
+ false, true, false},
+
+ /* For Text #4 */
+ {true, true, true, true, true,
+ false, false, false, false, false,
+ true, true, false},
+
+ /* For Text #5 */
+ {true, true, true, true, true,
+ false, false, false, false, false,
+ true, true, false},
+
+ /* For Text #6 */
+ {true, true, true, true, true,
+ false, false, false, false, false,
+ false, true, false},
+
+ /* For Text #7 */
+ {true, true, true, true, true,
+ false, false, false, false, false,
+ false, true, false},
+
+ /* For Text #8 */
+ {true, true, true, true, true,
+ false, false, false, false, false,
+ true, true, false},
+
+ /* For Text #9 */
+ {true, true, true, true, true,
+ false, false, false, false, false,
+ false, true, false},
+ };
+
+ /* Golden data for isLeftToRight() & isRightToLeft() results */
+ private static boolean[][][] isLTR_isRTL4Constructor1 = {
+ /* For Text #0 */
+ /* isLeftToRight() results */
+ {{true, false, true, false, true,
+ false, false, false, false, false,
+ true, true, false},
+ /* isRightToLeft() results */
+ {false, false, false, false, false,
+ false, false, false, false, false,
+ false, false, false}},
+
+ /* For Text #1 */
+ /* isLeftToRight() results */
+ {{false, false, false, false, true,
+ false, false, false, false, false,
+ false, false, false},
+ /* isRightToLeft() results */
+ {false, false, false, false, false,
+ false, false, false, false, false,
+ false, false, false}},
+
+ /* For Text #2 */
+ /* isLeftToRight() results */
+ {{false, false, false, false, false,
+ false, false, false, false, false,
+ false, false, false},
+ /* isRightToLeft() results */
+ {false, false, false, false, false,
+ false, false, false, true, false,
+ false, false, false}},
+
+ /* For Text #3 */
+ /* isLeftToRight() results */
+ {{false, false, false, false, false,
+ false, false, false, false, false,
+ false, false, false},
+ /* isRightToLeft() results */
+ {false, false, false, false, false,
+ false, false, false, true, false,
+ false, false, false}},
+
+ /* For Text #4 */
+ /* isLeftToRight() results */
+ {{false, false, false, false, true,
+ false, false, false, false, false,
+ false, false, false},
+ /* isRightToLeft() results */
+ {false, false, false, false, false,
+ false, false, false, false, false,
+ false, false, false}},
+
+ /* For Text #5 */
+ /* isLeftToRight() results */
+ {{false, false, false, false, true,
+ false, false, false, false, false,
+ false, false, false},
+ /* isRightToLeft() results */
+ {false, false, false, false, false,
+ false, false, false, false, false,
+ false, false, false}},
+
+ /* For Text #6 */
+ /* isLeftToRight() results */
+ {{false, false, false, false, false,
+ false, false, false, false, false,
+ false, false, false},
+ /* isRightToLeft() results */
+ {false, false, false, false, false,
+ false, false, false, false, false,
+ false, false, false}},
+
+ /* For Text #7 */
+ /* isLeftToRight() results */
+ {{false, false, false, false, false,
+ false, false, false, false, false,
+ false, false, false},
+ /* isRightToLeft() results */
+ {false, false, false, false, false,
+ false, false, false, false, false,
+ false, false, false}},
+
+ /* For Text #8 */
+ /* isLeftToRight() results */
+ {{false, false, false, false, true,
+ false, false, false, false, false,
+ false, false, false},
+ /* isRightToLeft() results */
+ {false, false, false, false, false,
+ false, false, false, false, false,
+ false, false, false}},
+
+ /* For Text #9 */
+ /* isLeftToRight() results */
+ {{false, false, false, false, false,
+ false, false, false, false, false,
+ false, false, false},
+ /* isRightToLeft() results */
+ {false, false, false, false, false,
+ false, false, false, true, false,
+ false, false, false}},
+ };
+
+ /* --------------------------------------------------------------------- */
+
+ /*
+ * Test data for Bidi(String, int) constructor and methods
+ */
+
+ /* Text for Bidi processing and its levels */
+ private static String[][] data4Constructor2 = {
+ /* For Text #0 */
+ {" ABC 123.",
+ "000000000", "000000000", "000000000", "122222221"},
+
+ /* For Text #1 */
+ {" ABC " + HebrewABC + " " + NKo123 + " 123.",
+ "00000111111112220", "00000111111112220", "00000111111112220",
+ "12221111111112221"},
+
+ /* For Text #2 */
+ {" ABC " + ArabicABC + " " + Arabic123 + " 123.",
+ "00000111122212220", "00000111122212220", "00000111122212220",
+ "12221111122212221"},
+
+ /* For Text #3 */
+ {" " + NKoABC + " ABC 123 " + NKo123 + ".",
+ "11111222222211111", "11111222222211111", "01110000000001110",
+ "11111222222211111"},
+
+ /* For Text #4 */
+ {" " + ArabicABC + " ABC 123 " + Arabic123 + ".",
+ "11111222222212221", "11111222222212221", "01110000000002220",
+ "11111222222212221"},
+
+ /* For Text #5 */
+ {" " + HebrewABC + " " + NKo123 + ".",
+ "111111111", "111111111", "011111110", "111111111"},
+
+ /* For Text #6 */
+ {" " + ArabicABC + " " + Arabic123 + ".",
+ "111112221", "111112221", "011112220", "111112221"},
+
+ /* For Text #7 */
+ {" " + KharoshthiABC + " " + Kharoshthi123 + ".",
+ "111111111111111", "111111111111111", "011111111111110",
+ "111111111111111"},
+
+ /* For Text #8 */
+ {L + HebrewABC + " " + NKo123 + ".",
+ "011111110", "011111110", "011111110", "211111111"},
+
+ /* For Text #9 */
+ {R + "ABC " + Osmanya123 + ".",
+ "000000000000", "000000000000", "000000000000", "122222222221"},
+
+ /* For Text #10 */
+ {"ABC " + PArabicABC + " " + PArabicABC + " 123",
+ "000011111111222", "000011111111222", "000011111111222",
+ "222111111111222"},
+
+ /* For Text #11 */
+ {RLE + "ABC " + HebrewABC + " " + NKo123 + "." + PDF,
+ "22221111111110", "22221111111110", "22221111111110",
+ "44443333333331"},
+
+ /* For Text #12 */
+ {"He said \"" + RLE + "ABC " + HebrewABC + " " + NKo123 + PDF + ".\"",
+ "000000000222211111111000", "000000000222211111111000",
+ "000000000222211111111000", "222222211444433333333111"},
+
+ /* For Text #13 */
+ {LRO + "He said \"" + RLE + "ABC " + NKoABC + " " + NKo123 + PDF +
+ ".\"" + PDF,
+ "22222222224444333333332220", "22222222224444333333332220",
+ "22222222224444333333332220", "22222222224444333333332221"},
+
+ /* For Text #14 */
+ {LRO + "He said \"" + RLE + "ABC " + HebrewABC + " " + NKo123 + PDF +
+ ".\"", // PDF missing
+ "2222222222444433333333222", "2222222222444433333333222",
+ "2222222222444433333333222", "2222222222444433333333222"},
+
+ /* For Text #15 */
+ {"Did you say '" + LRE + "he said \"" + RLE + "ABC " + HebrewABC +
+ " " + NKo123 + PDF + "\"" + PDF + "'?",
+ "0000000000000222222222244443333333322000",
+ "0000000000000222222222244443333333322000",
+ "0000000000000222222222244443333333322000",
+ "2222222222222222222222244443333333322111"},
+
+ /* For Text #16 */
+ {RLO + "Did you say '" + LRE + "he said \"" + RLE + "ABC " +
+ HebrewABC + " " + NKo123 + PDF + "\"" + PDF + "'?" + PDF,
+ "111111111111112222222222444433333333221110",
+ "111111111111112222222222444433333333221110",
+ "111111111111112222222222444433333333221110",
+ "333333333333334444444444666655555555443331"},
+
+ /* For Text #17 */
+ {RLO + "Did you say '" + LRE + "he said \"" + RLE + "ABC " +
+ HebrewABC + " " + NKo123 + PDF + "\"" + PDF + "'?", // PDF missing
+ "11111111111111222222222244443333333322111",
+ "11111111111111222222222244443333333322111",
+ "11111111111111222222222244443333333322111",
+ "33333333333333444444444466665555555544333"},
+
+ /* For Text #18 */
+ {" ABC (" + ArabicABC + " " + Arabic123 + ") 123.",
+ "0000001111222112220", "0000001111222112220",
+ "0000001111222112220", "1222111111222112221"},
+
+ /* For Text #19 */
+ {" " + HebrewABC + " (ABC 123) " + NKo123 + ".",
+ "1111112222222111111", "1111112222222111111",
+ "0111000000000001110", "1111112222222111111"},
+
+ /* For Text #20 */
+ {" He said \"" + RLE + "ABC " + NKoABC + " " + NKo123 + PDF + ".\" ",
+ "00000000002222111111110000", "00000000002222111111110000",
+ "00000000002222111111110000", "12222222114444333333331111"},
+
+ /* For Text #21 */
+ {" Did you say '" + LRE + "he said \"" + RLE + "ABC " + HebrewABC +
+ " " + NKo123 + PDF + "\"" + PDF + "'? ",
+ "000000000000002222222222444433333333220000",
+ "000000000000002222222222444433333333220000",
+ "000000000000002222222222444433333333220000",
+ "122222222222222222222222444433333333221111"},
+
+ /* For Text #22 */
+ {RLE + OsmanyaABC + " " + KharoshthiABC + " " + Kharoshthi123 + "." +
+ PDF,
+ "22222221111111111111110", "22222221111111111111110",
+ "22222221111111111111110", "44444443333333333333331"},
+ };
+
+ /* Golden data for baseIsLeftToRight() results */
+ private static boolean[][] baseIsLTR4Constructor2 = {
+ /* For Text #0 - $4 */
+ {true, true, true, false},
+ {true, true, true, false},
+ {true, true, true, false},
+ {false, false, true, false},
+ {false, false, true, false},
+
+ /* For Text #5 - $9 */
+ {false, false, true, false},
+ {false, false, true, false},
+ {false, false, true, false},
+ {true, true, true, false},
+ {true, true, true, false},
+
+ /* For Text #10 - $14 */
+ {true, true, true, false},
+ {true, true, true, false},
+ {true, true, true, false},
+ {true, true, true, false},
+ {true, true, true, false},
+
+ /* For Text #15 - $19 */
+ {true, true, true, false},
+ {true, true, true, false},
+ {true, true, true, false},
+ {true, true, true, false},
+ {false, false, true, false},
+
+ /* For Text #20 - $22 */
+ {true, true, true, false},
+ {true, true, true, false},
+ {true, true, true, false},
+ };
+
+ /* Golden data for isLeftToRight() & isRightToLeft() results */
+ private static boolean[][][] isLTR_isRTL4Constructor2 = {
+ /* isLeftToRight() results & isRightToLeft() results */
+ /* For Text #0 - $4 */
+ {{true, true, true, false}, {false, false, false, false}},
+ {{false, false, false, false}, {false, false, false, false}},
+ {{false, false, false, false}, {false, false, false, false}},
+ {{false, false, false, false}, {false, false, false, false}},
+ {{false, false, false, false}, {false, false, false, false}},
+
+ /* For Text #5 - $9 */
+ {{false, false, false, false}, {true, true, false, true }},
+ {{false, false, false, false}, {false, false, false, false}},
+ {{false, false, false, false}, {true, true, false, true }},
+ {{false, false, false, false}, {false, false, false, false}},
+ {{true, true, true, false}, {false, false, false, false}},
+
+ /* For Text #10 - $14 */
+ {{false, false, false, false}, {false, false, false, false}},
+ {{false, false, false, false}, {false, false, false, false}},
+ {{false, false, false, false}, {false, false, false, false}},
+ {{false, false, false, false}, {false, false, false, false}},
+ {{false, false, false, false}, {false, false, false, false}},
+
+ /* For Text #15 - $19 */
+ {{false, false, false, false}, {false, false, false, false}},
+ {{false, false, false, false}, {false, false, false, false}},
+ {{false, false, false, false}, {false, false, false, false}},
+ {{false, false, false, false}, {false, false, false, false}},
+ {{false, false, false, false}, {false, false, false, false}},
+
+ /* For Text #20 - $22 */
+ {{false, false, false, false}, {false, false, false, false}},
+ {{false, false, false, false}, {false, false, false, false}},
+ {{false, false, false, false}, {false, false, false, false}},
+ };
+
+ /* Golden data for requiresBidi() results */
+ private static boolean[] requiresBidi4Constructor2 = {
+ /* For Text #0 - $9 */
+ false, true, true, true, true,
+ true, true, true, true, false,
+
+ /* For Text #10 - $19 */
+ true, true, true, true, true,
+ true, true, true, true, true,
+
+ /* For Text #20 - $22 */
+ true, true, true,
+ };
+
+ /* --------------------------------------------------------------------- */
+
+ /*
+ * Test data for Bidi(char[], ...) constructor and methods
+ */
+
+ /* Enbeddings */
+ private static byte[][][] emb4Constructor3 = {
+ /* Embeddings for paragraphs which don't include surrogate pairs. */
+ {{0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0, -3, -3, -3, -3, -3, -3, -3, 0, 0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0, -4, -4, -4, -4, -4, -4, -4, 0, 0, 0, 0, 0, 0}},
+
+ /* Embeddings for paragraphs which include surrogate pairs. */
+ {{ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0,
+ -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0,
+ -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0}},
+ };
+
+ /* Text for Bidi processing and its levels */
+ private static String[][] data4Constructor3 = {
+ /* For Text #0 */
+ {"abc xyz.",
+ /* DIRECTION_DEFAULT_LEFT_TO_RIGHT */
+ "000002222222000000", "000000000000000000",
+ "000003333333000000", "000000000000000000",
+ /* DIRECTION_DEFAULT_RIGHT_TO_LEFT */
+ "222222222222222221", "222222222222222221",
+ "222113333333112221", "222224444444222221",
+ /* DIRECTION_LEFT_TO_RIGHT */
+ "000002222222000000", "000000000000000000",
+ "000003333333000000", "000000000000000000",
+ /* DIRECTION_RIGHT_TO_LEFT */
+ "222222222222222221", "222222222222222221",
+ "222113333333112221", "222224444444222221"},
+
+ /* For Text #1 */
+ {"ABC <" + HebrewABC + " " + NKo123 + "> XYZ.",
+ /* DIRECTION_DEFAULT_LEFT_TO_RIGHT */
+ "000001111111000000", "000003333333000000",
+ "000003333333000000", "000000000000000000",
+ /* DIRECTION_DEFAULT_RIGHT_TO_LEFT */
+ "222111111111112221", "222223333333222221",
+ "222113333333112221", "222224444444222221",
+ /* DIRECTION_LEFT_TO_RIGHT */
+ "000001111111000000", "000003333333000000",
+ "000003333333000000", "000000000000000000",
+ /* DIRECTION_RIGHT_TO_LEFT */
+ "222111111111112221", "222223333333222221",
+ "222113333333112221", "222224444444222221"},
+
+ /* For Text #2 */
+ {NKoABC + " " + NKo123 + ".",
+ /* DIRECTION_DEFAULT_LEFT_TO_RIGHT */
+ "111112222222111111", "111112222222111111",
+ "111111111111111111", "111114444444111111",
+ /* DIRECTION_DEFAULT_RIGHT_TO_LEFT */
+ "111112222222111111", "111112222222111111",
+ "111111111111111111", "111114444444111111",
+ /* DIRECTION_LEFT_TO_RIGHT */
+ "111112222222111110", "111002222222001110",
+ "111113333333111110", "111004444444001110",
+ /* DIRECTION_RIGHT_TO_LEFT */
+ "111112222222111111", "111112222222111111",
+ "111111111111111111", "111114444444111111"},
+
+ /* For Text #3 */
+ {HebrewABC + " <" + ArabicABC + " " + Arabic123 + "> " + NKo123 + ".",
+ /* DIRECTION_DEFAULT_LEFT_TO_RIGHT */
+ "111111111222111111", "111113333444111111",
+ "111111111111111111", "111114444444111111",
+ /* DIRECTION_DEFAULT_RIGHT_TO_LEFT */
+ "111111111222111111", "111113333444111111",
+ "111111111111111111", "111114444444111111",
+ /* DIRECTION_LEFT_TO_RIGHT */
+ "111111111222111110", "111003333444001110",
+ "111113333333111110", "111004444444001110",
+ /* DIRECTION_RIGHT_TO_LEFT */
+ "111111111222111111", "111113333444111111",
+ "111111111111111111", "111114444444111111"},
+
+ /* For Text #4 */
+ {"abc <123 456> xyz.",
+ /* DIRECTION_DEFAULT_LEFT_TO_RIGHT */
+ "000002221222000000", "000000000000000000",
+ "000003333333000000", "000000000000000000",
+ /* DIRECTION_DEFAULT_RIGHT_TO_LEFT */
+ "222222222222222221", "222222222222222221",
+ "222113333333112221", "222224444444222221",
+ /* DIRECTION_LEFT_TO_RIGHT */
+ "000002221222000000", "000000000000000000",
+ "000003333333000000", "000000000000000000",
+ /* DIRECTION_RIGHT_TO_LEFT */
+ "222222222222222221", "222222222222222221",
+ "222113333333112221", "222224444444222221"},
+
+ /* For Text #5 */
+ {OsmanyaABC + " <" + KharoshthiABC + " " + Kharoshthi123 + "> " +
+ Osmanya123 + ".",
+ /* DIRECTION_DEFAULT_LEFT_TO_RIGHT */
+ "000000001111111111111000000000", "000000003333333333333000000000",
+ "000000003333333333333000000000", "000000000000000000000000000000",
+ /* DIRECTION_DEFAULT_RIGHT_TO_LEFT */
+ "222222111111111111111112222221", "222222223333333333333222222221",
+ "222222113333333333333112222221", "222222224444444444444222222221",
+ /* DIRECTION_LEFT_TO_RIGHT */
+ "000000001111111111111000000000", "000000003333333333333000000000",
+ "000000003333333333333000000000", "000000000000000000000000000000",
+ /* DIRECTION_RIGHT_TO_LEFT */
+ "222222111111111111111112222221", "222222223333333333333222222221",
+ "222222113333333333333112222221", "222222224444444444444222222221"},
+
+ /* For Text #6 */
+ {KharoshthiABC + " <" + OsmanyaABC + " " + Osmanya123 + "> " +
+ Kharoshthi123 + ".",
+ /* DIRECTION_DEFAULT_LEFT_TO_RIGHT */
+ "111111112222222222222111111111", "111111112222222222222111111111",
+ "111111111111111111111111111111", "111111114444444444444111111111",
+ /* DIRECTION_DEFAULT_RIGHT_TO_LEFT */
+ "111111112222222222222111111111", "111111112222222222222111111111",
+ "111111111111111111111111111111", "111111114444444444444111111111",
+ /* DIRECTION_LEFT_TO_RIGHT */
+ "111111112222222222222111111110", "111111002222222222222001111110",
+ "111111113333333333333111111110", "111111004444444444444001111110",
+ /* DIRECTION_RIGHT_TO_LEFT */
+ "111111112222222222222111111111", "111111112222222222222111111111",
+ "111111111111111111111111111111", "111111114444444444444111111111"},
+ };
+
+ /* Golden data for baseIsLeftToRight() results */
+ private static boolean[][] baseIsLTR4Constructor3 = {
+ /* For Text #0 */
+ {true, true, true, true, // DIRECTION_DEFAULT_LEFT_TO_RIGHT
+ true, true, true, true, // DIRECTION_DEFAULT_RIGHT_TO_LEFT
+ true, true, true, true, // DIRECTION_LEFT_TO_RIGHT
+ false, false, false, false}, // DIRECTION_RIGHT_TO_LEFT
+
+ /* For Text #1 */
+ {true, true, true, true,
+ true, true, true, true,
+ true, true, true, true,
+ false, false, false, false},
+
+ /* For Text #2 */
+ {false, false, false, false,
+ false, false, false, false,
+ true, true, true, true,
+ false, false, false, false},
+
+ /* For Text #3 */
+ {false, false, false, false,
+ false, false, false, false,
+ true, true, true, true,
+ false, false, false, false},
+
+ /* For Text #4 */
+ {true, true, true, true,
+ true, true, true, true,
+ true, true, true, true,
+ false, false, false, false},
+
+ /* For Text #5 */
+ {true, true, true, true,
+ true, true, true, true,
+ true, true, true, true,
+ false, false, false, false},
+
+ /* For Text #6 */
+ {false, false, false, false,
+ false, false, false, false,
+ true, true, true, true,
+ false, false, false, false},
+ };
+
+ /* Golden data for isLeftToRight() & isRightToLeft() results */
+ private static boolean[][][] isLTR_isRTL4Constructor3 = {
+ /* For Text #0 */
+ /* isLeftToRight() results */
+ {{false, true, false, true, // DIRECTION_DEFAULT_LEFT_TO_RIGHT
+ false, false, false, false, // DIRECTION_DEFAULT_RIGHT_TO_LEFT
+ false, true, false, true, // DIRECTION_LEFT_TO_RIGHT
+ false, false, false, false}, // DIRECTION_RIGHT_TO_LEFT
+ /* isRightToLeft() results */
+ {false, false, false, false, // DIRECTION_DEFAULT_LEFT_TO_RIGHT
+ false, false, false, false, // DIRECTION_DEFAULT_RIGHT_TO_LEFT
+ false, false, false, false, // DIRECTION_LEFT_TO_RIGHT
+ false, false, false, false}}, // DIRECTION_RIGHT_TO_LEFTT
+
+ /* For Text #1 */
+ /* isLeftToRight() results */
+ {{false, false, false, true,
+ false, false, false, false,
+ false, false, false, true,
+ false, false, false, false},
+ /* isRightToLeft() results */
+ {false, false, false, false,
+ false, false, false, false,
+ false, false, false, false,
+ false, false, false, false}},
+
+ /* For Text #2 */
+ /* isLeftToRight() results */
+ {{false, false, false, false,
+ false, false, false, false,
+ false, false, false, false,
+ false, false, false, false},
+ /* isRightToLeft() results */
+ {false, false, true, false,
+ false, false, true, false,
+ false, false, false, false,
+ false, false, true, false}},
+
+ /* For Text #3 */
+ /* isLeftToRight() results */
+ {{false, false, false, false,
+ false, false, false, false,
+ false, false, false, false,
+ false, false, false, false},
+ /* isRightToLeft() results */
+ {false, false, true, false,
+ false, false, true, false,
+ false, false, false, false,
+ false, false, true, false}},
+
+ /* For Text #4 */
+ /* isLeftToRight() results */
+ {{false, true, false, true,
+ false, false, false, false,
+ false, true, false, true,
+ false, false, false, false },
+ /* isRightToLeft() results */
+ {false, false, false, false,
+ false, false, false, false,
+ false, false, false, false,
+ false, false, false, false}},
+
+ /* For Text #5 */
+ /* isLeftToRight() results */
+ {{false, false, false, true,
+ false, false, false, false,
+ false, false, false, true,
+ false, false, false, false},
+ /* isRightToLeft() results */
+ {false, false, false, false,
+ false, false, false, false,
+ false, false, false, false,
+ false, false, false, false}},
+
+ /* For Text #6 */
+ /* isLeftToRight() results */
+ {{false, false, false, false,
+ false, false, false, false,
+ false, false, false, false,
+ false, false, false, false},
+ /* isRightToLeft() results */
+ {false, false, true, false,
+ false, false, true, false,
+ false, false, false, false,
+ false, false, true, false}},
+ };
+
+ /* --------------------------------------------------------------------- */
+
+ /*
+ * Test data for reorderVisually() methods
+ */
+
+ private static Object[][][] data4reorderVisually = {
+ {{"ABC", " ", "abc", " ", ArabicABC, "."}, // Original text
+ {"000000001110"}, // levels
+ {"ABC", " ", "abc", " ", ArabicABC, "."}}, // Reordered text
+
+ {{"ABC", " ", HebrewABC, " ", NKoABC, "."},
+ {"222111111111"},
+ {".", NKoABC, " ", HebrewABC, " ", "ABC"}},
+
+ {{OsmanyaABC, " ", HebrewABC, " ", KharoshthiABC, "."},
+ {"222222111111111111"},
+ {".", KharoshthiABC, " ", HebrewABC, " ", OsmanyaABC,}},
+
+ {{"ABC", " ", Osmanya123, " ", "\"", OsmanyaABC, " ", Kharoshthi123,
+ " ", KharoshthiABC, ".", "\""},
+ {"0000000000002222221111111111111100"},
+ {"ABC", " ", Osmanya123, " ", "\"", KharoshthiABC, " ", Kharoshthi123,
+ " ", OsmanyaABC, ".", "\""}},
+ };
+
+}
diff --git a/jdk/test/java/text/Bidi/BidiEmbeddingTest.java b/jdk/test/java/text/Bidi/BidiEmbeddingTest.java
index 3e967be351d..7ac77b4a647 100644
--- a/jdk/test/java/text/Bidi/BidiEmbeddingTest.java
+++ b/jdk/test/java/text/Bidi/BidiEmbeddingTest.java
@@ -23,7 +23,7 @@
/*
* @test
- * @bug 4396492 4396496 4778510
+ * @bug 4396492 4396496 4778510 6850113
* @summary verify that the embedding values processed by the bidi code use negative values to
* indicate overrides, rather than using bit 7. Also tests Bidi without loading awt classes to
* confirm that Bidi can be used without awt. Verify that embedding level 0 is properly mapped
@@ -89,10 +89,12 @@ public class BidiEmbeddingTest {
" at level " + bidi2.getRunLevel(i));
}
- System.out.println(bidi2);
+ System.out.println(bidi2 + "\n");
if (bidi.getRunCount() != 3 || bidi2.getRunCount() != 3) {
throw new Error("Bidi run count incorrect");
+ } else {
+ System.out.println("test1() passed.\n");
}
}
@@ -123,10 +125,12 @@ public class BidiEmbeddingTest {
" at level " + bidi.getRunLevel(i));
}
- System.out.println(bidi);
+ System.out.println(bidi + "\n");
if (bidi.getRunCount() != 6) { // runs of spaces and angles at embedding bound,s and final period, each get level 1
throw new Error("Bidi embedding processing failed");
+ } else {
+ System.out.println("test2() passed.\n");
}
}
}
diff --git a/jdk/test/java/text/Bidi/Bug6850113.java b/jdk/test/java/text/Bidi/Bug6850113.java
new file mode 100644
index 00000000000..2023df89a58
--- /dev/null
+++ b/jdk/test/java/text/Bidi/Bug6850113.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2009 Sun Microsystems, Inc. All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+/*
+ * @test
+ * @bug 6850113
+ * @summary Verify the return value of digit() for some digits.
+ */
+
+import sun.text.normalizer.UCharacter;
+
+public class Bug6850113 {
+
+ public static void main(String[] args) {
+ boolean err = false;
+
+ // Fullwidth Latin capital letters
+ for (int i = 0xff21, j = 10; i <= 0xff3a; i++, j++) {
+ if (UCharacter.digit(i, 36) != j) {
+ err = true;
+ System.out.println("Error: UCharacter.digit(0x" +
+ Integer.toHexString(i) + ", 36) returned " +
+ UCharacter.digit(i, 36) + ", expected=" + j);
+ }
+ }
+
+ // Fullwidth Latin small letters
+ for (int i = 0xff41, j = 10; i <= 0xff5a; i++, j++) {
+ if (UCharacter.digit(i, 36) != j) {
+ err = true;
+ System.out.println("Error: UCharacter.digit(0x" +
+ Integer.toHexString(i) + ", 36) returned " +
+ UCharacter.digit(i, 36) + ", expected=" + j);
+ }
+ }
+
+ if (err) {
+ throw new RuntimeException("UCharacter.digit(): Wrong return value");
+ }
+ }
+}