/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* $Id$ */
package org.apache.fop.complexscripts.bidi;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.fop.traits.Direction;
import org.apache.fop.util.CharUtilities;
// CSOFF: LineLengthCheck
/**
* <p>The <code>UnicodeBidiAlgorithm</code> class implements functionality prescribed by
* the Unicode Bidirectional Algorithm, Unicode Standard Annex #9.</p>
*
* <p>This work was originally authored by Glenn Adams (gadams@apache.org).</p>
*/
public final class UnicodeBidiAlgorithm implements BidiConstants {
/**
* logging instance
*/
private static final Log log = LogFactory.getLog(UnicodeBidiAlgorithm.class);
private UnicodeBidiAlgorithm() {
}
/**
* Resolve the directionality levels of each character in a character seqeunce.
* If some character is encoded in the character sequence as a Unicode Surrogate Pair,
* then the directionality level of each of the two members of the pair will be identical.
* @return null if bidirectional processing is not required; otherwise, returns an array
* of integers, where each integer corresponds to exactly one UTF-16
* encoding element present in the input character sequence, and where each integer denotes
* the directionality level of the corresponding encoding element
* @param cs input character sequence representing a UTF-16 encoded string
* @param defaultLevel the default paragraph level, which must be zero (LR) or one (RL)
*/
public static int[] resolveLevels(CharSequence cs, Direction defaultLevel) {
int[] chars = new int [ cs.length() ];
if (convertToScalar(cs, chars) || (defaultLevel == Direction.RL)) {
return resolveLevels(chars, (defaultLevel == Direction.RL) ? 1 : 0, new int [ chars.length ]);
} else {
return null;
}
}
/**
* Resolve the directionality levels of each character in a character seqeunce.
* @return null if bidirectional processing is not required; otherwise, returns an array
* of integers, where each integer corresponds to exactly one UTF-16
* encoding element present in the input character sequence, and where each integer denotes
* the directionality level of the corresponding encoding element
* @param chars array of input characters represented as unicode scalar values
* @param defaultLevel the default paragraph level, which must be zero (LR) or one (RL)
* @param levels array to receive levels, one for each character in chars array
*/
public static int[] resolveLevels(int[] chars, int defaultLevel, int[] levels) {
return resolveLevels(chars, getClasses(chars), defaultLevel, levels, false);
}
/**
* Resolve the directionality levels of each character in a character seqeunce.
* @return null if bidirectional processing is not required; otherwise, returns an array
* of integers, where each integer corresponds to exactly one UTF-16
* encoding element present in the input character sequence, and where each integer denotes
* the directionality level of the corresponding encoding element
* @param chars array of input characters represented as unicode scalar values
* @param classes array containing one bidi class per character in chars array
* @param defaultLevel the default paragraph level, which must be zero (LR) or one (RL)
* @param levels array to receive levels, one for each character in chars array
* @param useRuleL1 true if rule L1 should be used
*/
public static int[] resolveLevels(int[] chars, int[] classes, int defaultLevel, int[] levels, boolean useRuleL1) {
int[] ica = classes;
int[] wca = copySequence(ica);
int[] ea = new int [ levels.length ];
resolveExplicit(wca, defaultLevel, ea);
resolveRuns(wca, defaultLevel, ea, levelsFromEmbeddings(ea, levels));
if (useRuleL1) {
resolveSeparators(ica, wca, defaultLevel, levels);
}
dump("RL: CC(" + ((chars != null) ? chars.length : -1) + ")", chars, classes, defaultLevel, levels);
return levels;
}
private static int[] copySequence(int[] ta) {
int[] na = new int [ ta.length ];
System.arraycopy(ta, 0, na, 0, na.length);
return na;
}
private static void resolveExplicit(int[] wca, int defaultLevel, int[] ea) {
int[] es = new int [ MAX_LEVELS ]; /* embeddings stack */
int ei = 0; /* embeddings stack index */
int ec = defaultLevel; /* current embedding level */
for (int i = 0, n = wca.length; i < n; i++) {
int bc = wca [ i ]; /* bidi class of current char */
int el; /* embedding level to assign to current char */
switch (bc) {
case LRE: // start left-to-right embedding
case RLE: // start right-to-left embedding
case LRO: // start left-to-right override
case RLO: // start right-to-left override
int en; /* new embedding level */
if ((bc == RLE) || (bc == RLO)) {
en = ((ec & ~OVERRIDE) + 1) | 1;
} else {
en = ((ec & ~OVERRIDE) + 2) & ~1;
}
if (en < (MAX_LEVELS + 1)) {
es [ ei++ ] = ec;
if ((bc == LRO) || (bc == RLO)) {
ec = en | OVERRIDE;
} else {
ec = en & ~OVERRIDE;
}
} else {
// max levels exceeded, so don't change level or override
}
el = ec;
break;
case PDF: // pop directional formatting
el = ec;
if (ei > 0) {
ec = es [ --ei ];
} else {
// ignore isolated PDF
}
break;
case B: // paragraph separator
el = ec = defaultLevel;
ei = 0;
break;
default:
el = ec;
break;
}
switch (bc) {
case BN:
break;
case LRE: case RLE: case LRO: case RLO: case PDF:
wca [ i ] = BN;
break;
default:
if ((el & OVERRIDE) != 0) {
wca [ i ] = directionOfLevel(el);
}
break;
}
ea [ i ] = el;
}
}
private static int directionOfLevel(int level) {
return ((level & 1) != 0) ? R : L;
}
private static int levelOfEmbedding(int embedding) {
return embedding & ~OVERRIDE;
}
private static int[] levelsFromEmbeddings(int[] ea, int[] la) {
assert ea != null;
assert la != null;
assert la.length == ea.length;
for (int i = 0, n = la.length; i < n; i++) {
la [ i ] = levelOfEmbedding(ea [ i ]);
}
return la;
}
private static void resolveRuns(int[] wca, int defaultLevel, int[] ea, int[] la) {
if (la.length != wca.length) {
throw new IllegalArgumentException("levels sequence length must match classes sequence length");
} else if (la.length != ea.length) {
throw new IllegalArgumentException("levels sequence length must match embeddings sequence length");
} else {
for (int i = 0, n = ea.length, lPrev = defaultLevel; i < n; ) {
int s = i;
int e = s;
int l = findNextNonRetainedFormattingLevel(wca, ea, s, lPrev);
while (e < n) {
if (la [ e ] != l) {
if (startsWithRetainedFormattingRun(wca, ea, e)) {
e += getLevelRunLength(ea, e);
} else {
break;
}
} else {
e++;
}
}
lPrev = resolveRun(wca, defaultLevel, ea, la, s, e, l, lPrev);
i = e;
}
}
}
private static int findNextNonRetainedFormattingLevel(int[] wca, int[] ea, int start, int lPrev) {
int s = start;
int e = wca.length;
while (s < e) {
if (startsWithRetainedFormattingRun(wca, ea, s)) {
s += getLevelRunLength(ea, s);
} else {
break;
}
}
if (s < e) {
return levelOfEmbedding(ea [ s ]);
} else {
return lPrev;
}
}
private static int getLevelRunLength(int[] ea, int start) {
assert start < ea.length;
int nl = 0;
for (int s = start, e = ea.length, l0 = levelOfEmbedding(ea [ start ]); s < e; s++) {
if (levelOfEmbedding(ea [ s ]) == l0) {
nl++;
} else {
break;
}
}
return nl;
}
private static boolean startsWithRetainedFormattingRun(int[] wca, int[] ea, int start) {
int nl = getLevelRunLength(ea, start);
if (nl > 0) {
int nc = getRetainedFormattingRunLength(wca, start);
return (nc >= nl);
} else {
return false;
}
}
private static int getRetainedFormattingRunLength(int[] wca, int start) {
assert start < wca.length;
int nc = 0;
for (int s = start, e = wca.length; s < e; s++) {
if (wca [ s ] == BidiConstants.BN) {
nc++;
} else {
break;
}
}
return nc;
}
private static int resolveRun(int[] wca, int defaultLevel, int[] ea, int[] la, int start, int end, int level, int levelPrev) {
// determine start of run direction
int sor = directionOfLevel(max(levelPrev, level));
// determine end of run direction
int le = -1;
if (end == wca.length) {
le = max(level, defaultLevel);
} else {
for (int i = end; i < wca.length; i++) {
if (wca [ i ] != BidiConstants.BN) {
le = max(level, la [ i ]);
break;
}
}
if (le < 0) {
le = max(level, defaultLevel);
}
}
int eor = directionOfLevel(le);
if (log.isDebugEnabled()) {
log.debug("BR[" + padLeft(start, 3) + "," + padLeft(end, 3) + "] :" + padLeft(level, 2) + ": SOR(" + getClassName(sor) + "), EOR(" + getClassName(eor) + ")");
}
resolveWeak(wca, defaultLevel, ea, la, start, end, level, sor, eor);
resolveNeutrals(wca, defaultLevel, ea, la, start, end, level, sor, eor);
resolveImplicit(wca, defaultLevel, ea, la, start, end, level, sor, eor);
// if this run is all retained formatting, then return prior level, otherwise this run's level
return isRetainedFormatting(wca, start, end) ? levelPrev : level;
}
private static void resolveWeak(int[] wca, int defaultLevel, int[] ea, int[] la, int start, int end, int level, int sor, int eor) {
// W1 - X BN* NSM -> X BN* X
for (int i = start, n = end, bcPrev = sor; i < n; i++) {
int bc = wca [ i ];
if (bc == NSM) {
wca [ i ] = bcPrev;
} else if (bc != BN) {
bcPrev = bc;
}
}
// W2 - AL ... EN -> AL ... AN
for (int i = start, n = end, bcPrev = sor; i < n; i++) {
int bc = wca [ i ];
if (bc == EN) {
if (bcPrev == AL) {
wca [ i ] = AN;
}
} else if (isStrong(bc)) {
bcPrev = bc;
}
}
// W3 - AL -> R
for (int i = start, n = end; i < n; i++) {
int bc = wca [ i ];
if (bc == AL) {
wca [ i ] = R;
}
}
// W4 - EN BN* ES BN* EN -> EN BN* EN BN* EN; XN BN* CS BN* XN -> XN BN* XN BN* XN
for (int i = start, n = end, bcPrev = sor; i < n; i++) {
int bc = wca [ i ];
if (bc == ES) {
int bcNext = eor;
for (int j = i + 1; j < n; j++) {
if ((bc = wca [ j ]) != BN) {
bcNext = bc;
break;
}
}
if ((bcPrev == EN) && (bcNext == EN)) {
wca [ i ] = EN;
}
} else if (bc == CS) {
int bcNext = eor;
for (int j = i + 1; j < n; j++) {
if ((bc = wca [ j ]) != BN) {
bcNext = bc;
break;
}
}
if ((bcPrev == EN) && (bcNext == EN)) {
wca [ i ] = EN;
} else if ((bcPrev == AN) && (bcNext == AN)) {
wca [ i ] = AN;
}
}
if (bc != BN) {
bcPrev = bc;
}
}
// W5 - EN (ET|BN)* -> EN (EN|BN)*; (ET|BN)* EN -> (EN|BN)* EN
for (int i = start, n = end, bcPrev = sor; i < n; i++) {
int bc = wca [ i ];
if (bc == ET) {
int bcNext = eor;
for (int j = i + 1; j < n; j++) {
bc = wca [ j ];
if ((bc != BN) && (bc != ET)) {
bcNext = bc;
break;
}
}
if ((bcPrev == EN) || (bcNext == EN)) {
wca [ i ] = EN;
}
} else if (bc != BN) {
bcPrev = bc;
}
}
// W6 - BN* (ET|ES|CS) BN* -> ON* ON ON*
for (int i = start, n = end; i < n; i++) {
int bc = wca [ i ];
if ((bc == ET) || (bc == ES) || (bc == CS)) {
wca [ i ] = ON;
resolveAdjacentBoundaryNeutrals(wca, start, end, i, ON);
}
}
// W7 - L ... EN -> L ... L
for (int i = start, n = end, bcPrev = sor; i < n; i++) {
int bc = wca [ i ];
if (bc == EN) {
if (bcPrev == L) {
wca [ i ] = L;
}
} else if ((bc == L) || (bc == R)) {
bcPrev = bc;
}
}
}
private static void resolveNeutrals(int[] wca, int defaultLevel, int[] ea, int[] la, int start, int end, int level, int sor, int eor) {
// N1 - (L|R) N+ (L|R) -> L L+ L | R R+ R; (AN|EN) N+ R -> (AN|EN) R+ R; R N+ (AN|EN) -> R R+ (AN|EN)
for (int i = start, n = end, bcPrev = sor; i < n; i++) {
int bc = wca [ i ];
if (isNeutral(bc)) {
int bcNext = eor;
for (int j = i + 1; j < n; j++) {
bc = wca [ j ];
if ((bc == L) || (bc == R)) {
bcNext = bc;
break;
} else if ((bc == AN) || (bc == EN)) {
bcNext = R;
break;
} else if (isNeutral(bc)) {
continue;
} else if (isRetainedFormatting(bc)) {
continue;
} else {
break;
}
}
if (bcPrev == bcNext) {
wca [ i ] = bcPrev;
resolveAdjacentBoundaryNeutrals(wca, start, end, i, bcPrev);
}
} else if ((bc == L) || (bc == R)) {
bcPrev = bc;
} else if ((bc == AN) || (bc == EN)) {
bcPrev = R;
}
}
// N2 - N -> embedding level
for (int i = start, n = end; i < n; i++) {
int bc = wca [ i ];
if (isNeutral(bc)) {
int bcEmbedding = directionOfLevel(levelOfEmbedding(ea [ i ]));
wca [ i ] = bcEmbedding;
resolveAdjacentBoundaryNeutrals(wca, start, end, i, bcEmbedding);
}
}
}
private static void resolveAdjacentBoundaryNeutrals(int[] wca, int start, int end, int index, int bcNew) {
if ((index < start) || (index >= end)) {
throw new IllegalArgumentException();
} else {
for (int i = index - 1; i >= start; i--) {
int bc = wca [ i ];
if (bc == BN) {
wca [ i ] = bcNew;
} else {
break;
}
}
for (int i = index + 1; i < end; i++) {
int bc = wca [ i ];
if (bc == BN) {
wca [ i ] = bcNew;
} else {
break;
}
}
}
}
private static void resolveImplicit(int[] wca, int defaultLevel, int[] ea, int[] la, int start, int end, int level, int sor, int eor) {
for (int i = start, n = end; i < n; i++) {
int bc = wca [ i ]; // bidi class
int el = la [ i ]; // embedding level
int ed = 0; // embedding level delta
if ((el & 1) == 0) { // even
if (bc == R) {
ed = 1;
} else if (bc == AN) {
ed = 2;
} else if (bc == EN) {
ed = 2;
}
} else { // odd
if (bc == L) {
ed = 1;
} else if (bc == EN) {
ed = 1;
} else if (bc == AN) {
ed = 1;
}
}
la [ i ] = el + ed;
}
}
/**
* Resolve separators and boundary neutral levels to account for UAX#9 3.4 L1 while taking into
* account retention of formatting codes (5.2).
* @param ica original input class array (sequence)
* @param wca working copy of original intput class array (sequence), as modified by prior steps
* @param dl default paragraph level
* @param la array of output levels to be adjusted, as produced by bidi algorithm
*/
private static void resolveSeparators(int[] ica, int[] wca, int dl, int[] la) {
// steps (1) through (3)
for (int i = 0, n = ica.length; i < n; i++) {
int ic = ica[i];
if ((ic == BidiConstants.S) || (ic == BidiConstants.B)) {
la[i] = dl;
for (int k = i - 1; k >= 0; k--) {
int pc = ica[k];
if (isRetainedFormatting(pc)) {
continue;
} else if (pc == BidiConstants.WS) {
la[k] = dl;
} else {
break;
}
}
}
}
// step (4) - consider end of input sequence to be end of line, but skip any trailing boundary neutrals and retained formatting codes
for (int i = ica.length; i > 0; i--) {
int k = i - 1;
int ic = ica[k];
if (isRetainedFormatting(ic)) {
continue;
} else if (ic == BidiConstants.WS) {
la[k] = dl;
} else {
break;
}
}
// step (5) - per section 5.2
for (int i = 0, n = ica.length; i < n; i++) {
int ic = ica[i];
if (isRetainedFormatting(ic)) {
if (i == 0) {
la[i] = dl;
} else {
la[i] = la [ i - 1 ];
}
}
}
}
private static boolean isStrong(int bc) {
switch (bc) {
case L:
case R:
case AL:
return true;
default:
return false;
}
}
private static boolean isNeutral(int bc) {
switch (bc) {
case WS:
case ON:
case S:
case B:
return true;
default:
return false;
}
}
private static boolean isRetainedFormatting(int bc) {
switch (bc) {
case LRE:
case LRO:
case RLE:
case RLO:
case PDF:
case BN:
return true;
default:
return false;
}
}
private static boolean isRetainedFormatting(int[] ca, int s, int e) {
for (int i = s; i < e; i++) {
if (!isRetainedFormatting(ca[i])) {
return false;
}
}
return true;
}
private static int max(int x, int y) {
if (x > y) {
return x;
} else {
return y;
}
}
private static int[] getClasses(int[] chars) {
int[] classes = new int [ chars.length ];
int bc;
for (int i = 0, n = chars.length; i < n; i++) {
int ch = chars [ i ];
if (ch >= 0) {
bc = BidiClass.getBidiClass(chars [ i ]);
} else {
bc = SURROGATE;
}
classes [ i ] = bc;
}
return classes;
}
/**
* Convert character sequence (a UTF-16 encoded string) to an array of unicode scalar values
* expressed as integers. If a valid UTF-16 surrogate pair is encountered, it is converted to
* two integers, the first being the equivalent unicode scalar value, and the second being
* negative one (-1). This special mechanism is used to track the use of surrogate pairs while
* working with unicode scalar values, and permits maintaining indices that apply both to the
* input UTF-16 and out scalar value sequences.
* @return a boolean indicating that content is present that triggers bidirectional processing
* @param cs a UTF-16 encoded character sequence
* @param chars an integer array to accept the converted scalar values, where the length of the
* array must be the same as the length of the input character sequence
* @throws IllegalArgumentException if the input sequence is not a valid UTF-16 string, e.g.,
* if it contains an isolated UTF-16 surrogate
*/
private static boolean convertToScalar(CharSequence cs, int[] chars) throws IllegalArgumentException {
boolean triggered = false;
if (chars.length != cs.length()) {
throw new IllegalArgumentException("characters array length must match input sequence length");
}
for (int i = 0, n = chars.length; i < n; ) {
int chIn = cs.charAt(i);
int chOut;
if (chIn < 0xD800) {
chOut = chIn;
} else if (chIn < 0xDC00) {
int chHi = chIn;
int chLo;
if ((i + 1) < n) {
chLo = cs.charAt(i + 1);
if ((chLo >= 0xDC00) && (chLo <= 0xDFFF)) {
chOut = convertToScalar(chHi, chLo);
} else {
throw new IllegalArgumentException("isolated high surrogate");
}
} else {
throw new IllegalArgumentException("truncated surrogate pair");
}
} else if (chIn < 0xE000) {
throw new IllegalArgumentException("isolated low surrogate");
} else {
chOut = chIn;
}
if (!triggered && triggersBidi(chOut)) {
triggered = true;
}
if ((chOut & 0xFF0000) == 0) {
chars [ i++ ] = chOut;
} else {
chars [ i++ ] = chOut;
chars [ i++ ] = -1;
}
}
return triggered;
}
/**
* Convert UTF-16 surrogate pair to unicode scalar valuee.
* @return a unicode scalar value
* @param chHi high (most significant or first) surrogate
* @param chLo low (least significant or second) surrogate
* @throws IllegalArgumentException if one of the input surrogates is not valid
*/
private static int convertToScalar(int chHi, int chLo) {
if ((chHi < 0xD800) || (chHi > 0xDBFF)) {
throw new IllegalArgumentException("bad high surrogate");
} else if ((chLo < 0xDC00) || (chLo > 0xDFFF)) {
throw new IllegalArgumentException("bad low surrogate");
} else {
return (((chHi & 0x03FF) << 10) | (chLo & 0x03FF)) + 0x10000;
}
}
/**
* Determine of character CH triggers bidirectional processing. Bidirectional
* processing is deemed triggerable if CH is a strong right-to-left character,
* an arabic letter or number, or is a right-to-left embedding or override
* character.
* @return true if character triggers bidirectional processing
* @param ch a unicode scalar value
*/
private static boolean triggersBidi(int ch) {
switch (BidiClass.getBidiClass(ch)) {
case R:
case AL:
case AN:
case RLE:
case RLO:
return true;
default:
return false;
}
}
private static void dump(String header, int[] chars, int[] classes, int defaultLevel, int[] levels) {
log.debug(header);
log.debug("BD: default level(" + defaultLevel + ")");
StringBuffer sb = new StringBuffer();
if (chars != null) {
for (int i = 0, n = chars.length; i < n; i++) {
int ch = chars [ i ];
sb.setLength(0);
if ((ch > 0x20) && (ch < 0x7F)) {
sb.append((char) ch);
} else {
sb.append(CharUtilities.charToNCRef(ch));
}
for (int k = sb.length(); k < 12; k++) {
sb.append(' ');
}
sb.append(": " + padRight(getClassName(classes[i]), 4) + " " + levels[i]);
log.debug(sb);
}
} else {
for (int i = 0, n = classes.length; i < n; i++) {
sb.setLength(0);
for (int k = sb.length(); k < 12; k++) {
sb.append(' ');
}
sb.append(": " + padRight(getClassName(classes[i]), 4) + " " + levels[i]);
log.debug(sb);
}
}
}
private static String getClassName(int bc) {
switch (bc) {
case L: // left-to-right
return "L";
case LRE: // left-to-right embedding
return "LRE";
case LRO: // left-to-right override
return "LRO";
case R: // right-to-left
return "R";
case AL: // right-to-left arabic
return "AL";
case RLE: // right-to-left embedding
return "RLE";
case RLO: // right-to-left override
return "RLO";
case PDF: // pop directional formatting
return "PDF";
case EN: // european number
return "EN";
case ES: // european number separator
return "ES";
case ET: // european number terminator
return "ET";
case AN: // arabic number
return "AN";
case CS: // common number separator
return "CS";
case NSM: // non-spacing mark
return "NSM";
case BN: // boundary neutral
return "BN";
case B: // paragraph separator
return "B";
case S: // segment separator
return "S";
case WS: // whitespace
return "WS";
case ON: // other neutrals
return "ON";
case SURROGATE: // placeholder for low surrogate
return "SUR";
default:
return "?";
}
}
private static String padLeft(int n, int width) {
return padLeft(Integer.toString(n), width);
}
private static String padLeft(String s, int width) {
StringBuffer sb = new StringBuffer();
for (int i = s.length(); i < width; i++) {
sb.append(' ');
}
sb.append(s);
return sb.toString();
}
/* not used yet
private static String padRight ( int n, int width ) {
return padRight ( Integer.toString ( n ), width );
}
*/
private static String padRight(String s, int width) {
StringBuffer sb = new StringBuffer(s);
for (int i = sb.length(); i < width; i++) {
sb.append(' ');
}
return sb.toString();
}
}