* * 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. * *
Block Separator.
* For handling of paragraphs, see:
*
*
* Levels can be abstract values when used for the paraLevel and
* embeddingLevels arguments of setPara(); there:
*
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 pseudo-level values
* LEVEL_DEFAULT_LTR and LEVEL_DEFAULT_RTL.
* The related constants are not real, valid level values.
* DEFAULT_XXX can be used to specify a default for the paragraph
* level for when the setPara() method shall determine it but there
* is no strongly typed character in the input.
*
*
* Note that the value for LEVEL_DEFAULT_LTR is even and the one
* for LEVEL_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 MAX_EXPLICIT_LEVEL is odd.
*
*
* See Also: *
* See Also: *
* See Also: *
* The basic assumptions are: *
*{@code
*
* package com.ibm.icu.dev.test.bidi;
*
* import com.ibm.icu.text.Bidi;
* import com.ibm.icu.text.BidiRun;
*
* public class Sample {
*
* static final int styleNormal = 0;
* static final int styleSelected = 1;
* static final int styleBold = 2;
* static final int styleItalics = 4;
* static final int styleSuper=8;
* static final int styleSub = 16;
*
* static class StyleRun {
* int limit;
* int style;
*
* public StyleRun(int limit, int style) {
* this.limit = limit;
* this.style = style;
* }
* }
*
* static class Bounds {
* int start;
* int limit;
*
* public Bounds(int start, int limit) {
* this.start = start;
* this.limit = limit;
* }
* }
*
* static int getTextWidth(String text, int start, int limit, StyleRun[] styleRuns, int styleRunCount) {
* // simplistic way to compute the width
* return limit - start;
* }
*
* // set limit and StyleRun limit for a line
* // from text[start] and from styleRuns[styleRunStart]
* // using Bidi.getLogicalRun(...)
* // returns line width
* static int getLineBreak(String text, Bounds line, Bidi para, StyleRun styleRuns[], Bounds styleRun) {
* // dummy return
* return 0;
* }
*
* // render runs on a line sequentially, always from left to right
*
* // prepare rendering a new line
* static void startLine(byte textDirection, int lineWidth) {
* System.out.println();
* }
*
* // render a run of text and advance to the right by the run width
* // the text[start..limit-1] is always in logical order
* static void renderRun(String text, int start, int limit, byte textDirection, int 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
* static void renderDirectionalRun(String text, int start, int limit, byte direction, StyleRun styleRuns[],
* int styleRunCount) {
* int i;
*
* // iterate over style runs
* if (direction == Bidi.LTR) {
* int styleLimit;
* for (i = 0; i < styleRunCount; ++i) {
* styleLimit = styleRuns[i].limit;
* if (start < styleLimit) {
* if (styleLimit > limit) {
* styleLimit = limit;
* }
* renderRun(text, start, styleLimit, direction, styleRuns[i].style);
* if (styleLimit == limit) {
* break;
* }
* start = styleLimit;
* }
* }
* } else {
* int styleStart;
*
* for (i = styleRunCount - 1; i >= 0; --i) {
* if (i > 0) {
* styleStart = styleRuns[i - 1].limit;
* } else {
* styleStart = 0;
* }
* if (limit >= styleStart) {
* if (styleStart < start) {
* styleStart = start;
* }
* renderRun(text, styleStart, limit, direction, styleRuns[i].style);
* if (styleStart == start) {
* break;
* }
* limit = styleStart;
* }
* }
* }
* }
*
* // the line object represents text[start..limit-1]
* static void renderLine(Bidi line, String text, int start, int limit, StyleRun styleRuns[], int styleRunCount) {
* byte direction = line.getDirection();
* if (direction != Bidi.MIXED) {
* // unidirectional
* if (styleRunCount <= 1) {
* renderRun(text, start, limit, direction, styleRuns[0].style);
* } else {
* renderDirectionalRun(text, start, limit, direction, styleRuns, styleRunCount);
* }
* } else {
* // mixed-directional
* int count, i;
* BidiRun run;
*
* try {
* count = line.countRuns();
* } catch (IllegalStateException e) {
* e.printStackTrace();
* return;
* }
* if (styleRunCount <= 1) {
* int style = styleRuns[0].style;
*
* // iterate over directional runs
* for (i = 0; i < count; ++i) {
* run = line.getVisualRun(i);
* renderRun(text, run.getStart(), run.getLimit(), run.getDirection(), style);
* }
* } else {
* // iterate over both directional and style runs
* for (i = 0; i < count; ++i) {
* run = line.getVisualRun(i);
* renderDirectionalRun(text, run.getStart(), run.getLimit(), run.getDirection(), styleRuns,
* styleRunCount);
* }
* }
* }
* }
*
* static void renderParagraph(String text, byte textDirection, StyleRun styleRuns[], int styleRunCount,
* int lineWidth) {
* int length = text.length();
* Bidi para = new Bidi();
* try {
* para.setPara(text, textDirection != 0 ? Bidi.LEVEL_DEFAULT_RTL : Bidi.LEVEL_DEFAULT_LTR, null);
* } catch (Exception e) {
* e.printStackTrace();
* return;
* }
* byte paraLevel = (byte) (1 & para.getParaLevel());
* StyleRun styleRun = new StyleRun(length, styleNormal);
*
* if (styleRuns == null || styleRunCount <= 0) {
* styleRuns = new StyleRun[1];
* styleRunCount = 1;
* styleRuns[0] = styleRun;
* }
* // assume styleRuns[styleRunCount-1].limit>=length
*
* int 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 {
* // we need to render several lines
* Bidi line = new Bidi(length, 0);
* int start = 0, limit;
* int styleRunStart = 0, styleRunLimit;
*
* for (;;) {
* limit = length;
* styleRunLimit = styleRunCount;
* width = getLineBreak(text, new Bounds(start, limit), para, styleRuns,
* new Bounds(styleRunStart, styleRunLimit));
* try {
* line = para.setLine(start, limit);
* } catch (Exception e) {
* e.printStackTrace();
* return;
* }
* // prepare rendering a new line
* // from either left or right
* startLine(paraLevel, width);
*
* if (styleRunStart > 0) {
* int newRunCount = styleRuns.length - styleRunStart;
* StyleRun[] newRuns = new StyleRun[newRunCount];
* System.arraycopy(styleRuns, styleRunStart, newRuns, 0, newRunCount);
* renderLine(line, text, start, limit, newRuns, styleRunLimit - styleRunStart);
* } else {
* renderLine(line, text, start, limit, styleRuns, styleRunLimit - styleRunStart);
* }
* if (limit == length) {
* break;
* }
* start = limit;
* styleRunStart = styleRunLimit - 1;
* if (start >= styleRuns[styleRunStart].limit) {
* ++styleRunStart;
* }
* }
* }
* }
*
* public static void main(String[] args) {
* renderParagraph("Some Latin text...", Bidi.LTR, null, 0, 80);
* renderParagraph("Some Hebrew text...", Bidi.RTL, null, 0, 60);
* }
* }
*
* }
*/
/*
* General implementation notes:
*
* Throughout the implementation, there are comments like (W2) that refer to
* rules of the BiDi algorithm, 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 wherever 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 modifies the dirProps after the initial setup,
* when applying X5c (replace FSI by LRI or RLI), X6, N0 (replace paired
* brackets by L or R).
*
* In this implementation, the resolution of weak types (W1 to W6), neutrals (N1
* and N2), 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().
*/
// Original filename in ICU4J: Bidi.java
public class BidiBase {
static class Point {
int pos; /* position in text */
int flag; /* flag for LRM/RLM, before/after */
}
static class InsertPoints {
int size;
int confirmed;
Point[] points = new Point[0];
}
static class Opening {
int position; /* position of opening bracket */
int match; /* matching char or -position of closing bracket */
int contextPos; /* position of last strong char found before opening */
short flags; /* bits for L or R/AL found within the pair */
byte contextDir; /* L or R according to last strong char before opening */
}
static class IsoRun {
int contextPos; /* position of char determining context */
short start; /* index of first opening entry for this run */
short limit; /* index after last opening entry for this run */
byte level; /* level of this run */
byte lastStrong; /* bidi class of last strong char found in this run */
byte lastBase; /* bidi class of last base char found in this run */
byte contextDir; /* L or R to use as context for following openings */
}
static class BracketData {
Opening[] openings = new Opening[SIMPLE_PARAS_COUNT];
int isoRunLast; /* index of last used entry */
/*
* array of nested isolated sequence entries; can never excess
* UBIDI_MAX_EXPLICIT_LEVEL + 1 for index 0, + 1 for before the first isolated
* sequence
*/
IsoRun[] isoRuns = new IsoRun[MAX_EXPLICIT_LEVEL + 2];
boolean isNumbersSpecial; /* reordering mode for NUMBERS_SPECIAL */
}
static class Isolate {
int startON;
int start1;
short stateImp;
short state;
}
/**
* Paragraph level setting
* * * 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 rightmost or
* leftmost strong character of the source text is RTL or Arabic Letter, the
* direction will be LTR otherwise.
*
*
* If reordering option OPTION_INSERT_MARKS is set, an RLM may be
* added at the beginning of the result string to ensure round trip (that the
* result string, when reordered back to visual, will produce the original
* source text).
*
* @see #REORDER_INVERSE_LIKE_DIRECT
* @see #REORDER_INVERSE_FOR_NUMBERS_SPECIAL
* @stable ICU 3.8
*/
public static final byte LEVEL_DEFAULT_LTR = (byte) 0x7e;
/**
* Paragraph level setting
*
* * 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 rightmost 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.
*
*
* If reordering option OPTION_INSERT_MARKS is set, an RLM may be
* added at the beginning of the result string to ensure round trip (that the
* result string, when reordered back to visual, will produce the original
* source text).
*
* @see #REORDER_INVERSE_LIKE_DIRECT
* @see #REORDER_INVERSE_FOR_NUMBERS_SPECIAL
* @stable ICU 3.8
*/
public static final byte LEVEL_DEFAULT_RTL = (byte) 0x7f;
/**
* Maximum explicit embedding level. (The maximum resolved level can be up to
* MAX_EXPLICIT_LEVEL+1).
*
* @stable ICU 3.8
*/
public static final byte MAX_EXPLICIT_LEVEL = 125;
/**
* Bit flag for level input. Overrides directional properties.
*
* @stable ICU 3.8
*/
public static final byte LEVEL_OVERRIDE = (byte) 0x80;
/**
* Special value which can be returned by the mapping methods when a logical
* index has no corresponding visual index or vice-versa. This may happen for
* the logical-to-visual mapping of a Bidi control when option
* OPTION_REMOVE_CONTROLS is specified. This can also happen for
* the visual-to-logical mapping of a Bidi mark (LRM or RLM) inserted by option
* OPTION_INSERT_MARKS.
*
* @see #getVisualIndex
* @see #getVisualMap
* @see #getLogicalIndex
* @see #getLogicalMap
* @see #OPTION_INSERT_MARKS
* @see #OPTION_REMOVE_CONTROLS
* @stable ICU 3.8
*/
public static final int MAP_NOWHERE = -1;
/**
* Left-to-right text.
*
getDirection(), it means that the source
* string contains no right-to-left characters, or that the source string is
* empty and the paragraph level is even.
* getBaseDirection(), it means that the
* first strong character of the source string has a left-to-right direction.
* getDirection(), it means that the source
* string contains no left-to-right characters, or that the source string is
* empty and the paragraph level is odd.
* getBaseDirection(), it means that the
* first strong character of the source string has a right-to-left direction.
*
* As return value for getDirection(), it means that the source
* string contains both left-to-right and right-to-left characters.
*
* @stable ICU 3.8
*/
public static final byte MIXED = 2;
/**
* option bit for writeReordered(): keep combining characters after their base
* characters in RTL runs
*
* @see #writeReordered
* @stable ICU 3.8
*/
public static final short KEEP_BASE_COMBINING = 1;
/**
* option bit for writeReordered(): replace characters with the "mirrored"
* property in RTL runs by their mirror-image mappings
*
* @see #writeReordered
* @stable ICU 3.8
*/
public static final short DO_MIRRORING = 2;
/**
* option bit for writeReordered(): surround the run with LRMs if necessary;
* this is part of the approximate "inverse Bidi" algorithm
*
*
* This option does not imply corresponding adjustment of the index mappings. *
* * @see #setInverse * @see #writeReordered * @stable ICU 3.8 */ public static final short INSERT_LRM_FOR_NUMERIC = 4; /** * option bit for writeReordered(): remove Bidi control characters (this does * not affect INSERT_LRM_FOR_NUMERIC) * ** This option does not imply corresponding adjustment of the index mappings. *
* * @see #writeReordered * @see #INSERT_LRM_FOR_NUMERIC * @stable ICU 3.8 */ public static final short REMOVE_BIDI_CONTROLS = 8; /** * option bit for writeReordered(): write the output in reverse order * *
* This has the same effect as calling writeReordered() first
* without this option, and then calling writeReverse() without
* mirroring. Doing this in the same step is faster and avoids a temporary
* buffer. An example for using this option is output to a character terminal
* that is designed for RTL scripts and stores text in reverse order.
*
OPTION_INSERT_MARKS,
* some Bidi controls in the source text may be removed and other controls may
* be added to produce the minimum combination which has the required display.
*
* @see #OPTION_INSERT_MARKS
* @see #setReorderingMode
* @stable ICU 3.8
*/
static final short REORDER_RUNS_ONLY = 3;
/**
* Reordering mode: Visual to Logical algorithm which handles numbers like L
* (same algorithm as selected by setInverse(true).
*
* @see #setInverse
* @see #setReorderingMode
* @stable ICU 3.8
*/
static final short REORDER_INVERSE_NUMBERS_AS_L = 4;
/**
* Reordering mode: Visual to Logical algorithm equivalent to the regular
* Logical to Visual algorithm.
*
* @see #setReorderingMode
* @stable ICU 3.8
*/
static final short REORDER_INVERSE_LIKE_DIRECT = 5;
/**
* Reordering mode: Inverse Bidi (Visual to Logical) algorithm for the
* REORDER_NUMBERS_SPECIAL Bidi algorithm.
*
* @see #setReorderingMode
* @stable ICU 3.8
*/
static final short REORDER_INVERSE_FOR_NUMBERS_SPECIAL = 6;
/*
* Reordering mode values must be ordered so that all the regular logical to
* visual modes come first, and all inverse Bidi modes come last.
*/
private static final short REORDER_LAST_LOGICAL_TO_VISUAL = REORDER_NUMBERS_SPECIAL;
/**
* Option bit for setReorderingOptions: insert Bidi marks (LRM or
* RLM) when needed to ensure correct result of a reordering to a Logical order
*
*
* This option must be set or reset before calling setPara.
*
* This option is significant only with reordering modes which generate a result * with Logical order, specifically. *
*REORDER_RUNS_ONLYREORDER_INVERSE_NUMBERS_AS_LREORDER_INVERSE_LIKE_DIRECTREORDER_INVERSE_FOR_NUMBERS_SPECIAL
* If this option is set in conjunction with reordering mode
* REORDER_INVERSE_NUMBERS_AS_L or with calling
* setInverse(true), it implies option
* INSERT_LRM_FOR_NUMERIC in calls to method
* writeReordered().
*
* 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 will be ignored if specified together with option
* OPTION_REMOVE_CONTROLS. It inhibits option
* REMOVE_BIDI_CONTROLS in calls to method
* writeReordered() and it implies option
* INSERT_LRM_FOR_NUMERIC in calls to method
* writeReordered() if the reordering mode is
* REORDER_INVERSE_NUMBERS_AS_L.
*
setReorderingOptions: remove Bidi control
* characters
*
*
* This option must be set or reset before calling setPara.
*
* This option nullifies option OPTION_INSERT_MARKS. It inhibits
* option INSERT_LRM_FOR_NUMERIC in calls to method
* writeReordered() and it implies option
* REMOVE_BIDI_CONTROLS in calls to that method.
*
setReorderingOptions: process the output as part
* of a stream to be continued
*
*
* This option must be set or reset before calling setPara.
*
* 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. *
* *
* When this option bit is on, setPara() may process less than the
* full source text in order to truncate the text at a meaningful boundary. The
* caller should call getProcessedLength() immediately after
* calling setPara() in order to determine how much of the source
* text has been processed. Source text beyond that length should be resubmitted
* in following calls to setPara. The processed length may be less
* than the length of the source text if a character preceding the last
* character of the source text constitutes a reasonable boundary (like a block
* separator) for text to be continued.
* If the last character of the source text constitutes a reasonable boundary,
* the whole text will be processed at once.
* If nowhere in the source text there exists such a reasonable boundary, the
* processed length will be zero.
* The caller should check for such an occurrence and do one of the following:
*
OPTION_STREAMING.
* When the OPTION_STREAMING option is used, it is recommended to
* call orderParagraphsLTR(true) before calling
* setPara() so that later paragraphs may be concatenated to
* previous paragraphs on the right.
*
setPara, which may be shorter than the original
* length. Otherwise, it is identical to the original length.
*/
public int length;
/*
* if option OPTION_REMOVE_CONTROLS is set, and/or Bidi marks are allowed to be
* inserted in one of the reordering modes, the length of the result string may
* be different from the processed length.
*/
int resultLength;
/* indicators for whether memory may be allocated after construction */
boolean mayAllocateText;
boolean mayAllocateRuns;
/* arrays with one value per text-character */
byte[] dirPropsMemory = new byte[1];
byte[] levelsMemory = new byte[1];
byte[] dirProps;
byte[] levels;
/* are we performing an approximation of the "inverse Bidi" algorithm? */
boolean isInverse;
/* are we using the basic algorithm or its variation? */
int reorderingMode;
/* bitmask for reordering options */
int reorderingOptions;
/* must block separators receive level 0? */
boolean orderParagraphsLTR;
/* the paragraph level */
byte paraLevel;
/* original paraLevel when contextual */
/* must be one of DEFAULT_xxx or 0 if not contextual */
byte defaultParaLevel;
/* the following is set in setPara, used in processPropertySeq */
ImpTabPair impTabPair; /* reference to levels state table pair */
/* the overall paragraph or line directionality */
byte direction;
/* flags is a bit set for which directional properties are in the text */
int flags;
/* lastArabicPos is index to the last AL in the text, -1 if none */
int lastArabicPos;
/* characters after trailingWSStart are WS and are */
/* implicitly at the paraLevel (rule (L1)) - levels may not reflect that */
int trailingWSStart;
/* fields for paragraph handling, set in getDirProps() */
int paraCount;
int[] paras_limit = new int[SIMPLE_PARAS_COUNT];
byte[] paras_level = new byte[SIMPLE_PARAS_COUNT];
/* fields for line reordering */
int runCount; /* ==-1: runs not set up yet */
BidiRun[] runsMemory = new BidiRun[0];
BidiRun[] runs;
/* for non-mixed text, we only need a tiny array of runs (no allocation) */
BidiRun[] simpleRuns = { new BidiRun() };
/* fields for managing isolate sequences */
Isolate[] isolates;
/* maximum or current nesting depth of isolate sequences */
/*
* Within resolveExplicitLevels() and checkExplicitLevels(), this is the maximal
* nesting encountered. Within resolveImplicitLevels(), this is the index of the
* current isolates stack entry.
*/
int isolateCount;
/* mapping of runs in logical order to visual order */
int[] logicalToVisualRunsMap;
/* flag to indicate that the map has been updated */
boolean isGoodLogicalToVisualRunsMap;
/* for inverse Bidi with insertion of directional marks */
InsertPoints insertPoints = new InsertPoints();
/* for option OPTION_REMOVE_CONTROLS */
int controlCount;
/*
* Sometimes, bit values are more appropriate to deal with directionality
* properties. Abbreviations in these method names refer to names used in the
* Bidi algorithm.
*/
static int DirPropFlag(byte dir) {
return (1 << dir);
}
boolean testDirPropFlagAt(int flag, int index) {
return ((DirPropFlag(dirProps[index]) & flag) != 0);
}
static final int DirPropFlagMultiRuns = DirPropFlag((byte) 31);
/* to avoid some conditional statements, use tiny constant arrays */
static final int DirPropFlagLR[] = { DirPropFlag(L), DirPropFlag(R) };
static final int DirPropFlagE[] = { DirPropFlag(LRE), DirPropFlag(RLE) };
static final int DirPropFlagO[] = { DirPropFlag(LRO), DirPropFlag(RLO) };
static final int DirPropFlagLR(byte level) {
return DirPropFlagLR[level & 1];
}
static final int DirPropFlagE(byte level) {
return DirPropFlagE[level & 1];
}
static final int DirPropFlagO(byte level) {
return DirPropFlagO[level & 1];
}
static final byte DirFromStrong(byte strong) {
return strong == L ? L : R;
}
static final byte NoOverride(byte level) {
return (byte) (level & ~LEVEL_OVERRIDE);
}
/* are there any characters that are LTR or RTL? */
static final int MASK_LTR = DirPropFlag(L) | DirPropFlag(EN) | DirPropFlag(ENL) | DirPropFlag(ENR) | DirPropFlag(AN)
| DirPropFlag(LRE) | DirPropFlag(LRO) | DirPropFlag(LRI);
static final int MASK_RTL = DirPropFlag(R) | DirPropFlag(AL) | DirPropFlag(RLE) | DirPropFlag(RLO)
| DirPropFlag(RLI);
static final int MASK_R_AL = DirPropFlag(R) | DirPropFlag(AL);
/* explicit embedding codes */
private static final int MASK_EXPLICIT = DirPropFlag(LRE) | DirPropFlag(LRO) | DirPropFlag(RLE) | DirPropFlag(RLO)
| DirPropFlag(PDF);
private static final int MASK_BN_EXPLICIT = DirPropFlag(BN) | MASK_EXPLICIT;
/* explicit isolate codes */
private static final int MASK_ISO = DirPropFlag(LRI) | DirPropFlag(RLI) | DirPropFlag(FSI) | DirPropFlag(PDI);
/* paragraph and segment separators */
private static final int MASK_B_S = DirPropFlag(B) | DirPropFlag(S);
/* all types that are counted as White Space or Neutral in some steps */
static final int MASK_WS = MASK_B_S | DirPropFlag(WS) | MASK_BN_EXPLICIT | MASK_ISO;
/* types that are neutrals or could becomes neutrals in (Wn) */
private static final int MASK_POSSIBLE_N = DirPropFlag(ON) | DirPropFlag(CS) | DirPropFlag(ES) | DirPropFlag(ET)
| MASK_WS;
/*
* These types may be changed to "e", the embedding type (L or R) of the run, in
* the Bidi algorithm (N2)
*/
private static final int MASK_EMBEDDING = DirPropFlag(NSM) | MASK_POSSIBLE_N;
/*
* the dirProp's L and R are defined to 0 and 1 values in
* UCharacterDirection.java
*/
private static byte GetLRFromLevel(byte level) {
return (byte) (level & 1);
}
private static boolean IsDefaultLevel(byte level) {
return ((level & LEVEL_DEFAULT_LTR) == LEVEL_DEFAULT_LTR);
}
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)) || ((c >= 0x2066) && (c <= 0x2069)));
}
void verifyValidPara() {
if (!(this == this.paraBidi)) {
throw new IllegalStateException();
}
}
void verifyValidParaOrLine() {
BidiBase para = this.paraBidi;
/* verify Para */
if (this == para) {
return;
}
/* verify Line */
if ((para == null) || (para != para.paraBidi)) {
throw new IllegalStateException();
}
}
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);
}
}
/**
* 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 */
bdp = UBiDiProps.INSTANCE;
/* 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 getInitialRunsMemory(int len) {
getRunsMemory(true, len);
}
/**
* Is this Bidi object set to perform the inverse Bidi algorithm?
*
* Note: calling this method after setting the reordering mode with
* setReorderingMode will return true if the
* reordering mode was set to REORDER_INVERSE_NUMBERS_AS_L,
* false for all other values.
*
true if the Bidi object is set to perform
* the inverse Bidi algorithm by handling numbers as L.
*
* @see #setInverse
* @see #setReorderingMode
* @see #REORDER_INVERSE_NUMBERS_AS_L
* @stable ICU 3.8
*/
public boolean isInverse() {
return isInverse;
}
/* perform (P2)..(P3) ------------------------------------------------------- */
/*
* Check that there are enough entries in the arrays paras_limit and paras_level
*/
private void checkParaCount() {
int[] saveLimits;
byte[] saveLevels;
int count = paraCount;
if (count <= paras_level.length)
return;
int oldLength = paras_level.length;
saveLimits = paras_limit;
saveLevels = paras_level;
try {
paras_limit = new int[count * 2];
paras_level = new byte[count * 2];
} catch (Exception e) {
throw new OutOfMemoryError("Failed to allocate memory for paras");
}
System.arraycopy(saveLimits, 0, paras_limit, 0, oldLength);
System.arraycopy(saveLevels, 0, paras_level, 0, oldLength);
}
/*
* Get the directional properties for the text, calculate the flags bit-set, and
* determine the paragraph level if necessary (in paras_level[i]). FSI
* initiators are also resolved and their dirProp replaced with LRI or RLI. When
* encountering an FSI, it is initially replaced with an LRI, which is the
* default. Only if a strong R or AL is found within its scope will the LRI be
* replaced by an RLI.
*/
static final int NOT_SEEKING_STRONG = 0; /* 0: not contextual paraLevel, not after FSI */
static final int SEEKING_STRONG_FOR_PARA = 1; /* 1: looking for first strong char in para */
static final int SEEKING_STRONG_FOR_FSI = 2; /* 2: looking for first strong after FSI */
static final int LOOKING_FOR_PDI = 3; /* 3: found strong after FSI, looking for PDI */
private void getDirProps() {
int i = 0, i0, i1;
flags = 0; /* collect all directionalities in the text */
int uchar;
byte dirProp;
byte defaultParaLevel = 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
*/
boolean isDefaultLevelInverse = isDefaultLevel && (reorderingMode == REORDER_INVERSE_LIKE_DIRECT
|| reorderingMode == REORDER_INVERSE_FOR_NUMBERS_SPECIAL);
lastArabicPos = -1;
int controlCount = 0;
boolean removeBidiControls = (reorderingOptions & OPTION_REMOVE_CONTROLS) != 0;
byte state;
byte lastStrong = ON; /* for default level & inverse Bidi */
/*
* The following stacks are used to manage isolate sequences. Those sequences
* may be nested, but obviously never more deeply than the maximum explicit
* embedding level. lastStack is the index of the last used entry in the stack.
* A value of -1 means that there is no open isolate sequence. lastStack is
* reset to -1 on paragraph boundaries.
*/
/*
* The following stack contains the position of the initiator of each open
* isolate sequence
*/
int[] isolateStartStack = new int[MAX_EXPLICIT_LEVEL + 1];
/*
* The following stack contains the last known state before encountering the
* initiator of an isolate sequence
*/
byte[] previousStateStack = new byte[MAX_EXPLICIT_LEVEL + 1];
int stackLast = -1;
if ((reorderingOptions & OPTION_STREAMING) != 0)
length = 0;
defaultParaLevel = (byte) (paraLevel & 1);
if (isDefaultLevel) {
paras_level[0] = defaultParaLevel;
lastStrong = defaultParaLevel;
state = SEEKING_STRONG_FOR_PARA;
} else {
paras_level[0] = paraLevel;
state = NOT_SEEKING_STRONG;
}
/* 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 += UTF16.getCharCount(uchar);
i1 = i - 1; /* index of last code unit, gets the directional property */
dirProp = (byte) getCustomizedClass(uchar);
flags |= DirPropFlag(dirProp);
dirProps[i1] = dirProp;
if (i1 > i0) { /* set previous code units' properties to BN */
flags |= DirPropFlag(BN);
do {
dirProps[--i1] = BN;
} while (i1 > i0);
}
if (removeBidiControls && IsBidiControlChar(uchar)) {
controlCount++;
}
if (dirProp == L) {
if (state == SEEKING_STRONG_FOR_PARA) {
paras_level[paraCount - 1] = 0;
state = NOT_SEEKING_STRONG;
} else if (state == SEEKING_STRONG_FOR_FSI) {
if (stackLast <= MAX_EXPLICIT_LEVEL) {
/* no need for next statement, already set by default */
/* dirProps[isolateStartStack[stackLast]] = LRI; */
flags |= DirPropFlag(LRI);
}
state = LOOKING_FOR_PDI;
}
lastStrong = L;
continue;
}
if (dirProp == R || dirProp == AL) {
if (state == SEEKING_STRONG_FOR_PARA) {
paras_level[paraCount - 1] = 1;
state = NOT_SEEKING_STRONG;
} else if (state == SEEKING_STRONG_FOR_FSI) {
if (stackLast <= MAX_EXPLICIT_LEVEL) {
dirProps[isolateStartStack[stackLast]] = RLI;
flags |= DirPropFlag(RLI);
}
state = LOOKING_FOR_PDI;
}
lastStrong = R;
if (dirProp == AL)
lastArabicPos = i - 1;
continue;
}
if (dirProp >= FSI && dirProp <= RLI) { /* FSI, LRI or RLI */
stackLast++;
if (stackLast <= MAX_EXPLICIT_LEVEL) {
isolateStartStack[stackLast] = i - 1;
previousStateStack[stackLast] = state;
}
if (dirProp == FSI) {
dirProps[i - 1] = LRI; /* default if no strong char */
state = SEEKING_STRONG_FOR_FSI;
} else
state = LOOKING_FOR_PDI;
continue;
}
if (dirProp == PDI) {
if (state == SEEKING_STRONG_FOR_FSI) {
if (stackLast <= MAX_EXPLICIT_LEVEL) {
/* no need for next statement, already set by default */
/* dirProps[isolateStartStack[stackLast]] = LRI; */
flags |= DirPropFlag(LRI);
}
}
if (stackLast >= 0) {
if (stackLast <= MAX_EXPLICIT_LEVEL)
state = previousStateStack[stackLast];
stackLast--;
}
continue;
}
if (dirProp == B) {
if (i < originalLength && uchar == CR && text[i] == LF) /* do nothing on the CR */
continue;
paras_limit[paraCount - 1] = i;
if (isDefaultLevelInverse && lastStrong == R)
paras_level[paraCount - 1] = 1;
if ((reorderingOptions & OPTION_STREAMING) != 0) {
/*
* When streaming, we only process whole paragraphs thus some updates are only
* done on paragraph boundaries
*/
length = i; /* i is index to next character */
this.controlCount = controlCount;
}
if (i < originalLength) { /* B not last char in text */
paraCount++;
checkParaCount(); /* check that there is enough memory for a new para entry */
if (isDefaultLevel) {
paras_level[paraCount - 1] = defaultParaLevel;
state = SEEKING_STRONG_FOR_PARA;
lastStrong = defaultParaLevel;
} else {
paras_level[paraCount - 1] = paraLevel;
state = NOT_SEEKING_STRONG;
}
stackLast = -1;
}
continue;
}
}
/* +Ignore still open isolate sequences with overflow */
if (stackLast > MAX_EXPLICIT_LEVEL) {
stackLast = MAX_EXPLICIT_LEVEL;
state = SEEKING_STRONG_FOR_FSI; /* to be on the safe side */
}
/* Resolve direction of still unresolved open FSI sequences */
while (stackLast >= 0) {
if (state == SEEKING_STRONG_FOR_FSI) {
/* no need for next statement, already set by default */
/* dirProps[isolateStartStack[stackLast]] = LRI; */
flags |= DirPropFlag(LRI);
break;
}
state = previousStateStack[stackLast];
stackLast--;
}
/* When streaming, ignore text after the last paragraph separator */
if ((reorderingOptions & OPTION_STREAMING) != 0) {
if (length < originalLength)
paraCount--;
} else {
paras_limit[paraCount - 1] = originalLength;
this.controlCount = controlCount;
}
/*
* For inverse bidi, default para direction is RTL if there is a strong R or AL
* at either end of the paragraph
*/
if (isDefaultLevelInverse && lastStrong == R) {
paras_level[paraCount - 1] = 1;
}
if (isDefaultLevel) {
paraLevel = paras_level[0];
}
/*
* The following is needed to resolve the text direction for default level
* paragraphs containing no strong character
*/
for (i = 0; i < paraCount; i++)
flags |= DirPropFlagLR(paras_level[i]);
if (orderParagraphsLTR && (flags & DirPropFlag(B)) != 0) {
flags |= DirPropFlag(L);
}
}
/* determine the paragraph level at position index */
byte GetParaLevelAt(int pindex) {
if (defaultParaLevel == 0 || pindex < paras_limit[0])
return paraLevel;
int i;
for (i = 1; i < paraCount; i++)
if (pindex < paras_limit[i])
break;
if (i >= paraCount)
i = paraCount - 1;
return paras_level[i];
}
/* Functions for handling paired brackets ----------------------------------- */
/*
* In the isoRuns array, the first entry is used for text outside of any isolate
* sequence. Higher entries are used for each more deeply nested isolate
* sequence. isoRunLast is the index of the last used entry. The openings array
* is used to note the data of opening brackets not yet matched by a closing
* bracket, or matched but still susceptible to change level. Each isoRun entry
* contains the index of the first and one-after-last openings entries for
* pending opening brackets it contains. The next openings entry to use is the
* one-after-last of the most deeply nested isoRun entry. isoRun entries also
* contain their current embedding level and the last encountered strong
* character, since these will be needed to resolve the level of paired
* brackets.
*/
private void bracketInit(BracketData bd) {
bd.isoRunLast = 0;
bd.isoRuns[0] = new IsoRun();
bd.isoRuns[0].start = 0;
bd.isoRuns[0].limit = 0;
bd.isoRuns[0].level = GetParaLevelAt(0);
bd.isoRuns[0].lastStrong = bd.isoRuns[0].lastBase = bd.isoRuns[0].contextDir = (byte) (GetParaLevelAt(0) & 1);
bd.isoRuns[0].contextPos = 0;
bd.openings = new Opening[SIMPLE_PARAS_COUNT];
bd.isNumbersSpecial = reorderingMode == REORDER_NUMBERS_SPECIAL
|| reorderingMode == REORDER_INVERSE_FOR_NUMBERS_SPECIAL;
}
/* paragraph boundary */
private void bracketProcessB(BracketData bd, byte level) {
bd.isoRunLast = 0;
bd.isoRuns[0].limit = 0;
bd.isoRuns[0].level = level;
bd.isoRuns[0].lastStrong = bd.isoRuns[0].lastBase = bd.isoRuns[0].contextDir = (byte) (level & 1);
bd.isoRuns[0].contextPos = 0;
}
/* LRE, LRO, RLE, RLO, PDF */
private void bracketProcessBoundary(BracketData bd, int lastCcPos, byte contextLevel, byte embeddingLevel) {
IsoRun pLastIsoRun = bd.isoRuns[bd.isoRunLast];
if ((DirPropFlag(dirProps[lastCcPos]) & MASK_ISO) != 0) /* after an isolate */
return;
if (NoOverride(embeddingLevel) > NoOverride(contextLevel)) /* not a PDF */
contextLevel = embeddingLevel;
pLastIsoRun.limit = pLastIsoRun.start;
pLastIsoRun.level = embeddingLevel;
pLastIsoRun.lastStrong = pLastIsoRun.lastBase = pLastIsoRun.contextDir = (byte) (contextLevel & 1);
pLastIsoRun.contextPos = lastCcPos;
}
/* LRI or RLI */
private void bracketProcessLRI_RLI(BracketData bd, byte level) {
IsoRun pLastIsoRun = bd.isoRuns[bd.isoRunLast];
short lastLimit;
pLastIsoRun.lastBase = ON;
lastLimit = pLastIsoRun.limit;
bd.isoRunLast++;
pLastIsoRun = bd.isoRuns[bd.isoRunLast];
if (pLastIsoRun == null)
pLastIsoRun = bd.isoRuns[bd.isoRunLast] = new IsoRun();
pLastIsoRun.start = pLastIsoRun.limit = lastLimit;
pLastIsoRun.level = level;
pLastIsoRun.lastStrong = pLastIsoRun.lastBase = pLastIsoRun.contextDir = (byte) (level & 1);
pLastIsoRun.contextPos = 0;
}
/* PDI */
private void bracketProcessPDI(BracketData bd) {
IsoRun pLastIsoRun;
bd.isoRunLast--;
pLastIsoRun = bd.isoRuns[bd.isoRunLast];
pLastIsoRun.lastBase = ON;
}
/* newly found opening bracket: create an openings entry */
private void bracketAddOpening(BracketData bd, char match, int position) {
IsoRun pLastIsoRun = bd.isoRuns[bd.isoRunLast];
Opening pOpening;
if (pLastIsoRun.limit >= bd.openings.length) { /* no available new entry */
Opening[] saveOpenings = bd.openings;
int count;
try {
count = bd.openings.length;
bd.openings = new Opening[count * 2];
} catch (Exception e) {
throw new OutOfMemoryError("Failed to allocate memory for openings");
}
System.arraycopy(saveOpenings, 0, bd.openings, 0, count);
}
pOpening = bd.openings[pLastIsoRun.limit];
if (pOpening == null)
pOpening = bd.openings[pLastIsoRun.limit] = new Opening();
pOpening.position = position;
pOpening.match = match;
pOpening.contextDir = pLastIsoRun.contextDir;
pOpening.contextPos = pLastIsoRun.contextPos;
pOpening.flags = 0;
pLastIsoRun.limit++;
}
/*
* change N0c1 to N0c2 when a preceding bracket is assigned the embedding level
*/
private void fixN0c(BracketData bd, int openingIndex, int newPropPosition, byte newProp) {
/* This function calls itself recursively */
IsoRun pLastIsoRun = bd.isoRuns[bd.isoRunLast];
Opening qOpening;
int k, openingPosition, closingPosition;
for (k = openingIndex + 1; k < pLastIsoRun.limit; k++) {
qOpening = bd.openings[k];
if (qOpening.match >= 0) /* not an N0c match */
continue;
if (newPropPosition < qOpening.contextPos)
break;
if (newPropPosition >= qOpening.position)
continue;
if (newProp == qOpening.contextDir)
break;
openingPosition = qOpening.position;
dirProps[openingPosition] = newProp;
closingPosition = -(qOpening.match);
dirProps[closingPosition] = newProp;
qOpening.match = 0; /* prevent further changes */
fixN0c(bd, k, openingPosition, newProp);
fixN0c(bd, k, closingPosition, newProp);
}
}
/* process closing bracket; return L or R if N0b or N0c, ON if N0d */
private byte bracketProcessClosing(BracketData bd, int openIdx, int position) {
IsoRun pLastIsoRun = bd.isoRuns[bd.isoRunLast];
Opening pOpening, qOpening;
byte direction;
boolean stable;
byte newProp;
pOpening = bd.openings[openIdx];
direction = (byte) (pLastIsoRun.level & 1);
stable = true; /* assume stable until proved otherwise */
/*
* The stable flag is set when brackets are paired and their level is resolved
* and cannot be changed by what will be found later in the source string. An
* unstable match can occur only when applying N0c, where the resolved level
* depends on the preceding context, and this context may be affected by text
* occurring later. Example: RTL paragraph containing: abc[(latin) HEBREW] When
* the closing parenthesis is encountered, it appears that N0c1 must be applied
* since 'abc' sets an opposite direction context and both parentheses receive
* level 2. However, when the closing square bracket is processed, N0b applies
* because of 'HEBREW' being included within the brackets, thus the square
* brackets are treated like R and receive level 1. However, this changes the
* preceding context of the opening parenthesis, and it now appears that N0c2
* must be applied to the parentheses rather than N0c1.
*/
if ((direction == 0 && (pOpening.flags & FOUND_L) > 0)
|| (direction == 1 && (pOpening.flags & FOUND_R) > 0)) { /* N0b */
newProp = direction;
} else if ((pOpening.flags & (FOUND_L | FOUND_R)) != 0) { /* N0c */
/*
* it is stable if there is no preceding text or in conditions too complicated
* and not worth checking
*/
stable = (openIdx == pLastIsoRun.start);
if (direction != pOpening.contextDir)
newProp = pOpening.contextDir; /* N0c1 */
else
newProp = direction; /* N0c2 */
} else {
/* forget this and any brackets nested within this pair */
pLastIsoRun.limit = (short) openIdx;
return ON; /* N0d */
}
dirProps[pOpening.position] = newProp;
dirProps[position] = newProp;
/* Update nested N0c pairs that may be affected */
fixN0c(bd, openIdx, pOpening.position, newProp);
if (stable) {
pLastIsoRun.limit = (short) openIdx; /* forget any brackets nested within this pair */
/* remove lower located synonyms if any */
while (pLastIsoRun.limit > pLastIsoRun.start
&& bd.openings[pLastIsoRun.limit - 1].position == pOpening.position)
pLastIsoRun.limit--;
} else {
int k;
pOpening.match = -position;
/* neutralize lower located synonyms if any */
k = openIdx - 1;
while (k >= pLastIsoRun.start && bd.openings[k].position == pOpening.position)
bd.openings[k--].match = 0;
/*
* neutralize any unmatched opening between the current pair; this will also
* neutralize higher located synonyms if any
*/
for (k = openIdx + 1; k < pLastIsoRun.limit; k++) {
qOpening = bd.openings[k];
if (qOpening.position >= position)
break;
if (qOpening.match > 0)
qOpening.match = 0;
}
}
return newProp;
}
/* handle strong characters, digits and candidates for closing brackets */
private void bracketProcessChar(BracketData bd, int position) {
IsoRun pLastIsoRun = bd.isoRuns[bd.isoRunLast];
byte dirProp, newProp;
byte level;
dirProp = dirProps[position];
if (dirProp == ON) {
char c, match;
int idx;
/*
* First see if it is a matching closing bracket. Hopefully, this is more
* efficient than checking if it is a closing bracket at all
*/
c = text[position];
for (idx = pLastIsoRun.limit - 1; idx >= pLastIsoRun.start; idx--) {
if (bd.openings[idx].match != c)
continue;
/* We have a match */
newProp = bracketProcessClosing(bd, idx, position);
if (newProp == ON) { /* N0d */
c = 0; /* prevent handling as an opening */
break;
}
pLastIsoRun.lastBase = ON;
pLastIsoRun.contextDir = newProp;
pLastIsoRun.contextPos = position;
level = levels[position];
if ((level & LEVEL_OVERRIDE) != 0) { /* X4, X5 */
short flag;
int i;
newProp = (byte) (level & 1);
pLastIsoRun.lastStrong = newProp;
flag = (short) DirPropFlag(newProp);
for (i = pLastIsoRun.start; i < idx; i++)
bd.openings[i].flags |= flag;
/* matching brackets are not overridden by LRO/RLO */
levels[position] &= ~LEVEL_OVERRIDE;
}
/* matching brackets are not overridden by LRO/RLO */
levels[bd.openings[idx].position] &= ~LEVEL_OVERRIDE;
return;
}
/*
* We get here only if the ON character is not a matching closing bracket or it
* is a case of N0d
*/
/* Now see if it is an opening bracket */
if (c != 0) {
match = (char) UCharacter.getBidiPairedBracket(c); /* get the matching char */
} else {
match = 0;
}
if (match != c && /* has a matching char */
UCharacter.getIntPropertyValue(c, BIDI_PAIRED_BRACKET_TYPE) ==
/* opening bracket */ BidiPairedBracketType.OPEN) {
/*
* special case: process synonyms create an opening entry for each synonym
*/
if (match == 0x232A) { /* RIGHT-POINTING ANGLE BRACKET */
bracketAddOpening(bd, (char) 0x3009, position);
} else if (match == 0x3009) { /* RIGHT ANGLE BRACKET */
bracketAddOpening(bd, (char) 0x232A, position);
}
bracketAddOpening(bd, match, position);
}
}
level = levels[position];
if ((level & LEVEL_OVERRIDE) != 0) { /* X4, X5 */
newProp = (byte) (level & 1);
if (dirProp != S && dirProp != WS && dirProp != ON)
dirProps[position] = newProp;
pLastIsoRun.lastBase = newProp;
pLastIsoRun.lastStrong = newProp;
pLastIsoRun.contextDir = newProp;
pLastIsoRun.contextPos = position;
} else if (dirProp <= R || dirProp == AL) {
newProp = DirFromStrong(dirProp);
pLastIsoRun.lastBase = dirProp;
pLastIsoRun.lastStrong = dirProp;
pLastIsoRun.contextDir = newProp;
pLastIsoRun.contextPos = position;
} else if (dirProp == EN) {
pLastIsoRun.lastBase = EN;
if (pLastIsoRun.lastStrong == L) {
newProp = L; /* W7 */
if (!bd.isNumbersSpecial)
dirProps[position] = ENL;
pLastIsoRun.contextDir = L;
pLastIsoRun.contextPos = position;
} else {
newProp = R; /* N0 */
if (pLastIsoRun.lastStrong == AL)
dirProps[position] = AN; /* W2 */
else
dirProps[position] = ENR;
pLastIsoRun.contextDir = R;
pLastIsoRun.contextPos = position;
}
} else if (dirProp == AN) {
newProp = R; /* N0 */
pLastIsoRun.lastBase = AN;
pLastIsoRun.contextDir = R;
pLastIsoRun.contextPos = position;
} else if (dirProp == NSM) {
/*
* if the last real char was ON, change NSM to ON so that it will stay ON even
* if the last real char is a bracket which may be changed to L or R
*/
newProp = pLastIsoRun.lastBase;
if (newProp == ON)
dirProps[position] = newProp;
} else {
newProp = dirProp;
pLastIsoRun.lastBase = dirProp;
}
if (newProp <= R || newProp == AL) {
int i;
short flag = (short) DirPropFlag(DirFromStrong(newProp));
for (i = pLastIsoRun.start; i < pLastIsoRun.limit; i++)
if (position > bd.openings[i].position)
bd.openings[i].flags |= flag;
}
}
/* 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 LTR;
} else if ((flags & MASK_LTR) == 0) {
return RTL;
} 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, FSI,
* PDI) in the plain text. That is why (X9) instructs to remove all not-isolate
* explicit codes (and BN). However, in a real implementation, the 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 a
* not-isolate 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, except for paired
* brackets whose properties (ON) may be replaced by L or R. 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,
* RLO, LRI, RLI and FSI and popped with each PDF and PDI, the explicit level
* must never exceed MAX_EXPLICIT_LEVEL.
*
* In order to have a correct push-pop semantics even in the case of overflows,
* overflow counters and a valid isolate counter are used as described in UAX#9
* section 3.3.2 "Explicit Levels and Directions".
*
* This implementation assumes that MAX_EXPLICIT_LEVEL is odd.
*
* Returns the direction
*
*/
private byte resolveExplicitLevels() {
int i = 0;
byte dirProp;
byte level = GetParaLevelAt(0);
byte dirct;
isolateCount = 0;
/* determine if the text is mixed-directional or single-directional */
dirct = directionFromFlags();
/* we may not need to resolve any explicit levels */
if (dirct != MIXED) {
/* not mixed directionality: levels don't matter - trailingWSStart will be 0 */
return dirct;
}
if (reorderingMode > REORDER_LAST_LOGICAL_TO_VISUAL) {
/* inverse BiDi: mixed, but all characters are at the same embedding level */
/* set all levels to the paragraph level */
int paraIndex, start, limit;
for (paraIndex = 0; paraIndex < paraCount; paraIndex++) {
if (paraIndex == 0)
start = 0;
else
start = paras_limit[paraIndex - 1];
limit = paras_limit[paraIndex];
level = paras_level[paraIndex];
for (i = start; i < limit; i++)
levels[i] = level;
}
return dirct; /* no bracket matching for inverse BiDi */
}
if ((flags & (MASK_EXPLICIT | MASK_ISO)) == 0) {
/* no embeddings, set all levels to the paragraph level */
/* we still have to perform bracket matching */
int paraIndex, start, limit;
BracketData bracketData = new BracketData();
bracketInit(bracketData);
for (paraIndex = 0; paraIndex < paraCount; paraIndex++) {
if (paraIndex == 0)
start = 0;
else
start = paras_limit[paraIndex - 1];
limit = paras_limit[paraIndex];
level = paras_level[paraIndex];
for (i = start; i < limit; i++) {
levels[i] = level;
dirProp = dirProps[i];
if (dirProp == BN)
continue;
if (dirProp == B) {
if ((i + 1) < length) {
if (text[i] == CR && text[i + 1] == LF)
continue; /* skip CR when followed by LF */
bracketProcessB(bracketData, level);
}
continue;
}
bracketProcessChar(bracketData, i);
}
}
return dirct;
}
/* 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, newLevel;
byte previousLevel = level; /* previous level for regular (not CC) characters */
int lastCcPos = 0; /* index of last effective LRx,RLx, PDx */
/*
* The following stack remembers the embedding level and the ISOLATE flag of
* level runs. stackLast points to its current entry.
*/
short[] stack = new short[MAX_EXPLICIT_LEVEL + 2]; /*
* we never push anything >= MAX_EXPLICIT_LEVEL but we need
* one more entry as base
*/
int stackLast = 0;
int overflowIsolateCount = 0;
int overflowEmbeddingCount = 0;
int validIsolateCount = 0;
BracketData bracketData = new BracketData();
bracketInit(bracketData);
stack[0] = level; /* initialize base entry to para level, no override, no isolate */
/* recalculate the flags */
flags = 0;
for (i = 0; i < length; i++) {
dirProp = dirProps[i];
switch (dirProp) {
case LRE:
case RLE:
case LRO:
case RLO:
/* (X2, X3, X4, X5) */
flags |= DirPropFlag(BN);
levels[i] = previousLevel;
if (dirProp == LRE || dirProp == LRO) {
/* least greater even level */
newLevel = (byte) ((embeddingLevel + 2) & ~(LEVEL_OVERRIDE | 1));
} else {
/* least greater odd level */
newLevel = (byte) ((NoOverride(embeddingLevel) + 1) | 1);
}
if (newLevel <= MAX_EXPLICIT_LEVEL && overflowIsolateCount == 0 && overflowEmbeddingCount == 0) {
lastCcPos = i;
embeddingLevel = newLevel;
if (dirProp == LRO || dirProp == RLO)
embeddingLevel |= LEVEL_OVERRIDE;
stackLast++;
stack[stackLast] = embeddingLevel;
/*
* we don't need to set LEVEL_OVERRIDE off for LRE and RLE since this has
* already been done for newLevel which is the source for embeddingLevel.
*/
} else {
if (overflowIsolateCount == 0)
overflowEmbeddingCount++;
}
break;
case PDF:
/* (X7) */
flags |= DirPropFlag(BN);
levels[i] = previousLevel;
/* handle all the overflow cases first */
if (overflowIsolateCount > 0) {
break;
}
if (overflowEmbeddingCount > 0) {
overflowEmbeddingCount--;
break;
}
if (stackLast > 0 && stack[stackLast] < ISOLATE) { /* not an isolate entry */
lastCcPos = i;
stackLast--;
embeddingLevel = (byte) stack[stackLast];
}
break;
case LRI:
case RLI:
flags |= DirPropFlag(ON) | DirPropFlagLR(embeddingLevel);
levels[i] = NoOverride(embeddingLevel);
if (NoOverride(embeddingLevel) != NoOverride(previousLevel)) {
bracketProcessBoundary(bracketData, lastCcPos, previousLevel, embeddingLevel);
flags |= DirPropFlagMultiRuns;
}
previousLevel = embeddingLevel;
/* (X5a, X5b) */
if (dirProp == LRI)
/* least greater even level */
newLevel = (byte) ((embeddingLevel + 2) & ~(LEVEL_OVERRIDE | 1));
else
/* least greater odd level */
newLevel = (byte) ((NoOverride(embeddingLevel) + 1) | 1);
if (newLevel <= MAX_EXPLICIT_LEVEL && overflowIsolateCount == 0 && overflowEmbeddingCount == 0) {
flags |= DirPropFlag(dirProp);
lastCcPos = i;
validIsolateCount++;
if (validIsolateCount > isolateCount)
isolateCount = validIsolateCount;
embeddingLevel = newLevel;
/*
* we can increment stackLast without checking because newLevel will exceed
* UBIDI_MAX_EXPLICIT_LEVEL before stackLast overflows
*/
stackLast++;
stack[stackLast] = (short) (embeddingLevel + ISOLATE);
bracketProcessLRI_RLI(bracketData, embeddingLevel);
} else {
/* make it WS so that it is handled by adjustWSLevels() */
dirProps[i] = WS;
overflowIsolateCount++;
}
break;
case PDI:
if (NoOverride(embeddingLevel) != NoOverride(previousLevel)) {
bracketProcessBoundary(bracketData, lastCcPos, previousLevel, embeddingLevel);
flags |= DirPropFlagMultiRuns;
}
/* (X6a) */
if (overflowIsolateCount > 0) {
overflowIsolateCount--;
/* make it WS so that it is handled by adjustWSLevels() */
dirProps[i] = WS;
} else if (validIsolateCount > 0) {
flags |= DirPropFlag(PDI);
lastCcPos = i;
overflowEmbeddingCount = 0;
while (stack[stackLast] < ISOLATE) /* pop embedding entries */
stackLast--; /* until the last isolate entry */
stackLast--; /* pop also the last isolate entry */
validIsolateCount--;
bracketProcessPDI(bracketData);
} else
/* make it WS so that it is handled by adjustWSLevels() */
dirProps[i] = WS;
embeddingLevel = (byte) (stack[stackLast] & ~ISOLATE);
flags |= DirPropFlag(ON) | DirPropFlagLR(embeddingLevel);
previousLevel = embeddingLevel;
levels[i] = NoOverride(embeddingLevel);
break;
case B:
flags |= DirPropFlag(B);
levels[i] = GetParaLevelAt(i);
if ((i + 1) < length) {
if (text[i] == CR && text[i + 1] == LF)
break; /* skip CR when followed by LF */
overflowEmbeddingCount = overflowIsolateCount = 0;
validIsolateCount = 0;
stackLast = 0;
previousLevel = embeddingLevel = GetParaLevelAt(i + 1);
stack[0] = embeddingLevel; /* initialize base entry to para level, no override, no isolate */
bracketProcessB(bracketData, embeddingLevel);
}
break;
case BN:
/* BN, LRE, RLE, and PDF are supposed to be removed (X9) */
/* they will get their levels set correctly in adjustWSLevels() */
levels[i] = previousLevel;
flags |= DirPropFlag(BN);
break;
default:
/* all other types are normal characters and get the "real" level */
if (NoOverride(embeddingLevel) != NoOverride(previousLevel)) {
bracketProcessBoundary(bracketData, lastCcPos, previousLevel, embeddingLevel);
flags |= DirPropFlagMultiRuns;
if ((embeddingLevel & LEVEL_OVERRIDE) != 0)
flags |= DirPropFlagO(embeddingLevel);
else
flags |= DirPropFlagE(embeddingLevel);
}
previousLevel = embeddingLevel;
levels[i] = embeddingLevel;
bracketProcessChar(bracketData, i);
/* the dirProp may have been changed in bracketProcessChar() */
flags |= DirPropFlag(dirProps[i]);
break;
}
}
if ((flags & MASK_EMBEDDING) != 0) {
flags |= DirPropFlagLR(paraLevel);
}
if (orderParagraphsLTR && (flags & DirPropFlag(B)) != 0) {
flags |= DirPropFlag(L);
}
/* 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;
int isolateCount = 0;
this.flags = 0; /* collect all directionalities in the text */
byte level;
this.isolateCount = 0;
for (i = 0; i < length; ++i) {
if (levels[i] == 0) {
levels[i] = paraLevel;
}
// for backward compatibility
if (MAX_EXPLICIT_LEVEL < (levels[i] & 0x7f)) {
if ((levels[i] & LEVEL_OVERRIDE) != 0) {
levels[i] = (byte) (paraLevel | LEVEL_OVERRIDE);
} else {
levels[i] = paraLevel;
}
}
level = levels[i];
dirProp = dirProps[i];
if (dirProp == LRI || dirProp == RLI) {
isolateCount++;
if (isolateCount > this.isolateCount)
this.isolateCount = isolateCount;
} else if (dirProp == PDI) {
isolateCount--;
} else if (dirProp == B) {
isolateCount = 0;
}
if ((level & LEVEL_OVERRIDE) != 0) {
/* keep the override flag in levels[i] but adjust the flags */
level &= ~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 < level)) {
/* level out of bounds */
throw new IllegalArgumentException("level " + level + " out of bounds at " + i);
}
}
if ((flags & MASK_EMBEDDING) != 0) {
flags |= DirPropFlagLR(paraLevel);
}
/* determine if the text is mixed-directional or single-directional */
return directionFromFlags();
}
/*********************************************************************/
/* The Properties state machine table */
/*********************************************************************/
/* */
/* All table cells are 8 bits: */
/* bits 0..4: next state */
/* bits 5..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. */
/* */
/*********************************************************************/
/* Definitions and type for properties state tables */
/*********************************************************************/
private static final int IMPTABPROPS_COLUMNS = 16;
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 FSI LRI RLI PDI
* ENL ENR
*/
0, 1, 2, 7, 8, 3, 9, 6, 5, 4, 4, 10, 10, 12, 10, 10, 10, 11, 10, 4, 4, 4, 4, 13, 14 };
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, FSI, RLI, LRI and PDI */
/* - 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, ENL, ENR, Res */
/* 0 Init */ { 1, 2, 4, 5, 7, 15, 17, 7, 9, 7, 0, 7, 3, 18, 21, _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,
32 + 18, 32 + 21, _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,
32 + 18, 32 + 21, _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,
32 + 18, 32 + 21, _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, 18,
21, _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,
32 + 18, 32 + 21, _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,
18, 21, _AN },
/* 7 ON */ { 32 + 1, 32 + 2, 32 + 4, 32 + 5, 7, 32 + 15, 32 + 17, 7, 64 + 14, 7, 7, 7, 32 + 3, 32 + 18,
32 + 21, _ON },
/* 8 AL:ON */ { 32 + 1, 32 + 2, 32 + 6, 32 + 6, 8, 32 + 16, 32 + 17, 8, 8, 8, 8, 8, 32 + 3, 32 + 18,
32 + 21, _ON },
/* 9 ET */ { 32 + 1, 32 + 2, 4, 32 + 5, 7, 32 + 15, 32 + 17, 7, 9, 7, 9, 9, 32 + 3, 18, 21, _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, 18, 21, _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,
18, 21, _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, 96 + 18, 96 + 21, _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, 18, 21, _AN },
/* 14 ON+ET */ { 32 + 1, 32 + 2, 128 + 4, 32 + 5, 7, 32 + 15, 32 + 17, 7, 14, 7, 14, 14, 32 + 3, 128 + 18,
128 + 21, _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, 32 + 18, 32 + 21, _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, 32 + 18, 32 + 21, _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, 32 + 18, 32 + 21, _B },
/* 18 ENL */ { 32 + 1, 32 + 2, 18, 32 + 5, 32 + 7, 32 + 15, 32 + 17, 64 + 19, 20, 64 + 19, 18, 18, 32 + 3,
18, 21, _L },
/* 19 ENL+ES/CS */ { 96 + 1, 96 + 2, 18, 96 + 5, 128 + 7, 96 + 15, 96 + 17, 128 + 7, 128 + 14, 128 + 7, 19,
128 + 7, 96 + 3, 18, 21, _L },
/* 20 ENL+ET */ { 32 + 1, 32 + 2, 18, 32 + 5, 32 + 7, 32 + 15, 32 + 17, 32 + 7, 20, 32 + 7, 20, 20, 32 + 3,
18, 21, _L },
/* 21 ENR */ { 32 + 1, 32 + 2, 21, 32 + 5, 32 + 7, 32 + 15, 32 + 17, 64 + 22, 23, 64 + 22, 21, 21, 32 + 3,
18, 21, _AN },
/* 22 ENR+ES/CS */ { 96 + 1, 96 + 2, 21, 96 + 5, 128 + 7, 96 + 15, 96 + 17, 128 + 7, 128 + 14, 128 + 7, 22,
128 + 7, 96 + 3, 18, 21, _AN },
/* 23 ENR+ET */ { 32 + 1, 32 + 2, 21, 32 + 5, 32 + 7, 32 + 15, 32 + 17, 32 + 7, 23, 32 + 7, 23, 23, 32 + 3,
18, 21, _AN } };
/*********************************************************************/
/* 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 lower 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 */ { 0, 0x21, 0x33, 0x33, 4, 4, 0, 0 },
/* 5 : AN+ON */ { 0, 0x21, 0, 0x32, 5, 5, 0, 0 } };
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 };
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 lower possible level until
* proven otherwise.
*/
/* L, R, EN, AN, ON, S, B, Res */
/* 0 : init */ { 0, 2, 0x11, 0x11, 0, 0, 0, 0 }, /* 1 : L+EN/AN */ { 0, 0x42, 1, 1, 0, 0, 0, 0 },
/* 2 : R */ { 0, 2, 4, 4, 0x13, 0x13, 0, 1 }, /* 3 : R+ON */ { 0, 0x22, 0x34, 0x34, 3, 3, 0, 0 },
/* 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, 13, 14 };
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, 2, 5, 6, 7, 8 };
private static final short[] impAct3 = { 0, 1, 9, 10, 11, 12 };
private static final ImpTabPair impTab_INVERSE_LIKE_DIRECT_WITH_MARKS = new ImpTabPair(
impTabL_INVERSE_LIKE_DIRECT_WITH_MARKS, impTabR_INVERSE_LIKE_DIRECT_WITH_MARKS, impAct2, impAct3);
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, impAct2, impAct3);
private static 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 */
int runStart; /* start position of the run */
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++;
}
private void setLevelsOutsideIsolates(int start, int limit, byte level) {
byte dirProp;
int isolateCount = 0, k;
for (k = start; k < limit; k++) {
dirProp = dirProps[k];
if (dirProp == PDI)
isolateCount--;
if (isolateCount == 0) {
levels[k] = level;
}
if (dirProp == LRI || dirProp == RLI)
isolateCount++;
}
}
/* 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* * 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:
* Unicode Bidirectional Algorithm, 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
*/
void setPara(char[] chars, byte paraLevel, byte[] embeddingLevels) {
/* check the argument values */
if (paraLevel < LEVEL_DEFAULT_LTR) {
verifyRange(paraLevel, 0, MAX_EXPLICIT_LEVEL + 1);
}
if (chars == null) {
chars = new char[0];
}
/* special treatment for RUNS_ONLY mode */
if (reorderingMode == REORDER_RUNS_ONLY) {
setParaRunsOnly(chars, paraLevel);
return;
}
/* 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 = (byte) (paraLevel & 1);
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.
*/
defaultParaLevel = IsDefaultLevel(paraLevel) ? paraLevel : 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;
}
flags = DirPropFlagLR(paraLevel);
runCount = 0;
paraCount = 0;
setParaSuccess();
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 */
/* 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();
}
/* allocate isolate memory */
if (isolateCount > 0) {
if (isolates == null || isolates.length < isolateCount)
isolates = new Isolate[isolateCount + 3]; /* keep some reserve */
}
isolateCount = -1; /* current isolates stack entry == none */
/*
* The steps after (X9) in the Bidi algorithm are performed only if the
* paragraph text has mixed directionality!
*/
switch (direction) {
case LTR:
/* all levels are implicitly at paraLevel (important for getLevels()) */
trailingWSStart = 0;
break;
case RTL:
/* all levels are implicitly at paraLevel (important for getLevels()) */
trailingWSStart = 0;
break;
default:
/*
* Choose the right implicit state table
*/
switch (reorderingMode) {
case REORDER_DEFAULT:
this.impTabPair = impTab_DEFAULT;
break;
case REORDER_NUMBERS_SPECIAL:
this.impTabPair = impTab_NUMBERS_SPECIAL;
break;
case REORDER_GROUP_NUMBERS_WITH_R:
this.impTabPair = impTab_GROUP_NUMBERS_WITH_R;
break;
case REORDER_RUNS_ONLY:
/* we should never get here */
throw new InternalError("Internal ICU error in setPara");
/* break; */
case REORDER_INVERSE_NUMBERS_AS_L:
this.impTabPair = impTab_INVERSE_NUMBERS_AS_L;
break;
case REORDER_INVERSE_LIKE_DIRECT:
if ((reorderingOptions & OPTION_INSERT_MARKS) != 0) {
this.impTabPair = impTab_INVERSE_LIKE_DIRECT_WITH_MARKS;
} else {
this.impTabPair = impTab_INVERSE_LIKE_DIRECT;
}
break;
case REORDER_INVERSE_FOR_NUMBERS_SPECIAL:
if ((reorderingOptions & OPTION_INSERT_MARKS) != 0) {
this.impTabPair = impTab_INVERSE_FOR_NUMBERS_SPECIAL_WITH_MARKS;
} else {
this.impTabPair = impTab_INVERSE_FOR_NUMBERS_SPECIAL;
}
break;
}
/*
* 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) && (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) || ((DirPropFlag(dirProps[limit]) & MASK_BN_EXPLICIT) != 0))) {
}
/* 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 (NoOverride(level) < NoOverride(nextLevel)) {
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 & LEVEL_OVERRIDE) == 0) {
resolveImplicitLevels(start, limit, sor, eor);
} else {
/* remove the LEVEL_OVERRIDE flags */
do {
levels[start++] &= ~LEVEL_OVERRIDE;
} while (start < limit);
}
} while (limit < length);
}
/* reset the embedding levels for some non-graphic characters (L1), (X9) */
adjustWSLevels();
break;
}
/*
* add RLM for inverse Bidi with contextual orientation resolving to RTL which
* would not round-trip otherwise
*/
if ((defaultParaLevel > 0) && ((reorderingOptions & OPTION_INSERT_MARKS) != 0)
&& ((reorderingMode == REORDER_INVERSE_LIKE_DIRECT)
|| (reorderingMode == REORDER_INVERSE_FOR_NUMBERS_SPECIAL))) {
int start, last;
byte level;
byte dirProp;
for (int i = 0; i < paraCount; i++) {
last = paras_limit[i] - 1;
level = paras_level[i];
if (level == 0)
continue; /* LTR paragraph */
start = i == 0 ? 0 : paras_limit[i - 1];
for (int j = last; j >= start; j--) {
dirProp = dirProps[j];
if (dirProp == L) {
if (j < last) {
while (dirProps[last] == B) {
last--;
}
}
addPoint(last, RLM_BEFORE);
break;
}
if ((DirPropFlag(dirProp) & MASK_R_AL) != 0) {
break;
}
}
}
}
if ((reorderingOptions & OPTION_REMOVE_CONTROLS) != 0) {
resultLength -= controlCount;
} else {
resultLength += insertPoints.size;
}
setParaSuccess();
}
/**
* Perform the Unicode Bidi algorithm on a given paragraph, as defined in the
* Unicode Standard Annex #9:
* Unicode Bidirectional Algorithm, 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;
char ch = paragraph.first();
Boolean runDirection = (Boolean) paragraph.getAttribute(TextAttribute.RUN_DIRECTION);
Object shaper = paragraph.getAttribute(TextAttribute.NUMERIC_SHAPING);
if (runDirection == null) {
paraLvl = LEVEL_DEFAULT_LTR;
} else {
paraLvl = (runDirection.equals(TextAttribute.RUN_DIRECTION_LTR)) ? LTR : RTL;
}
byte[] lvls = null;
int len = paragraph.getEndIndex() - paragraph.getBeginIndex();
byte[] embeddingLevels = new byte[len];
char[] txt = new char[len];
int i = 0;
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) | LEVEL_OVERRIDE);
} else {
lvls = embeddingLevels;
embeddingLevels[i] = level;
}
}
ch = paragraph.next();
++i;
}
if (shaper != null) {
((NumericShaper) 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
*/
public 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
*/
public 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;
}
/**
* Retrieves the Bidi class for a given code point.
*
* If a BidiClassifier is defined and returns a value other than
* CLASS_DEFAULT, that value is used; otherwise the default class
* determination mechanism is invoked.
*
c that is in effect for
* this Bidi instance.
*
* @stable ICU 3.8
*/
public int getCustomizedClass(int c) {
int dir;
dir = bdp.getClass(c);
if (dir >= CHAR_DIRECTION_COUNT)
dir = ON;
return dir;
}
/**
* 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);
return BidiLine.setLine(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) {
// for backward compatibility
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
*/
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 BidiRun object according to its index. BidiRun methods may
* be used to retrieve the run's logical start, length and level, which can be
* even for an LTR run or odd for an RTL run. 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.
*
* countRuns() is normally called before the runs are retrieved.
*
*
* Example: * *
* Bidi bidi = new Bidi();
* String text = "abc 123 DEFG xyz";
* bidi.setPara(text, Bidi.RTL, null);
* int i, count = bidi.countRuns(), logicalStart, visualIndex = 0, length;
* BidiRun run;
* for (i = 0; i < count; ++i) {
* run = bidi.getVisualRun(i);
* logicalStart = run.getStart();
* length = run.getLength();
* if (Bidi.LTR == run.getEmbeddingLevel()) {
* do { // LTR
* show_char(text.charAt(logicalStart++), visualIndex++);
* } while (--length > 0);
* } else {
* logicalStart += length; // logicalLimit
* do { // RTL
* show_char(text.charAt(--logicalStart), visualIndex++);
* } while (--length > 0);
* }
* }
*
* * Note that in right-to-left runs, code like this places second surrogates * before first ones (which is generally a bad idea) and combining characters * before base characters. *
* Use of {@link #writeReordered}, optionally with the
* {@link #KEEP_BASE_COMBINING} option, can be considered in order
* to avoid these issues.
*
* @param runIndex is the number of the run in visual order, in the range
* [0..countRuns()-1].
*
* @return a BidiRun object containing the details of the run. The
* directionality of the run is LTR==0 or
* RTL==1, never MIXED.
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to setPara or
* setLine
* @throws IllegalArgumentException if runIndex is not in the range
* 0<=runIndex<countRuns()
*
* @see #countRuns()
* @see com.ibm.icu.text.BidiRun
* @see com.ibm.icu.text.BidiRun#getStart()
* @see com.ibm.icu.text.BidiRun#getLength()
* @see com.ibm.icu.text.BidiRun#getEmbeddingLevel()
* @stable ICU 3.8
*/
BidiRun getVisualRun(int runIndex) {
verifyValidParaOrLine();
BidiLine.getRuns(this);
verifyRange(runIndex, 0, runCount);
return BidiLine.getVisualRun(this, runIndex);
}
/**
* 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 right-to-left.
*
* @stable ICU 3.8
*/
public static final int DIRECTION_DEFAULT_RIGHT_TO_LEFT = LEVEL_DEFAULT_RTL;
/**
* 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 = LTR;
break;
case Bidi.DIRECTION_RIGHT_TO_LEFT:
paraLvl = RTL;
break;
case Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT:
paraLvl = LEVEL_DEFAULT_LTR;
break;
case Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT:
paraLvl = 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) | LEVEL_OVERRIDE);
} else if (lev == 0) {
lev = paraLvl;
if (paraLvl > MAX_EXPLICIT_LEVEL) {
lev &= 1;
}
}
paraEmbeddings[i] = lev;
}
}
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() == LTR && (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() == RTL && (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() == LTR);
}
/**
* 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
*/
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);
}
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);
// for backward compatibility
if (run < 0 || run >= runCount) {
return getParaLevel();
}
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);
// for backward compatibility
if (runCount == 1) {
return 0;
} else if (run == runCount) {
return length;
}
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);
// for backward compatibility
if (runCount == 1) {
return length;
}
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 << R | 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 + ", or limit "
+ limit + " is beyond the text length " + text.length);
}
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) {
// for backward compatibility
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 " + objectStart + " is out of range 0 to " + (objects.length - 1));
}
if (0 > count || objects.length < (objectStart + count)) {
throw new IllegalArgumentException("Value count " + count + " is less than zero, or objectStart + count"
+ " is beyond objects length " + objects.length);
}
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]];
}
}
/**
* Take a Bidi object containing the reordering information for a
* piece of text (one or more paragraphs) set by setPara() or for a
* line of text set by setLine() and return a string containing the
* reordered text.
*
*
* The text may have been aliased (only a reference was stored without copying
* the contents), thus it must not have been modified since the
* setPara() call.
*
options parameter, and of the option bit flags.
*
* @param options A bit set of options for the reordering that control how the
* reordered text is written. The options include mirroring the
* characters on a code point basis and inserting LRM characters,
* which is used especially for transforming visually stored text
* to logically stored text (although this is still an imperfect
* implementation of an "inverse Bidi" algorithm because it uses
* the "forward Bidi" algorithm at its core). The available
* options are: DO_MIRRORING,
* INSERT_LRM_FOR_NUMERIC,
* KEEP_BASE_COMBINING, OUTPUT_REVERSE,
* REMOVE_BIDI_CONTROLS, STREAMING
*
* @return The reordered text. If the INSERT_LRM_FOR_NUMERIC option
* is set, then the length of the returned string could be as large as
* getLength()+2*countRuns().REMOVE_BIDI_CONTROLS option is set, then the
* length of the returned string may be less than
* getLength().getProcessedLength().
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to setPara or
* setLine
*
* @see #DO_MIRRORING
* @see #INSERT_LRM_FOR_NUMERIC
* @see #KEEP_BASE_COMBINING
* @see #OUTPUT_REVERSE
* @see #REMOVE_BIDI_CONTROLS
* @see #OPTION_STREAMING
* @see #getProcessedLength
* @stable ICU 3.8
*/
public String writeReordered(int options) {
verifyValidParaOrLine();
if (length == 0) {
/* nothing to do */
return "";
}
return BidiWriter.writeReordered(this, options);
}
/**
* Display the bidi internal state, used in debugging.
*/
public String toString() {
StringBuilder buf = new StringBuilder(getClass().getName());
buf.append("[dir: ");
buf.append(direction);
buf.append(" baselevel: ");
buf.append(paraLevel);
buf.append(" length: ");
buf.append(length);
buf.append(" runs: ");
if (levels == null) {
buf.append("none");
} else {
buf.append('[');
buf.append(levels[0]);
for (int i = 1; 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 = 1; i < text.length; i++) {
buf.append(" 0x");
buf.append(Integer.toHexString(text[i]));
}
buf.append("]]");
return buf.toString();
}
}