Skip to content
Browse files

Removing Bidi.java as it's license doesn't allow us to include it. Co…

…mpiled version ok.
  • Loading branch information...
1 parent cca4863 commit 35aa2dd43b9f2685680a2a121284b34d9256d389 Cameron Dutro committed Oct 9, 2012
Showing with 0 additions and 1,004 deletions.
  1. +0 −1,004 classpath/Bidi.java
View
1,004 classpath/Bidi.java
@@ -1,1004 +0,0 @@
-/* Bidi.java -- Bidirectional Algorithm implementation
- Copyright (C) 2005, 2006 Free Software Foundation, Inc.
-
-This file is part of GNU Classpath.
-
-GNU Classpath is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
-any later version.
-
-GNU Classpath 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 for more details.
-
-You should have received a copy of the GNU General Public License
-along with GNU Classpath; see the file COPYING. If not, write to the
-Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301 USA.
-
-Linking this library statically or dynamically with other modules is
-making a combined work based on this library. Thus, the terms and
-conditions of the GNU General Public License cover the whole
-combination.
-
-As a special exception, the copyright holders of this library give you
-permission to link this library with independent modules to produce an
-executable, regardless of the license terms of these independent
-modules, and to copy and distribute the resulting executable under
-terms of your choice, provided that you also meet, for each linked
-independent module, the terms and conditions of the license of that
-module. An independent module is a module which is not derived from
-or based on this library. If you modify this library, you may extend
-this exception to your version of the library, but you are not
-obligated to do so. If you do not wish to do so, delete this
-exception statement from your version. */
-
-
-package classpath;
-
-import java.awt.font.NumericShaper;
-import java.awt.font.TextAttribute;
-import java.util.ArrayList;
-import java.text.*;
-
-
-/**
- * Bidirectional Algorithm implementation.
- *
- * The full algorithm is
- * <a href="http://www.unicode.org/unicode/reports/tr9/">Unicode Standard
- * Annex #9: The Bidirectional Algorithm</a>.
- *
- * @since 1.4
- */
-public final class Bidi
-{
- /**
- * This indicates that a strongly directional character in the text should
- * set the initial direction, but if no such character is found, then the
- * initial direction will be left-to-right.
- */
- public static final int DIRECTION_DEFAULT_LEFT_TO_RIGHT = -2;
-
- /**
- * This indicates that a strongly directional character in the text should
- * set the initial direction, but if no such character is found, then the
- * initial direction will be right-to-left.
- */
- public static final int DIRECTION_DEFAULT_RIGHT_TO_LEFT = -1;
-
- /**
- * This indicates that the initial direction should be left-to-right.
- */
- public static final int DIRECTION_LEFT_TO_RIGHT = 0;
-
- /**
- * This indicates that the initial direction should be right-to-left.
- */
- public static final int DIRECTION_RIGHT_TO_LEFT = 1;
-
- // Flags used when computing the result.
- private static final int LTOR = 1 << DIRECTION_LEFT_TO_RIGHT;
- private static final int RTOL = 1 << DIRECTION_RIGHT_TO_LEFT;
-
- // The text we are examining, and the starting offset.
- // If we had a better way to handle createLineBidi, we wouldn't
- // need this at all -- which for the String case would be an
- // efficiency win.
- private char[] text;
- private int textOffset;
- // The embeddings corresponding to the text, and the starting offset.
- private byte[] embeddings;
- private int embeddingOffset;
- // The length of the text (and embeddings) to use.
- private int length;
- // The flags.
- private int flags;
-
- // All instance fields following this point are initialized
- // during analysis. Fields before this must be set by the constructor.
-
- // The initial embedding level.
- private int baseEmbedding;
- // The type of each character in the text.
- private byte[] types;
- // The levels we compute.
- private byte[] levels;
-
- // A list of indices where a formatting code was found. These
- // are indicies into the original text -- not into the text after
- // the codes have been removed.
- private ArrayList formatterIndices;
-
- // Indices of the starts of runs in the text.
- private int[] runs;
-
- // A convenience field where we keep track of what kinds of runs
- // we've seen.
- private int resultFlags;
-
- /**
- * Create a new Bidi object given an attributed character iterator.
- * This constructor will examine various attributes of the text:
- * <ul>
- * <li> {@link TextAttribute#RUN_DIRECTION} is used to determine the
- * paragraph's base embedding level. This constructor will recognize
- * either {@link TextAttribute#RUN_DIRECTION_LTR} or
- * {@link TextAttribute#RUN_DIRECTION_RTL}. If neither is given,
- * {@link #DIRECTION_DEFAULT_LEFT_TO_RIGHT} is assumed.
- * </li>
- *
- * <li> If {@link TextAttribute#NUMERIC_SHAPING} is seen, then numeric
- * shaping will be done before the Bidi algorithm is run.
- * </li>
- *
- * <li> If {@link TextAttribute#BIDI_EMBEDDING} is seen on a given
- * character, then the value of this attribute will be used as an
- * embedding level override.
- * </li>
- * </ul>
- * @param iter the attributed character iterator to use
- */
- public Bidi(AttributedCharacterIterator iter)
- {
- // If set, this attribute should be set on all characters.
- // We don't check this (should we?) but we do assume that we
- // can simply examine the first character.
- Object val = iter.getAttribute(TextAttribute.RUN_DIRECTION);
- if (val == TextAttribute.RUN_DIRECTION_LTR)
- this.flags = DIRECTION_LEFT_TO_RIGHT;
- else if (val == TextAttribute.RUN_DIRECTION_RTL)
- this.flags = DIRECTION_RIGHT_TO_LEFT;
- else
- this.flags = DIRECTION_DEFAULT_LEFT_TO_RIGHT;
-
- // Likewise this attribute should be specified on the whole text.
- // We read it here and then, if it is set, we apply the numeric shaper
- // to the text before processing it.
- NumericShaper shaper = null;
- val = iter.getAttribute(TextAttribute.NUMERIC_SHAPING);
- if (val instanceof NumericShaper)
- shaper = (NumericShaper) val;
-
- char[] text = new char[iter.getEndIndex() - iter.getBeginIndex()];
- this.embeddings = new byte[this.text.length];
- this.embeddingOffset = 0;
- this.length = text.length;
- for (int i = 0; i < this.text.length; ++i)
- {
- this.text[i] = iter.current();
-
- val = iter.getAttribute(TextAttribute.BIDI_EMBEDDING);
- if (val instanceof Integer)
- {
- int ival = ((Integer) val).intValue();
- byte bval;
- if (ival < -62 || ival > 62)
- bval = 0;
- else
- bval = (byte) ival;
- this.embeddings[i] = bval;
- }
- }
-
- // Invoke the numeric shaper, if specified.
- if (shaper != null)
- shaper.shape(this.text, 0, this.length);
-
- runBidi();
- }
-
- /**
- * Create a new Bidi object with the indicated text and, possibly, explicit
- * embedding settings.
- *
- * If the embeddings array is null, it is ignored. Otherwise it is taken to
- * be explicit embedding settings corresponding to the text. Positive values
- * from 1 to 61 are embedding levels, and negative values from -1 to -61 are
- * embedding overrides. (FIXME: not at all clear what this really means.)
- *
- * @param text the text to use
- * @param offset the offset of the first character of the text
- * @param embeddings the explicit embeddings, or null if there are none
- * @param embedOffset the offset of the first embedding value to use
- * @param length the length of both the text and the embeddings
- * @param flags a flag indicating the base embedding direction
- */
- public Bidi(char[] text, int offset, byte[] embeddings, int embedOffset,
- int length, int flags)
- {
- if (flags != DIRECTION_DEFAULT_LEFT_TO_RIGHT
- && flags != DIRECTION_DEFAULT_RIGHT_TO_LEFT
- && flags != DIRECTION_LEFT_TO_RIGHT
- && flags != DIRECTION_RIGHT_TO_LEFT)
- throw new IllegalArgumentException("unrecognized 'flags' argument: "
- + flags);
- this.text = text;
- this.textOffset = offset;
- this.embeddings = embeddings;
- this.embeddingOffset = embedOffset;
- this.length = length;
- this.flags = flags;
-
- runBidi();
- }
-
- /**
- * Create a new Bidi object using the contents of the given String
- * as the text.
- * @param text the text to use
- * @param flags a flag indicating the base embedding direction
- */
- public Bidi(String text, int flags)
- {
- if (flags != DIRECTION_DEFAULT_LEFT_TO_RIGHT
- && flags != DIRECTION_DEFAULT_RIGHT_TO_LEFT
- && flags != DIRECTION_LEFT_TO_RIGHT
- && flags != DIRECTION_RIGHT_TO_LEFT)
- throw new IllegalArgumentException("unrecognized 'flags' argument: "
- + flags);
-
- // This is inefficient, but it isn't clear whether it matters.
- // If it does we can change our implementation a bit to allow either
- // a String or a char[].
- this.text = text.toCharArray();
- this.textOffset = 0;
- this.embeddings = null;
- this.embeddingOffset = 0;
- this.length = text.length();
- this.flags = flags;
-
- runBidi();
- }
-
- /**
- * Implementation function which computes the initial type of
- * each character in the input.
- */
- private void computeTypes()
- {
- types = new byte[length];
- for (int i = 0; i < length; ++i)
- types[i] = Character.getDirectionality(text[textOffset + i]);
- }
-
- /**
- * An internal function which implements rules P2 and P3.
- * This computes the base embedding level.
- * @return the paragraph's base embedding level
- */
- private int computeParagraphEmbeddingLevel()
- {
- // First check to see if the user supplied a directionality override.
- if (flags == DIRECTION_LEFT_TO_RIGHT
- || flags == DIRECTION_RIGHT_TO_LEFT)
- return flags;
-
- // This implements rules P2 and P3.
- // (Note that we don't need P1, as the user supplies
- // a paragraph.)
- for (int i = 0; i < length; ++i)
- {
- int dir = types[i];
- if (dir == Character.DIRECTIONALITY_LEFT_TO_RIGHT)
- return DIRECTION_LEFT_TO_RIGHT;
- if (dir == Character.DIRECTIONALITY_RIGHT_TO_LEFT
- || dir == Character.DIRECTIONALITY_RIGHT_TO_LEFT)
- return DIRECTION_RIGHT_TO_LEFT;
- }
- return (flags == DIRECTION_DEFAULT_LEFT_TO_RIGHT
- ? DIRECTION_LEFT_TO_RIGHT
- : DIRECTION_RIGHT_TO_LEFT);
- }
-
- /**
- * An internal function which implements rules X1 through X9.
- * This computes the initial levels for the text, handling
- * explicit overrides and embeddings.
- */
- private void computeExplicitLevels()
- {
- levels = new byte[length];
- byte currentEmbedding = (byte) baseEmbedding;
- // The directional override is a Character directionality
- // constant. -1 means there is no override.
- byte directionalOverride = -1;
- // The stack of pushed embeddings, and the stack pointer.
- // Note that because the direction is inherent in the depth,
- // and because we have a bit left over in a byte, we can encode
- // the override, if any, directly in this value on the stack.
- final int MAX_DEPTH = 62;
- byte[] embeddingStack = new byte[MAX_DEPTH];
- int sp = 0;
-
- for (int i = 0; i < length; ++i)
- {
- // If we see an explicit embedding, we use that, even if
- // the current character is itself a directional override.
- if (embeddings != null && embeddings[embeddingOffset + i] != 0)
- {
- // It isn't at all clear what we're supposed to do here.
- // What does a negative value really mean?
- // Should we push on the embedding stack here?
- currentEmbedding = embeddings[embeddingOffset + i];
- if (currentEmbedding < 0)
- {
- currentEmbedding = (byte) -currentEmbedding;
- directionalOverride
- = (((currentEmbedding % 2) == 0)
- ? Character.DIRECTIONALITY_LEFT_TO_RIGHT
- : Character.DIRECTIONALITY_RIGHT_TO_LEFT);
- }
- else
- directionalOverride = -1;
- continue;
- }
- // No explicit embedding.
- boolean isLtoR = false;
- boolean isSpecial = true;
- switch (types[i])
- {
- case Character.DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING:
- case Character.DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE:
- isLtoR = true;
- // Fall through.
- case Character.DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING:
- case Character.DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE:
- {
- byte newEmbedding;
- if (isLtoR)
- {
- // Least greater even.
- newEmbedding = (byte) ((currentEmbedding & ~1) + 2);
- }
- else
- {
- // Least greater odd.
- newEmbedding = (byte) ((currentEmbedding + 1) | 1);
- }
- // FIXME: we don't properly handle invalid pushes.
- if (newEmbedding < MAX_DEPTH)
- {
- // The new level is valid. Push the old value.
- // See above for a comment on the encoding here.
- if (directionalOverride != -1)
- currentEmbedding |= Byte.MIN_VALUE;
- embeddingStack[sp++] = currentEmbedding;
- currentEmbedding = newEmbedding;
- if (types[i] == Character.DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE)
- directionalOverride = Character.DIRECTIONALITY_LEFT_TO_RIGHT;
- else if (types[i] == Character.DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE)
- directionalOverride = Character.DIRECTIONALITY_RIGHT_TO_LEFT;
- else
- directionalOverride = -1;
- }
- }
- break;
- case Character.DIRECTIONALITY_POP_DIRECTIONAL_FORMAT:
- {
- // FIXME: we don't properly handle a pop with a corresponding
- // invalid push.
- if (sp == 0)
- {
- // We saw a pop without a push. Just ignore it.
- break;
- }
- byte newEmbedding = embeddingStack[--sp];
- currentEmbedding = (byte) (newEmbedding & 0x7f);
- if (newEmbedding < 0)
- directionalOverride
- = (((newEmbedding & 1) == 0)
- ? Character.DIRECTIONALITY_LEFT_TO_RIGHT
- : Character.DIRECTIONALITY_RIGHT_TO_LEFT);
- else
- directionalOverride = -1;
- }
- break;
- default:
- isSpecial = false;
- break;
- }
- levels[i] = currentEmbedding;
- if (isSpecial)
- {
- // Mark this character for removal.
- if (formatterIndices == null)
- formatterIndices = new ArrayList();
- formatterIndices.add(Integer.valueOf(i));
- }
- else if (directionalOverride != -1)
- types[i] = directionalOverride;
- }
-
- // Remove the formatting codes and update both the arrays
- // and 'length'. It would be more efficient not to remove
- // these codes, but it is also more complicated. Also, the
- // Unicode algorithm reference does not properly describe
- // how this is to be done -- from what I can tell, their suggestions
- // in this area will not yield the correct results.
- if (formatterIndices == null)
- return;
- int output = 0, input = 0;
- final int size = formatterIndices.size();
- for (int i = 0; i <= size; ++i)
- {
- int nextFmt;
- if (i == size)
- nextFmt = length;
- else
- nextFmt = ((Integer) formatterIndices.get(i)).intValue();
- // Non-formatter codes are from 'input' to 'nextFmt'.
- int len = nextFmt - input;
- System.arraycopy(levels, input, levels, output, len);
- System.arraycopy(types, input, types, output, len);
- output += len;
- input = nextFmt + 1;
- }
- length -= formatterIndices.size();
- }
-
- /**
- * An internal function to compute the boundaries of runs
- * in the text. It isn't strictly necessary to do this, but
- * it lets us write some following passes in a less complicated
- * way. Also it lets us efficiently implement some of the public
- * methods. A run is simply a sequence of characters at the
- * same level.
- */
- private void computeRuns()
- {
- int runCount = 0;
- int currentEmbedding = baseEmbedding;
- for (int i = 0; i < length; ++i)
- {
- if (levels[i] != currentEmbedding)
- {
- currentEmbedding = levels[i];
- ++runCount;
- }
- }
-
- // This may be called multiple times. If so, and if
- // the number of runs has not changed, then don't bother
- // allocating a new array.
- if (runs == null || runs.length != runCount + 1)
- runs = new int[runCount + 1];
- int where = 0;
- int lastRunStart = 0;
- currentEmbedding = baseEmbedding;
- for (int i = 0; i < length; ++i)
- {
- if (levels[i] != currentEmbedding)
- {
- runs[where++] = lastRunStart;
- lastRunStart = i;
- currentEmbedding = levels[i];
- }
- }
- runs[where++] = lastRunStart;
- }
-
- /**
- * An internal method to resolve weak types. This implements
- * rules W1 through W7.
- */
- private void resolveWeakTypes()
- {
- final int runCount = getRunCount();
-
- int previousLevel = baseEmbedding;
- for (int run = 0; run < runCount; ++run)
- {
- int start = getRunStart(run);
- int end = getRunLimit(run);
- int level = getRunLevel(run);
-
- // These are the names used in the Bidi algorithm.
- byte sor = (((Math.max(previousLevel, level) % 2) == 0)
- ? Character.DIRECTIONALITY_LEFT_TO_RIGHT
- : Character.DIRECTIONALITY_RIGHT_TO_LEFT);
- int nextLevel;
- if (run == runCount - 1)
- nextLevel = baseEmbedding;
- else
- nextLevel = getRunLevel(run + 1);
- byte eor = (((Math.max(level, nextLevel) % 2) == 0)
- ? Character.DIRECTIONALITY_LEFT_TO_RIGHT
- : Character.DIRECTIONALITY_RIGHT_TO_LEFT);
-
- byte prevType = sor;
- byte prevStrongType = sor;
- for (int i = start; i < end; ++i)
- {
- final byte nextType = (i == end - 1) ? eor : types[i + 1];
-
- // Rule W1: change NSM to the prevailing direction.
- if (types[i] == Character.DIRECTIONALITY_NONSPACING_MARK)
- types[i] = prevType;
- else
- prevType = types[i];
-
- // Rule W2: change EN to AN in some cases.
- if (types[i] == Character.DIRECTIONALITY_EUROPEAN_NUMBER)
- {
- if (prevStrongType == Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC)
- types[i] = Character.DIRECTIONALITY_ARABIC_NUMBER;
- }
- else if (types[i] == Character.DIRECTIONALITY_LEFT_TO_RIGHT
- || types[i] == Character.DIRECTIONALITY_RIGHT_TO_LEFT
- || types[i] == Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC)
- prevStrongType = types[i];
-
- // Rule W3: change AL to R.
- if (types[i] == Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC)
- types[i] = Character.DIRECTIONALITY_RIGHT_TO_LEFT;
-
- // Rule W4: handle separators between two numbers.
- if (prevType == Character.DIRECTIONALITY_EUROPEAN_NUMBER
- && nextType == Character.DIRECTIONALITY_EUROPEAN_NUMBER)
- {
- if (types[i] == Character.DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR
- || types[i] == Character.DIRECTIONALITY_COMMON_NUMBER_SEPARATOR)
- types[i] = nextType;
- }
- else if (prevType == Character.DIRECTIONALITY_ARABIC_NUMBER
- && nextType == Character.DIRECTIONALITY_ARABIC_NUMBER
- && types[i] == Character.DIRECTIONALITY_COMMON_NUMBER_SEPARATOR)
- types[i] = nextType;
-
- // Rule W5: change a sequence of european terminators to
- // european numbers, if they are adjacent to european numbers.
- // We also include BN characters in this.
- if (types[i] == Character.DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR
- || types[i] == Character.DIRECTIONALITY_BOUNDARY_NEUTRAL)
- {
- if (prevType == Character.DIRECTIONALITY_EUROPEAN_NUMBER)
- types[i] = prevType;
- else
- {
- // Look ahead to see if there is an EN terminating this
- // sequence of ETs.
- int j = i + 1;
- while (j < end
- && (types[j] == Character.DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR
- || types[j] == Character.DIRECTIONALITY_BOUNDARY_NEUTRAL))
- ++j;
- if (j < end
- && types[j] == Character.DIRECTIONALITY_EUROPEAN_NUMBER)
- {
- // Change them all to EN now.
- for (int k = i; k < j; ++k)
- types[k] = Character.DIRECTIONALITY_EUROPEAN_NUMBER;
- }
- }
- }
-
- // Rule W6: separators and terminators change to ON.
- // Again we include BN.
- if (types[i] == Character.DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR
- || types[i] == Character.DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR
- || types[i] == Character.DIRECTIONALITY_COMMON_NUMBER_SEPARATOR
- || types[i] == Character.DIRECTIONALITY_BOUNDARY_NEUTRAL)
- types[i] = Character.DIRECTIONALITY_OTHER_NEUTRALS;
-
- // Rule W7: change european number types.
- if (prevStrongType == Character.DIRECTIONALITY_LEFT_TO_RIGHT
- && types[i] == Character.DIRECTIONALITY_EUROPEAN_NUMBER)
- types[i] = prevStrongType;
- }
-
- previousLevel = level;
- }
- }
-
- /**
- * An internal method to resolve neutral types. This implements
- * rules N1 and N2.
- */
- private void resolveNeutralTypes()
- {
- // This implements rules N1 and N2.
- final int runCount = getRunCount();
-
- int previousLevel = baseEmbedding;
- for (int run = 0; run < runCount; ++run)
- {
- int start = getRunStart(run);
- int end = getRunLimit(run);
- int level = getRunLevel(run);
-
- byte embeddingDirection
- = (((level % 2) == 0) ? Character.DIRECTIONALITY_LEFT_TO_RIGHT
- : Character.DIRECTIONALITY_RIGHT_TO_LEFT);
- // These are the names used in the Bidi algorithm.
- byte sor = (((Math.max(previousLevel, level) % 2) == 0)
- ? Character.DIRECTIONALITY_LEFT_TO_RIGHT
- : Character.DIRECTIONALITY_RIGHT_TO_LEFT);
- int nextLevel;
- if (run == runCount - 1)
- nextLevel = baseEmbedding;
- else
- nextLevel = getRunLevel(run + 1);
- byte eor = (((Math.max(level, nextLevel) % 2) == 0)
- ? Character.DIRECTIONALITY_LEFT_TO_RIGHT
- : Character.DIRECTIONALITY_RIGHT_TO_LEFT);
-
- byte prevStrong = sor;
- int neutralStart = -1;
- for (int i = start; i <= end; ++i)
- {
- byte newStrong = -1;
- byte thisType = i == end ? eor : types[i];
- switch (thisType)
- {
- case Character.DIRECTIONALITY_LEFT_TO_RIGHT:
- newStrong = Character.DIRECTIONALITY_LEFT_TO_RIGHT;
- break;
- case Character.DIRECTIONALITY_RIGHT_TO_LEFT:
- case Character.DIRECTIONALITY_ARABIC_NUMBER:
- case Character.DIRECTIONALITY_EUROPEAN_NUMBER:
- newStrong = Character.DIRECTIONALITY_RIGHT_TO_LEFT;
- break;
- case Character.DIRECTIONALITY_BOUNDARY_NEUTRAL:
- case Character.DIRECTIONALITY_OTHER_NEUTRALS:
- case Character.DIRECTIONALITY_SEGMENT_SEPARATOR:
- case Character.DIRECTIONALITY_PARAGRAPH_SEPARATOR:
- case Character.DIRECTIONALITY_WHITESPACE:
- if (neutralStart == -1)
- neutralStart = i;
- break;
- }
- // If we see a strong character, update all the neutrals.
- if (newStrong != -1)
- {
- if (neutralStart != -1)
- {
- byte override = (prevStrong == newStrong
- ? prevStrong
- : embeddingDirection);
- for (int j = neutralStart; j < i; ++j)
- types[j] = override;
- }
- prevStrong = newStrong;
- neutralStart = -1;
- }
- }
-
- previousLevel = level;
- }
- }
-
- /**
- * An internal method to resolve implicit levels.
- * This implements rules I1 and I2.
- */
- private void resolveImplicitLevels()
- {
- // This implements rules I1 and I2.
- for (int i = 0; i < length; ++i)
- {
- if ((levels[i] & 1) == 0)
- {
- if (types[i] == Character.DIRECTIONALITY_RIGHT_TO_LEFT)
- ++levels[i];
- else if (types[i] == Character.DIRECTIONALITY_ARABIC_NUMBER
- || types[i] == Character.DIRECTIONALITY_EUROPEAN_NUMBER)
- levels[i] += 2;
- }
- else
- {
- if (types[i] == Character.DIRECTIONALITY_LEFT_TO_RIGHT
- || types[i] == Character.DIRECTIONALITY_ARABIC_NUMBER
- || types[i] == Character.DIRECTIONALITY_EUROPEAN_NUMBER)
- ++levels[i];
- }
-
- // Update the result flags.
- resultFlags |= 1 << (levels[i] & 1);
- }
- // One final update of the result flags, using the base level.
- resultFlags |= 1 << baseEmbedding;
- }
-
- /**
- * This reinserts the formatting codes that we removed early on.
- * Actually it does not insert formatting codes per se, but rather
- * simply inserts new levels at the appropriate locations in the
- * 'levels' array.
- */
- private void reinsertFormattingCodes()
- {
- if (formatterIndices == null)
- return;
- int input = length;
- int output = levels.length;
- // Process from the end as we are copying the array over itself here.
- for (int index = formatterIndices.size() - 1; index >= 0; --index)
- {
- int nextFmt = ((Integer) formatterIndices.get(index)).intValue();
-
- // nextFmt points to a location in the original array. So,
- // nextFmt+1 is the target of our copying. output is the location
- // to which we last copied, thus we can derive the length of the
- // copy from it.
- int len = output - nextFmt - 1;
- output = nextFmt;
- input -= len;
- // Note that we no longer need 'types' at this point, so we
- // only edit 'levels'.
- if (nextFmt + 1 < levels.length)
- System.arraycopy(levels, input, levels, nextFmt + 1, len);
-
- // Now set the level at the reinsertion point.
- int rightLevel;
- if (output == levels.length - 1)
- rightLevel = baseEmbedding;
- else
- rightLevel = levels[output + 1];
- int leftLevel;
- if (input == 0)
- leftLevel = baseEmbedding;
- else
- leftLevel = levels[input];
- levels[output] = (byte) Math.max(leftLevel, rightLevel);
- }
- length = levels.length;
- }
-
- /**
- * This is the main internal entry point. After a constructor
- * has initialized the appropriate local state, it will call
- * this method to do all the work.
- */
- private void runBidi()
- {
- computeTypes();
- baseEmbedding = computeParagraphEmbeddingLevel();
- computeExplicitLevels();
- computeRuns();
- resolveWeakTypes();
- resolveNeutralTypes();
- resolveImplicitLevels();
- // We're done with the types. Let the GC clean up.
- types = null;
- reinsertFormattingCodes();
- // After resolving the implicit levels, the number
- // of runs may have changed.
- computeRuns();
- }
-
- /**
- * Return true if the paragraph base embedding is left-to-right,
- * false otherwise.
- */
- public boolean baseIsLeftToRight()
- {
- return baseEmbedding == DIRECTION_LEFT_TO_RIGHT;
- }
-
- /**
- * Create a new Bidi object for a single line of text, taken
- * from the text used when creating the current Bidi object.
- * @param start the index of the first character of the line
- * @param end the index of the final character of the line
- * @return a new Bidi object for the indicated line of text
- */
- public Bidi createLineBidi(int start, int end)
- {
- // This isn't the most efficient implementation possible.
- // This probably does not matter, so we choose simplicity instead.
- int level = getLevelAt(start);
- int flag = (((level % 2) == 0)
- ? DIRECTION_LEFT_TO_RIGHT
- : DIRECTION_RIGHT_TO_LEFT);
- return new Bidi(text, textOffset + start,
- embeddings, embeddingOffset + start,
- end - start, flag);
- }
-
- /**
- * Return the base embedding level of the paragraph.
- */
- public int getBaseLevel()
- {
- return baseEmbedding;
- }
-
- /**
- * Return the length of the paragraph, in characters.
- */
- public int getLength()
- {
- return length;
- }
-
- /**
- * Return the level at the indicated character. If the
- * supplied index is less than zero or greater than the length
- * of the text, then the paragraph's base embedding level will
- * be returned.
- * @param offset the character to examine
- * @return the level of that character
- */
- public int getLevelAt(int offset)
- {
- if (offset < 0 || offset >= length)
- return getBaseLevel();
- return levels[offset];
- }
-
- /**
- * Return the number of runs in the result. A run is
- * a sequence of characters at the same embedding level.
- */
- public int getRunCount()
- {
- return runs.length;
- }
-
- /**
- * Return the level of the indicated run.
- * @param which the run to examine
- * @return the level of that run
- */
- public int getRunLevel(int which)
- {
- return levels[runs[which]];
- }
-
- /**
- * Return the index of the character just following the end
- * of the indicated run.
- * @param which the run to examine
- * @return the index of the character after the final character
- * of the run
- */
- public int getRunLimit(int which)
- {
- if (which == runs.length - 1)
- return length;
- return runs[which + 1];
- }
-
- /**
- * Return the index of the first character in the indicated run.
- * @param which the run to examine
- * @return the index of the first character of the run
- */
- public int getRunStart(int which)
- {
- return runs[which];
- }
-
- /**
- * Return true if the text is entirely left-to-right, and the
- * base embedding is also left-to-right.
- */
- public boolean isLeftToRight()
- {
- return resultFlags == LTOR;
- }
-
- /**
- * Return true if the text consists of mixed left-to-right and
- * right-to-left runs, or if the text consists of one kind of run
- * which differs from the base embedding direction.
- */
- public boolean isMixed()
- {
- return resultFlags == (LTOR | RTOL);
- }
-
- /**
- * Return true if the text is entirely right-to-left, and the
- * base embedding is also right-to-left.
- */
- public boolean isRightToLeft()
- {
- return resultFlags == RTOL;
- }
-
- /**
- * Return a String describing the internal state of this object.
- * This is only useful for debugging.
- */
- public String toString()
- {
- return "Bidi Bidi Bidi I like you, Buck!";
- }
-
- /**
- * Reorder objects according to the levels passed in. This implements
- * reordering as defined by the Unicode bidirectional layout specification.
- * The levels are integers from 0 to 62; even numbers represent left-to-right
- * runs, and odd numbers represent right-to-left runs.
- *
- * @param levels the levels associated with each object
- * @param levelOffset the index of the first level to use
- * @param objs the objects to reorder according to the levels
- * @param objOffset the index of the first object to use
- * @param count the number of objects (and levels) to manipulate
- */
- public static Object[] reorderVisually(byte[] levels, int levelOffset,
- Object[] objs, int objOffset, int count)
- {
- // We need a copy of the 'levels' array, as we are going to modify it.
- // This is unfortunate but difficult to avoid.
- byte[] levelCopy = new byte[count];
- // Do this explicitly so we can also find the maximum depth at the
- // same time.
- int max = 0;
- int lowestOdd = 63;
- for (int i = 0; i < count; ++i)
- {
- levelCopy[i] = levels[levelOffset + i];
- max = Math.max(levelCopy[i], max);
- if (levelCopy[i] % 2 != 0)
- lowestOdd = Math.min(lowestOdd, levelCopy[i]);
- }
-
- // Reverse the runs starting with the deepest.
- for (int depth = max; depth >= lowestOdd; --depth)
- {
- int start = 0;
- while (start < count)
- {
- // Find the start of a run >= DEPTH.
- while (start < count && levelCopy[start] < depth)
- ++start;
- if (start == count)
- break;
- // Find the end of the run.
- int end = start + 1;
- while (end < count && levelCopy[end] >= depth)
- ++end;
-
- // Reverse this run.
- for (int i = 0; i < (end - start) / 2; ++i)
- {
- byte tmpb = levelCopy[end - i - 1];
- levelCopy[end - i - 1] = levelCopy[start + i];
- levelCopy[start + i] = tmpb;
- Object tmpo = objs[objOffset + end - i - 1];
- objs[objOffset + end - i - 1] = objs[objOffset + start + i];
- objs[objOffset + start + i] = tmpo;
- }
-
- // Handle the next run.
- start = end + 1;
- }
- }
-
- return objs;
- }
-
- /**
- * Returns false if all characters in the text between start and end
- * are all left-to-right text. This implementation is just calls
- * <code>Character.getDirectionality(char)</code> on all characters
- * and makes sure all characters are either explicitly left-to-right
- * or neutral in directionality (character types L, EN, ES, ET, AN,
- * CS, S and WS).
- */
- public static boolean requiresBidi(char[] text, int start, int end)
- {
- for (int i = start; i < end; i++)
- {
- byte dir = Character.getDirectionality(text[i]);
- if (dir != Character.DIRECTIONALITY_LEFT_TO_RIGHT
- && dir != Character.DIRECTIONALITY_EUROPEAN_NUMBER
- && dir != Character.DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR
- && dir != Character.DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR
- && dir != Character.DIRECTIONALITY_ARABIC_NUMBER
- && dir != Character.DIRECTIONALITY_COMMON_NUMBER_SEPARATOR
- && dir != Character.DIRECTIONALITY_SEGMENT_SEPARATOR
- && dir != Character.DIRECTIONALITY_WHITESPACE
- && dir != Character.DIRECTIONALITY_PARAGRAPH_SEPARATOR)
- return true;
- }
-
- return false;
- }
-}

0 comments on commit 35aa2dd

Please sign in to comment.
Something went wrong with that request. Please try again.