Attachment #200389 for bug #183164

View | Details | Raw Unified | Return to bug 183164 | Differences between

and this patch




package org.eclipse.equinox.bidi.internal.tests;

import org.eclipse.equinox.bidi.*;
import org.eclipse.equinox.bidi.custom.STextDirections;
import org.eclipse.equinox.bidi.custom.STextProcessor;

/**


	class MyComma extends STextProcessor {

		public String getSeparators(STextEnvironment environment, String text, STextDirections dirProps) {
			return ","; //$NON-NLS-1$
		}

		public boolean skipProcessing(STextEnvironment environment, String text, STextDirections dirProps) {
			byte dirProp = dirProps.getOrientationAt(0);
			if (dirProp == AL)
				return true;
			return false;
		}

		public int getDirection(STextEnvironment environment, String text, STextDirections dirProps) {
			for (int i = 0; i < text.length(); i++) {
				byte dirProp = dirProps.getOrientationAt(i);
				if (dirProp == AL)
					return dirArabic;
			}

		dirArabic = RTL;
		dirHebrew = LTR;
		msg = "TestDirection #1";
		String text = toUT16("###");
		dirA = processor.getDirection(null, text, new STextDirections(text));
		text = toUT16("ABC");
		dirH = processor.getDirection(null, toUT16("ABC"), new STextDirections(text));
		assertTrue(msg, dirA == RTL && dirH == LTR);

		dirArabic = RTL;
		dirHebrew = RTL;
		msg = "TestDirection #2";
		text = toUT16("###");
		dirA = processor.getDirection(null, text, new STextDirections(text));
		text = toUT16("ABC");
		dirH = processor.getDirection(null, text, new STextDirections(text));
		assertTrue(msg, dirA == RTL && dirH == RTL);

		dirArabic = dirHebrew = LTR;


		dirArabic = RTL;
		msg = "TestDirection #10.5";
		text = toUT16("###");
		dirA = processor.getDirection(null, text, new STextDirections(text));
		text = toUT16("ABC");
		dirH = processor.getDirection(null, text, new STextDirections(text));
		assertTrue(msg, dirA == RTL && dirH == LTR);
		STextEnvironment environment = new STextEnvironment(null, true, STextEnvironment.ORIENT_LTR);
		data = "ABC,#DEF,HOST,com";

Lines 14-20 Link Here

(-)src/org/eclipse/equinox/bidi/internal/tests/STextNullProcessorTest.java (-1 / +1 lines)
14	import org.eclipse.equinox.bidi.STextEngine;	14	import org.eclipse.equinox.bidi.STextEngine;
15		15
16	/**	16	/**
17	* Tests RTL arithmetic	17	* Tests null processor
18	*/	18	*/
19	public class STextNullProcessorTest extends STextTestBase {	19	public class STextNullProcessorTest extends STextTestBase {
20		20





import org.eclipse.equinox.bidi.STextEngine;
import org.eclipse.equinox.bidi.STextEnvironment;
import org.eclipse.equinox.bidi.custom.STextDirections;
import org.eclipse.equinox.bidi.custom.STextProcessor;

/**


	class Processor1 extends STextProcessor {

		public int getSpecialsCount(STextEnvironment env, String text, STextDirections dirProps) {
			return 1;
		}

		public int indexOfSpecial(STextEnvironment env, String text, STextDirections dirProps, int[] offsets, int caseNumber, int fromIndex) {
			return fromIndex;
		}

		public int processSpecial(STextEnvironment env, String text, STextDirections dirProps, int[] offsets, int[] state, int caseNumber, int separLocation) {
			int len = text.length();
			for (int i = len - 1; i >= 0; i--) {
				STextProcessor.insertMark(text, dirProps, offsets, i);


	class Processor2 extends STextProcessor {

		public int getSpecialsCount(STextEnvironment env, String text, STextDirections dirProps) {
			return 1;
		}



	class Processor3 extends STextProcessor {

		public int getSpecialsCount(STextEnvironment env, String text, STextDirections dirProps) {
			return 1;
		}

		public int indexOfSpecial(STextEnvironment env, String text, STextDirections dirProps, int[] offsets, int caseNumber, int fromIndex) {
			return fromIndex;
		}
	}




 ******************************************************************************/
package org.eclipse.equinox.bidi.internal.tests;

import org.eclipse.equinox.bidi.STextEnvironment;
import org.eclipse.equinox.bidi.custom.STextProcessor;

public class STextTest extends STextProcessor {

	public STextTest() {
		super("-=.:");
	}

}




 ******************************************************************************/
package org.eclipse.equinox.bidi;

import org.eclipse.equinox.bidi.custom.STextDirections;
import org.eclipse.equinox.bidi.custom.STextProcessor;
import org.eclipse.equinox.bidi.internal.STextImpl;


		return STextImpl.fullBidiCharOffsets(processor, environment, text, state);
	}

	// TBD why is this method here and not just in the processor? Is it interesting in general?
	/**
	 * Get the base direction of a structured text. This base direction may depend on
	 * whether the text contains Arabic or Hebrew words. If the text contains both, 

	public static int getCurDirection(STextProcessor processor, STextEnvironment environment, String text) {
		if (processor == null)
			return DIR_LTR;
		return processor.getDirection(environment, text, new STextDirections(text));
	}

}

Lines 116-119 Link Here

(-)src/org/eclipse/equinox/bidi/STextProcessorFactory.java (+4 lines)
116	static public STextProcessor getProcessor(String id) {	116	static public STextProcessor getProcessor(String id) {
117	return STextTypesCollector.getInstance().getProcessor(id);	117	return STextTypesCollector.getInstance().getProcessor(id);
118	}	118	}
		119
		120	static public STextProcessor getMultiProcessor(String id) {
		121	return new STextProcessorMultipass();
		122	}
119	}	123	}




/*******************************************************************************
 * Copyright (c) 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/
package org.eclipse.equinox.bidi;

import org.eclipse.equinox.bidi.custom.STextProcessor;
import org.eclipse.equinox.bidi.internal.STextImpl;

public class STextProcessorMultipass extends STextProcessor {

	private int[] state = new int[] {0};

	public STextProcessorMultipass() {

	}

	public String leanToFullText(STextProcessor processor, STextEnvironment environment, String text) {
		return STextImpl.leanToFullText(processor, environment, text, state);
	}

	public int[] leanToFullMap(STextProcessor processor, STextEnvironment environment, String text) {
		return STextImpl.leanToFullMap(processor, environment, text, state);
	}

	public int[] leanBidiCharOffsets(STextProcessor processor, STextEnvironment environment, String text) {
		return STextImpl.leanBidiCharOffsets(processor, environment, text, state);
	}

	public String fullToLeanText(STextProcessor processor, STextEnvironment environment, String text) {
		return STextImpl.fullToLeanText(processor, environment, text, state);
	}

	public int[] fullToLeanMap(STextProcessor processor, STextEnvironment environment, String text) {
		return STextImpl.fullToLeanMap(processor, environment, text, state);
	}

	public int[] fullBidiCharOffsets(STextProcessor processor, STextEnvironment environment, String text) {
		return STextImpl.fullBidiCharOffsets(processor, environment, text, state);
	}
}




/*******************************************************************************
 * Copyright (c) 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/
package org.eclipse.equinox.bidi.custom;

import org.eclipse.equinox.bidi.STextEnvironment;

/**
 * The class determines bidirectional types of characters in a string.
 */
public class STextDirections {

	// In the following lines, B, L, R and AL represent bidi categories
	// as defined in the Unicode Bidirectional Algorithm
	// ( http://www.unicode.org/reports/tr9/ ).
	// B  represents the category Block Separator.
	// L  represents the category Left to Right character.
	// R  represents the category Right to Left character.
	// AL represents the category Arabic Letter.
	// AN represents the category Arabic Number.
	// EN  represents the category European Number.
	static final byte B = Character.DIRECTIONALITY_PARAGRAPH_SEPARATOR;
	static final byte L = Character.DIRECTIONALITY_LEFT_TO_RIGHT;
	static final byte R = Character.DIRECTIONALITY_RIGHT_TO_LEFT;
	static final byte AL = Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC;
	static final byte AN = Character.DIRECTIONALITY_ARABIC_NUMBER;
	static final byte EN = Character.DIRECTIONALITY_EUROPEAN_NUMBER;

	// TBD consider moving L, R, AL, AN, EN, B into this class from STextImpl
	// TBD add methods:
	// isRTL	(dirProp == R || dirProp == AL)
	// isLTR	(dirProp == L || dirProp == EN)
	// isStrong (isRTL() || isLTR() || dirProp == AN) <= excludes unknown, B, WS

	final protected String text;

	// 1 byte for each char in text
	private byte[] dirProps;

	// current orientation
	private byte baseOrientation = 0; // "0" means "unknown"

	public STextDirections(String text) {
		this.text = text;
		dirProps = new byte[text.length()];
	}

	public void setBaseOrientation(byte orientation) {
		baseOrientation = orientation;
	}

	public byte getBaseOrientation() {
		return baseOrientation;
	}

	private byte getCachedDirectionAt(int index) {
		return (byte) (dirProps[index] - 1);
	}

	private boolean hasCachedDirectionAt(int i) {
		return (dirProps[i] != 0); // "0" means "unknown"
	}

	/**
	 * @param  dirProp bidirectional class of the character. It must be
	 *         one of the values which can be returned by
	 *         <code>java.lang.Character.getDirectionality</code>.
	 */
	public void setOrientationAt(int i, byte dirProp) {
		dirProps[i] = (byte) (dirProp + 1);
	}

	public int getBaseOrientation(STextEnvironment environment) {
		int result;
		int orient = environment.getOrientation();
		if ((orient & STextEnvironment.ORIENT_CONTEXTUAL_LTR) == 0) { // absolute orientation
			result = orient;
		} else { // contextual orientation:
			result = orient & 1; // initiate to the default orientation minus contextual bit
			int len = text.length();
			byte dirProp;
			for (int i = 0; i < len; i++) {
				if (!hasCachedDirectionAt(i)) {
					dirProp = Character.getDirectionality(text.charAt(i));
					if (dirProp == B) // B char resolves to L or R depending on orientation
						continue;
					setOrientationAt(i, dirProp);
				} else {
					dirProp = getCachedDirectionAt(i);
				}
				if (dirProp == L) { // TBD || == EN ?
					result = STextEnvironment.ORIENT_LTR;
					break;
				}
				if (dirProp == R || dirProp == AL) {
					result = STextEnvironment.ORIENT_RTL;
					break;
				}
			}
			if (result == -1) // return the default orientation minus contextual bit
				result = orient & 1;
		}
		baseOrientation = (byte) result;
		return result;
	}

	/**
	 * Returns directionality of the character in the original string at
	 * the specified index.
	 * @param index position of the character in the <i>lean</i> text
	 * @return the bidirectional class of the character. It is one of the
	 * values which can be returned by {@link Character#getDirectionality(char)}
	 */
	public byte getOrientationAt(int index) {
		if (hasCachedDirectionAt(index))
			return getCachedDirectionAt(index);
		byte dirProp = Character.getDirectionality(text.charAt(index));
		if (dirProp == B) {
			byte orient = getBaseOrientation();
			dirProp = (orient == STextEnvironment.ORIENT_RTL) ? R : L;
		}
		setOrientationAt(index, dirProp);
		return dirProp;
	}

}




	 * number of special cases is zero, which means that
	 * <code>indexOfSpecial</code> should never be called for them.
	 */
	public int indexOfSpecial(STextEnvironment environment, String text, STextDirections dirProps, int[] offsets, int caseNumber, int fromIndex) {
		// This method must be overridden by all subclasses with special cases.
		throw new IllegalStateException("A processor with specialsCount > 0 must have an indexOfSpecial() method."); //$NON-NLS-1$
	}

	 * number of special cases is zero, which means that
	 * <code>processSpecial</code> should never be called for them.
	 */
	public int processSpecial(STextEnvironment environment, String text, STextDirections dirProps, int[] offsets, int[] state, int caseNumber, int separLocation) {
		// This method must be overridden by all subclasses with any special case.
		throw new IllegalStateException("A processor with specialsCount > 0 must have a processSpecial() method."); //$NON-NLS-1$
	}

	/**
	 * This method can be called from within {@link #indexOfSpecial} or
	 * {@link #processSpecial} in extensions of <code>STextProcessor</code> to retrieve
	 * the bidirectional class of characters in the <i>lean</i> text.
	 *
	 * @param  text is the structured text string received as
	 *         parameter to <code>indexOfSpecial</code> or
	 *         <code>processSpecial</code>.
	 *
	 * @param  dirProps is a parameter received by <code>indexOfSpecial</code>
	 *         or <code>processSpecial</code>, uniquely to be used as argument
	 *         for calls to <code>getDirProp</code> and other methods used
	 *         by processors.
	 *
	 * @param index position of the character in the <i>lean</i> text.
	 *         It must be a non-negative number smaller than the length
	 *         of the <i>lean</i> text.
	 *
	 * @return the bidirectional class of the character. It is one of the
	 *         values which can be returned by
	 *         <code>java.lang.Character.getDirectionality</code>.
	 *         However, it is recommended to use <code>getDirProp</code>
	 *         rather than <code>java.lang.Character.getDirectionality</code>
	 *         since <code>getDirProp</code> manages a cache of character
	 *         properties and so can be more efficient than calling the
	 *         java.lang.Character method.
	 */
	public static final byte getDirProp(String text, byte[] dirProps, int index) {
		return STextImpl.getDirProp(text, dirProps, index);
	}

	/**
	 * This method can be called from within {@link #indexOfSpecial} or
	 * {@link #processSpecial} in extensions of <code>STextProcessor</code> to set or
	 * override the bidirectional class of characters in the <i>lean</i> text.
	 *
	 * @param  dirProps is a parameter received by <code>indexOfSpecial</code>
	 *         or <code>processSpecial</code>, uniquely to be used as argument
	 *         for calls to <code>setDirProp</code> and other methods used
	 *         by processors.
	 *
	 * @param index position of the character in the <i>lean</i> text.
	 *         It must be a non-negative number smaller than the length
	 *         of the <i>lean</i> text.
	 *
	 * @param  dirProp bidirectional class of the character. It must be
	 *         one of the values which can be returned by
	 *         <code>java.lang.Character.getDirectionality</code>.
	 */
	public static final void setDirProp(byte[] dirProps, int index, byte dirProp) {
		STextImpl.setDirProp(dirProps, index, dirProp);
	}

	/**

	 *         For the benefit of efficiency, it is better to insert
	 *         multiple marks in ascending order of the offsets.
	 */
	public static final void insertMark(String text, STextDirections dirProps, int[] offsets, int offset) {
		STextImpl.insertMark(text, dirProps, offsets, offset);
	}


	 *         It must be a non-negative number smaller than the length
	 *         of the <i>lean</i> text.
	 */
	public static final void processSeparator(String text, STextDirections dirProps, int[] offsets, int separLocation) {
		STextImpl.processSeparator(text, dirProps, offsets, separLocation);
	}


	 * @return a string grouping one-character separators which separate
	 *         the structured text into tokens.
	 */
	public String getSeparators(STextEnvironment environment, String text, STextDirections dirProps) {
		return separators;
	}


	 *         The value returned is either
	 *         {@link STextEngine#DIR_LTR DIR_LTR} or {@link STextEngine#DIR_RTL DIR_RTL}.
	 */
	public int getDirection(STextEnvironment environment, String text, STextDirections dirProps) {
		return STextEngine.DIR_LTR;
	}


	 *         anything which is not identified by a one-character separator.
	 *
	 */
	public int getSpecialsCount(STextEnvironment environment, String text, STextDirections dirProps) {
		return 0;
	}


	 *         text to add directional formatting characters.
	 *
	 */
	public boolean skipProcessing(STextEnvironment environment, String text, STextDirections dirProps) {
		return false;
	}





package org.eclipse.equinox.bidi.internal;

import org.eclipse.equinox.bidi.STextEnvironment;
import org.eclipse.equinox.bidi.custom.STextDirections;
import org.eclipse.equinox.bidi.custom.STextProcessor;

/**

	 *
	 *  @see #getDelimiters
	 */
	public int indexOfSpecial(STextEnvironment environment, String text, STextDirections dirProps, int[] offsets, int caseNumber, int fromIndex) {
		char delim = getDelimiters().charAt((caseNumber - 1) * 2);
		return text.indexOf(delim, fromIndex);
	}

	 *  @return the position after the matching end delimiter, or the length
	 *          of <code>text</code> if no end delimiter is found.
	 */
	public int processSpecial(STextEnvironment environment, String text, STextDirections dirProps, int[] offsets, int[] state, int caseNumber, int separLocation) {
		STextProcessor.processSeparator(text, dirProps, offsets, separLocation);
		int loc = separLocation + 1;
		char delim = getDelimiters().charAt((caseNumber * 2) - 1);

Lines 11-16 Link Here

(-)src/org/eclipse/equinox/bidi/internal/STextDelimsEsc.java (-1 / +2 lines)
11	package org.eclipse.equinox.bidi.internal;	11	package org.eclipse.equinox.bidi.internal;
12		12
13	import org.eclipse.equinox.bidi.STextEnvironment;	13	import org.eclipse.equinox.bidi.STextEnvironment;
		14	import org.eclipse.equinox.bidi.custom.STextDirections;
14	import org.eclipse.equinox.bidi.custom.STextProcessor;	15	import org.eclipse.equinox.bidi.custom.STextProcessor;
15		16
16	/**	17	/**
Lines 49-55 Link Here
49	* and skips until after the matching end delimiter,	50	* and skips until after the matching end delimiter,
50	* ignoring possibly escaped end delimiters.	51	* ignoring possibly escaped end delimiters.
51	*/	52	*/
52	public int processSpecial(STextEnvironment environment, String text, byte[] dirProps, int[] offsets, int[] state, int caseNumber, int separLocation) {	53	public int processSpecial(STextEnvironment environment, String text, STextDirections dirProps, int[] offsets, int[] state, int caseNumber, int separLocation) {
53	STextProcessor.processSeparator(text, dirProps, offsets, separLocation);	54	STextProcessor.processSeparator(text, dirProps, offsets, separLocation);
54	int location = separLocation + 1;	55	int location = separLocation + 1;
55	char delim = getDelimiters().charAt((caseNumber * 2) - 1);	56	char delim = getDelimiters().charAt((caseNumber * 2) - 1);





import org.eclipse.equinox.bidi.STextEngine;
import org.eclipse.equinox.bidi.STextEnvironment;
import org.eclipse.equinox.bidi.custom.STextDirections;
import org.eclipse.equinox.bidi.custom.STextProcessor;

/**

public class STextImpl {

	static final String EMPTY_STRING = ""; //$NON-NLS-1$

	// In the following lines, B, L, R and AL represent bidi categories
	// as defined in the Unicode Bidirectional Algorithm
	// ( http://www.unicode.org/reports/tr9/ ).
	// B  represents the category Block Separator.
	// L  represents the category Left to Right character.
	// R  represents the category Right to Left character.
	// AL represents the category Arabic Letter.
	// AN represents the category Arabic Number.
	// EN  represents the category European Number.
	static final byte B = Character.DIRECTIONALITY_PARAGRAPH_SEPARATOR;
	static final byte L = Character.DIRECTIONALITY_LEFT_TO_RIGHT;
	static final byte R = Character.DIRECTIONALITY_RIGHT_TO_LEFT;
	static final byte AL = Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC;
	static final byte AN = Character.DIRECTIONALITY_ARABIC_NUMBER;
	static final byte EN = Character.DIRECTIONALITY_EUROPEAN_NUMBER;

	static final char LRM = 0x200E;
	static final char RLM = 0x200F;
	static final char LRE = 0x202A;

	static final int PREFIX_LENGTH = 2;
	static final int SUFFIX_LENGTH = 2;
	static final int FIXES_LENGTH = PREFIX_LENGTH + SUFFIX_LENGTH;
	static final int DIRPROPS_ADD = 2;
	static final int OFFSETS_SHIFT = 3;
	static final int[] EMPTY_INT_ARRAY = new int[0];
	static final STextEnvironment IGNORE_ENVIRONMENT = new STextEnvironment(null, false, STextEnvironment.ORIENT_IGNORE);

		// nothing to do
	}

	static long computeNextLocation(STextProcessor processor, STextEnvironment environment, String text, STextDirections dirProps, int[] offsets, int[] locations, int[] state, int curPos) {
		String separators = processor.getSeparators(environment, text, dirProps);
		int separCount = separators.length();
		int specialsCount = processor.getSpecialsCount(environment, text, dirProps);

			}
		}
		return nextLocation + (((long) idxLocation) << 32);
	}

	static int getCurOrient(STextEnvironment environment, String text, byte[] dirProps) {
		int orient = environment.getOrientation();
		if ((orient & STextEnvironment.ORIENT_CONTEXTUAL_LTR) == 0) {
			// absolute orientation
			return orient;
		}
		// contextual orientation
		int len = text.length();
		byte dirProp;
		for (int i = 0; i < len; i++) {
			// In the following lines, B, L, R and AL represent bidi categories
			// as defined in the Unicode Bidirectional Algorithm
			// ( http://www.unicode.org/reports/tr9/ ).
			// B  represents the category Block Separator.
			// L  represents the category Left to Right character.
			// R  represents the category Right to Left character.
			// AL represents the category Arabic Letter.
			dirProp = dirProps[i];
			if (dirProp == 0) {
				dirProp = Character.getDirectionality(text.charAt(i));
				if (dirProp == B) // B char resolves to L or R depending on orientation
					continue;
				dirProps[i] = (byte) (dirProp + DIRPROPS_ADD);
			} else {
				dirProp -= DIRPROPS_ADD;
			}
			if (dirProp == L)
				return STextEnvironment.ORIENT_LTR;
			if (dirProp == R || dirProp == AL)
				return STextEnvironment.ORIENT_RTL;
		}
		// return the default orientation corresponding to the contextual orientation
		return orient & 1;
	}

	/**
	 *  @see STextEngine#getCurDirection STextEngine.getCurDirection
	 */
	public static int getCurDirection(STextProcessor processor, STextEnvironment environment, String text, byte[] dirProps) {
		return processor.getDirection(environment, text, dirProps);
	}

	/**
	 *  @see STextProcessor#getDirProp STextProcessor.getDirProp
	 */
	public static byte getDirProp(String text, byte[] dirProps, int index) {
		byte dirProp = dirProps == null ? 0 : dirProps[index];
		if (dirProp == 0) {
			// In the following lines, B, L and R represent bidi categories
			// as defined in the Unicode Bidirectional Algorithm
			// ( http://www.unicode.org/reports/tr9/ ).
			// B  represents the category Block Separator.
			// L  represents the category Left to Right character.
			// R  represents the category Right to Left character.
			dirProp = Character.getDirectionality(text.charAt(index));
			if (dirProp == B && dirProps != null) {
				// the last entry of dirProps contains the current component orientation
				byte orient = dirProps[dirProps.length - 1];
				if (orient == -1)
					return B;
				dirProp = orient == STextEnvironment.ORIENT_RTL ? R : L;
			}
			if (dirProps != null)
				dirProps[index] = (byte) (dirProp + DIRPROPS_ADD);
			return dirProp;
		}
		return (byte) (dirProp - DIRPROPS_ADD);
	}

	/**
	 *  @see STextProcessor#setDirProp STextProcessor.setDirProp
	 */
	public static void setDirProp(byte[] dirProps, int index, byte dirProp) {
		dirProps[index] = (byte) (dirProp + DIRPROPS_ADD);
	}

	/**
	 *  @see STextProcessor#processSeparator STextProcessor.processSeparator
	 */
	public static void processSeparator(String text, STextDirections dirProps, int[] offsets, int separLocation) {
		// In this method, L, R, AL, AN and EN represent bidi categories
		// as defined in the Unicode Bidirectional Algorithm
		// ( http://www.unicode.org/reports/tr9/ ).
		// L  represents the category Left to Right character.
		// R  represents the category Right to Left character.
		// AL represents the category Arabic Letter.
		// AN represents the category Arabic Number.
		// EN  represents the category European Number.
		int len = text.length();
		// offsets[2] contains the structured text direction
		if (offsets[2] == STextEngine.DIR_RTL) {
			// the structured text base direction is RTL
			for (int i = separLocation - 1; i >= 0; i--) {
				byte dirProp = dirProps.getOrientationAt(i);
				if (dirProp == R || dirProp == AL)
					return;
				if (dirProp == L) {
					for (int j = separLocation; j < len; j++) {
						dirProp = dirProps.getOrientationAt(j);
						if (dirProp == R || dirProp == AL)
							return;
						if (dirProp == L || dirProp == EN) {

		// the structured text base direction is LTR
		boolean doneAN = false;
		for (int i = separLocation - 1; i >= 0; i--) {
			byte dirProp = dirProps.getOrientationAt(i);
			if (dirProp == L)
				return;
			if (dirProp == R || dirProp == AL) {
				for (int j = separLocation; j < len; j++) {
					dirProp = dirProps.getOrientationAt(j);
					if (dirProp == L)
						return;
					if (dirProp == R || dirProp == EN || dirProp == AL || dirProp == AN) {

			}
			if (dirProp == AN && !doneAN) {
				for (int j = separLocation; j < len; j++) {
					dirProp = dirProps.getOrientationAt(j);
					if (dirProp == L)
						return;
					if (dirProp == AL || dirProp == AN || dirProp == R) {

		int len = text.length();
		if (len == 0)
			return text;
		STextDirections dirProps = new STextDirections(text);
		int[] offsets = leanToFullCommon(processor, environment, text, state, dirProps);
		int prefixLength = offsets[1];
		int count = offsets[0] - OFFSETS_SHIFT;

		int len = text.length();
		if (len == 0)
			return EMPTY_INT_ARRAY;
		STextDirections dirProps = new STextDirections(text);
		int[] offsets = leanToFullCommon(processor, environment, text, state, dirProps);
		int prefixLength = offsets[1];
		int[] map = new int[len];

		int len = text.length();
		if (len == 0)
			return EMPTY_INT_ARRAY;
		STextDirections dirProps = new STextDirections(text);
		int[] offsets = leanToFullCommon(processor, environment, text, state, dirProps);
		// offsets[0] contains the number of used entries
		int count = offsets[0] - OFFSETS_SHIFT;

		return result;
	}

	static int[] leanToFullCommon(STextProcessor processor, STextEnvironment environment, String text, int[] state, STextDirections dirProps) {
		if (environment == null)
			environment = STextEnvironment.DEFAULT;
		if (state == null) {

			state[0] = STextEngine.STATE_INITIAL;
		}
		int len = text.length();
		int orient = dirProps.getBaseOrientation(environment);
		int orient = getCurOrient(environment, text, dirProps);
		dirProps[len] = (byte) orient;
		int direction = processor.getDirection(environment, text, dirProps);
		// offsets of marks to add. Entry 0 is the number of used slots;
		//  entry 1 is reserved to pass prefixLength.

			offsets[1] = 0;
		else {
			// recompute orient since it may have changed if contextual
			orient = dirProps.getBaseOrientation(environment);
			dirProps[len] = (byte) orient;
			if (orient == direction && orient != STextEnvironment.ORIENT_UNKNOWN)
				offsets[1] = 0;
			else if ((environment.getOrientation() & STextEnvironment.ORIENT_CONTEXTUAL_LTR) != 0)

			state = new int[1];
			state[0] = STextEngine.STATE_INITIAL;
		}
		int dir = processor.getDirection(environment, text, new STextDirections(text));
		char curMark = MARKS[dir];
		char curEmbed = EMBEDS[dir];
		int i; // used as loop index

			return EMPTY_INT_ARRAY;
		String lean = fullToLeanText(processor, environment, full, state);
		int lenLean = lean.length();
		int dir = processor.getDirection(environment, lean, new STextDirections(lean));
		char curMark = MARKS[dir];
		char curEmbed = EMBEDS[dir];
		int[] map = new int[lenFull];

		offsets[0] = OFFSETS_SHIFT;
		int lenLean = lean.length();
		int idxLean, idxFull;
		STextDirections dirProps = new STextDirections(full);
		// lean must be a subset of Full, so we only check on iLean < leanLen
		for (idxLean = idxFull = 0; idxLean < lenLean; idxFull++) {
			if (full.charAt(idxFull) == lean.charAt(idxLean))
				idxLean++;
			else {
				offsets = ensureRoomInOffsets(offsets);
				insertMark(lean, dirProps, offsets, idxFull);
			}
		}
		for (; idxFull < lenFull; idxFull++) {
			offsets = ensureRoomInOffsets(offsets);
			insertMark(lean, dirProps, offsets, idxFull);
		}
		int[] result = new int[offsets[0] - OFFSETS_SHIFT];
		System.arraycopy(offsets, OFFSETS_SHIFT, result, 0, result.length);

	/**
	 *  @see STextProcessor#insertMark STextProcessor.insertMark
	 */
	public static void insertMark(String text, STextDirections dirProps, int[] offsets, int offset) {
		int count = offsets[0];// number of used entries
		int index = count - 1; // index of greatest member <= offset
		// look up after which member the new offset should be inserted

		if (dirProps == null || offset < 1)
			return;

		byte dirProp = dirProps.getOrientationAt(offset);
		// if the current char is a strong one or a digit, we change the
		//   dirProp of the previous char to account for the inserted mark.
		// In the following lines, L, R, AL, AN and EN represent bidi categories
		// as defined in the Unicode Bidirectional Algorithm
		// ( http://www.unicode.org/reports/tr9/ ).
		// L  represents the category Left to Right character.
		// R  represents the category Right to Left character.
		// AL represents the category Arabic Letter.
		// AN represents the category Arabic Number.
		// EN  represents the category European Number.
		if (dirProp == L || dirProp == R || dirProp == AL || dirProp == EN || dirProp == AN)
			index = offset - 1;
		else

			index = offset;

		int dir = offsets[2]; // current structured text direction
		dirProps.setOrientationAt(index, STRONGS[dir]);
		return;
	}





package org.eclipse.equinox.bidi.internal;

import org.eclipse.equinox.bidi.STextEnvironment;
import org.eclipse.equinox.bidi.custom.STextDirections;
import org.eclipse.equinox.bidi.custom.STextProcessor;

/**

	 *
	 *  @see #getSeparators getSeparators
	 */
	public int indexOfSpecial(STextEnvironment environment, String text, STextDirections dirProps, int[] offsets, int caseNumber, int fromIndex) {
		return text.indexOf(this.getSeparators(environment, text, dirProps).charAt(0), fromIndex);
	}


	 *
	 *  @return the length of <code>text</code>.
	 */
	public int processSpecial(STextEnvironment environment, String text, STextDirections dirProps, int[] offsets, int[] state, int caseNumber, int separLocation) {
		STextProcessor.processSeparator(text, dirProps, offsets, separLocation);
		return text.length();
	}

	 *
	 *  @return 1.
	 */
	public int getSpecialsCount(STextEnvironment environment, String text, STextDirections dirProps) {
		return 1;
	}






import org.eclipse.equinox.bidi.STextEngine;
import org.eclipse.equinox.bidi.STextEnvironment;
import org.eclipse.equinox.bidi.custom.STextDirections;
import org.eclipse.equinox.bidi.internal.STextDelimsEsc;

/**

	 *          </ul>
	 *          Otherwise, returns {@link STextEngine#DIR_LTR DIR_LTR}.
	 */
	public int getDirection(STextEnvironment environment, String text, STextDirections dirProps) {
		String language = environment.getLanguage();
		if (!language.equals("ar")) //$NON-NLS-1$
			return STextEngine.DIR_LTR;

		if (domainStart < 0)
			domainStart = 0;
		for (int i = domainStart; i < text.length(); i++) {
			byte dirProp = dirProps.getOrientationAt(i);
			if (dirProp == AL || dirProp == R)
				return STextEngine.DIR_RTL;
		}

	/**
	 *  @return 2 as number of special cases handled by this processor.
	 */
	public int getSpecialsCount(STextEnvironment environment, String text, STextDirections dirProps) {
		return 2;
	}






import org.eclipse.equinox.bidi.STextEngine;
import org.eclipse.equinox.bidi.STextEnvironment;
import org.eclipse.equinox.bidi.custom.STextDirections;
import org.eclipse.equinox.bidi.custom.STextProcessor;
import org.eclipse.equinox.bidi.internal.STextActivator;


	/**
	 *  @return 4 as the number of special cases handled by this processor.
	 */
	public int getSpecialsCount(STextEnvironment environment, String text, STextDirections dirProps) {
		return 4;
	}


	     *    <li>comments starting with slash-slash</li>
	     *  </ol>
	     */
	public int indexOfSpecial(STextEnvironment environment, String text, STextDirections dirProps, int[] offsets, int caseNumber, int fromIndex) {
		switch (caseNumber) {
			case 1 : /* space */
				return text.indexOf(' ', fromIndex);

	     *    <li>skip until after a line separator</li>
	     *  </ol>
	 */
	public int processSpecial(STextEnvironment environment, String text, STextDirections dirProps, int[] offsets, int[] state, int caseNumber, int separLocation) {
		int location, counter, i;

		STextProcessor.processSeparator(text, dirProps, offsets, separLocation);

			case 1 : /* space */
				separLocation++;
				while (separLocation < text.length() && text.charAt(separLocation) == ' ') {
					dirProps.setOrientationAt(separLocation, WS);
					separLocation++;
				}
				return separLocation;





import org.eclipse.equinox.bidi.STextEngine;
import org.eclipse.equinox.bidi.STextEnvironment;
import org.eclipse.equinox.bidi.custom.STextDirections;
import org.eclipse.equinox.bidi.custom.STextProcessor;

/**

	 *          </ul>
	 *          Otherwise, returns {@link STextEngine#DIR_LTR DIR_LTR}.
	 */
	public int getDirection(STextEnvironment environment, String text, STextDirections dirProps) {
		String language = environment.getLanguage();
		if (!language.equals("ar")) //$NON-NLS-1$
			return STextEngine.DIR_LTR;
		boolean flagAN = false;
		for (int i = 0; i < text.length(); i++) {
			byte dirProp = dirProps.getOrientationAt(i);
			if (dirProp == AL)
				return STextEngine.DIR_RTL;
			if (dirProp == L || dirProp == R)





import org.eclipse.equinox.bidi.STextEngine;
import org.eclipse.equinox.bidi.STextEnvironment;
import org.eclipse.equinox.bidi.custom.STextDirections;
import org.eclipse.equinox.bidi.custom.STextProcessor;

/**

	 *  
	 *  @return the number of special cases for this processor.
	 */
	public int getSpecialsCount(STextEnvironment environment, String text, STextDirections dirProps) {
		return maxSpecial;
	}


	 *  This method locates occurrences of the syntactic strings and of
	 *  R, AL, EN, AN characters.
	 */
	public int indexOfSpecial(STextEnvironment environment, String text, STextDirections dirProps, int[] offsets, int caseNumber, int fromIndex) {
		// In this method, L, R, AL, AN and EN represent bidi categories
		// as defined in the Unicode Bidirectional Algorithm
		// ( http://www.unicode.org/reports/tr9/ ).

			fromIndex = 1;
		// look for R, AL, AN, EN which are potentially needing a mark
		for (; fromIndex < text.length(); fromIndex++) {
			dirProp = dirProps.getOrientationAt(fromIndex);
			// R and AL will always be examined using processSeparator()
			if (dirProp == R || dirProp == AL)
				return fromIndex;

			if (dirProp == EN || dirProp == AN) {
				// no need for a mark after the first digit in a number
				if (dirProps.getOrientationAt(fromIndex - 1) == dirProp)
					continue;

				for (int i = fromIndex - 1; i >= 0; i--) {
					dirProp = dirProps.getOrientationAt(i);
					// after a L char, no need for a mark
					if (dirProp == L)
						continue;

	/**
	 *  This method process the special cases.
	 */
	public int processSpecial(STextEnvironment environment, String text, STextDirections dirProps, int[] offsets, int[] state, int caseNumber, int separLocation) {
		int location;

		switch (caseNumber) {

					return text.length();
				}
				// set the dirProp for the "E" to L (Left to Right character)
				dirProps.setOrientationAt(location + 1, L);
				return location + 2;
			case 18 : /* R, AL, AN, EN */
				STextProcessor.processSeparator(text, dirProps, offsets, separLocation);

	 *          </ul>
	 *          Otherwise, returns {@link STextEngine#DIR_LTR DIR_LTR}.
	 */
	public int getDirection(STextEnvironment environment, String text, STextDirections dirProps) {
		String language = environment.getLanguage();
		if (!language.equals("ar")) //$NON-NLS-1$
			return STextEngine.DIR_LTR;
		for (int i = 0; i < text.length(); i++) {
			byte dirProp = dirProps.getOrientationAt(i);
			if (dirProp == AL || dirProp == R)
				return STextEngine.DIR_RTL;
			if (dirProp == L)





import org.eclipse.equinox.bidi.STextEngine;
import org.eclipse.equinox.bidi.STextEnvironment;
import org.eclipse.equinox.bidi.custom.STextDirections;
import org.eclipse.equinox.bidi.custom.STextProcessor;
import org.eclipse.equinox.bidi.internal.STextActivator;


	/**
	 *  @return 5 as the number of special cases handled by this processor.
	 */
	public int getSpecialsCount(STextEnvironment environment, String text, STextDirections dirProps) {
		return 5;
	}


	  *    <li>comments starting with hyphen-hyphen</li>
	  *  </ol>
	  */
	public int indexOfSpecial(STextEnvironment environment, String text, STextDirections dirProps, int[] offsets, int caseNumber, int fromIndex) {
		switch (caseNumber) {
			case 1 : /* space */
				return text.indexOf(" ", fromIndex); //$NON-NLS-1$

	     *    <li>skip until after a line separator</li>
	     *  </ol>
	 */
	public int processSpecial(STextEnvironment environment, String text, STextDirections dirProps, int[] offsets, int[] state, int caseNumber, int separLocation) {
		int location;

		STextProcessor.processSeparator(text, dirProps, offsets, separLocation);

			case 1 : /* space */
				separLocation++;
				while (separLocation < text.length() && text.charAt(separLocation) == ' ') {
					dirProps.setOrientationAt(separLocation, WS);
					separLocation++;
				}
				return separLocation;

Lines 11-16 Link Here

(-)src/org/eclipse/equinox/bidi/internal/consumable/STextXPath.java (-1 / +2 lines)
11	package org.eclipse.equinox.bidi.internal.consumable;	11	package org.eclipse.equinox.bidi.internal.consumable;
12		12
13	import org.eclipse.equinox.bidi.STextEnvironment;	13	import org.eclipse.equinox.bidi.STextEnvironment;
		14	import org.eclipse.equinox.bidi.custom.STextDirections;
14	import org.eclipse.equinox.bidi.internal.STextDelims;	15	import org.eclipse.equinox.bidi.internal.STextDelims;
15		16
16	/**	17	/**
Lines 25-31 Link Here
25	/**	26	/**
26	* @return 2 as the number of special cases handled by this processor.	27	* @return 2 as the number of special cases handled by this processor.
27	*/	28	*/
28	public int getSpecialsCount(STextEnvironment environment, String text, byte[] dirProps) {	29	public int getSpecialsCount(STextEnvironment environment, String text, STextDirections dirProps) {
29	return 2;	30	return 2;
30	}	31	}
31		32

Return to bug 183164

Lines 132-138 Link Here

(-)src/org/eclipse/equinox/bidi/custom/STextProcessor.java (-61 / +8 lines)
132	* number of special cases is zero, which means that	132	* number of special cases is zero, which means that
133	* <code>indexOfSpecial</code> should never be called for them.	133	* <code>indexOfSpecial</code> should never be called for them.
134	*/	134	*/
135	public int indexOfSpecial(STextEnvironment environment, String text, byte[] dirProps, int[] offsets, int caseNumber, int fromIndex) {	135	public int indexOfSpecial(STextEnvironment environment, String text, STextDirections dirProps, int[] offsets, int caseNumber, int fromIndex) {
136	// This method must be overridden by all subclasses with special cases.	136	// This method must be overridden by all subclasses with special cases.
137	throw new IllegalStateException("A processor with specialsCount > 0 must have an indexOfSpecial() method."); //$NON-NLS-1$	137	throw new IllegalStateException("A processor with specialsCount > 0 must have an indexOfSpecial() method."); //$NON-NLS-1$
138	}	138	}
Lines 216-277 Link Here
216	* number of special cases is zero, which means that	216	* number of special cases is zero, which means that
217	* <code>processSpecial</code> should never be called for them.	217	* <code>processSpecial</code> should never be called for them.
218	*/	218	*/
219	public int processSpecial(STextEnvironment environment, String text, byte[] dirProps, int[] offsets, int[] state, int caseNumber, int separLocation) {	219	public int processSpecial(STextEnvironment environment, String text, STextDirections dirProps, int[] offsets, int[] state, int caseNumber, int separLocation) {
220	// This method must be overridden by all subclasses with any special case.	220	// This method must be overridden by all subclasses with any special case.
221	throw new IllegalStateException("A processor with specialsCount > 0 must have a processSpecial() method."); //$NON-NLS-1$	221	throw new IllegalStateException("A processor with specialsCount > 0 must have a processSpecial() method."); //$NON-NLS-1$
222	}
223
224	/**
225	* This method can be called from within {@link #indexOfSpecial} or
226	* {@link #processSpecial} in extensions of <code>STextProcessor</code> to retrieve
227	* the bidirectional class of characters in the <i>lean</i> text.
228	*
229	* @param text is the structured text string received as
230	* parameter to <code>indexOfSpecial</code> or
231	* <code>processSpecial</code>.
232	*
233	* @param dirProps is a parameter received by <code>indexOfSpecial</code>
234	* or <code>processSpecial</code>, uniquely to be used as argument
235	* for calls to <code>getDirProp</code> and other methods used
236	* by processors.
237	*
238	* @param index position of the character in the <i>lean</i> text.
239	* It must be a non-negative number smaller than the length
240	* of the <i>lean</i> text.
241	*
242	* @return the bidirectional class of the character. It is one of the
243	* values which can be returned by
244	* <code>java.lang.Character.getDirectionality</code>.
245	* However, it is recommended to use <code>getDirProp</code>
246	* rather than <code>java.lang.Character.getDirectionality</code>
247	* since <code>getDirProp</code> manages a cache of character
248	* properties and so can be more efficient than calling the
249	* java.lang.Character method.
250	*/
251	public static final byte getDirProp(String text, byte[] dirProps, int index) {
252	return STextImpl.getDirProp(text, dirProps, index);
253	}
254
255	/**
256	* This method can be called from within {@link #indexOfSpecial} or
257	* {@link #processSpecial} in extensions of <code>STextProcessor</code> to set or
258	* override the bidirectional class of characters in the <i>lean</i> text.
259	*
260	* @param dirProps is a parameter received by <code>indexOfSpecial</code>
261	* or <code>processSpecial</code>, uniquely to be used as argument
262	* for calls to <code>setDirProp</code> and other methods used
263	* by processors.
264	*
265	* @param index position of the character in the <i>lean</i> text.
266	* It must be a non-negative number smaller than the length
267	* of the <i>lean</i> text.
268	*
269	* @param dirProp bidirectional class of the character. It must be
270	* one of the values which can be returned by
271	* <code>java.lang.Character.getDirectionality</code>.
272	*/
273	public static final void setDirProp(byte[] dirProps, int index, byte dirProp) {
274	STextImpl.setDirProp(dirProps, index, dirProp);
275	}	222	}
276		223
277	/**	224	/**
Lines 305-311 Link Here
305	* For the benefit of efficiency, it is better to insert	252	* For the benefit of efficiency, it is better to insert
306	* multiple marks in ascending order of the offsets.	253	* multiple marks in ascending order of the offsets.
307	*/	254	*/
308	public static final void insertMark(String text, byte[] dirProps, int[] offsets, int offset) {	255	public static final void insertMark(String text, STextDirections dirProps, int[] offsets, int offset) {
309	STextImpl.insertMark(text, dirProps, offsets, offset);	256	STextImpl.insertMark(text, dirProps, offsets, offset);
310	}	257	}
311		258
Lines 340-346 Link Here
340	* It must be a non-negative number smaller than the length	287	* It must be a non-negative number smaller than the length
341	* of the <i>lean</i> text.	288	* of the <i>lean</i> text.
342	*/	289	*/
343	public static final void processSeparator(String text, byte[] dirProps, int[] offsets, int separLocation) {	290	public static final void processSeparator(String text, STextDirections dirProps, int[] offsets, int separLocation) {
344	STextImpl.processSeparator(text, dirProps, offsets, separLocation);	291	STextImpl.processSeparator(text, dirProps, offsets, separLocation);
345	}	292	}
346		293
Lines 365-371 Link Here
365	* @return a string grouping one-character separators which separate	312	* @return a string grouping one-character separators which separate
366	* the structured text into tokens.	313	* the structured text into tokens.
367	*/	314	*/
368	public String getSeparators(STextEnvironment environment, String text, byte[] dirProps) {	315	public String getSeparators(STextEnvironment environment, String text, STextDirections dirProps) {
369	return separators;	316	return separators;
370	}	317	}
371		318
Lines 394-400 Link Here
394	* The value returned is either	341	* The value returned is either
395	* {@link STextEngine#DIR_LTR DIR_LTR} or {@link STextEngine#DIR_RTL DIR_RTL}.	342	* {@link STextEngine#DIR_LTR DIR_LTR} or {@link STextEngine#DIR_RTL DIR_RTL}.
396	*/	343	*/
397	public int getDirection(STextEnvironment environment, String text, byte[] dirProps) {	344	public int getDirection(STextEnvironment environment, String text, STextDirections dirProps) {
398	return STextEngine.DIR_LTR;	345	return STextEngine.DIR_LTR;
399	}	346	}
400		347
Lines 426-432 Link Here
426	* anything which is not identified by a one-character separator.	373	* anything which is not identified by a one-character separator.
427	*	374	*
428	*/	375	*/
429	public int getSpecialsCount(STextEnvironment environment, String text, byte[] dirProps) {	376	public int getSpecialsCount(STextEnvironment environment, String text, STextDirections dirProps) {
430	return 0;	377	return 0;
431	}	378	}
432		379
Lines 455-461 Link Here
455	* text to add directional formatting characters.	402	* text to add directional formatting characters.
456	*	403	*
457	*/	404	*/
458	public boolean skipProcessing(STextEnvironment environment, String text, byte[] dirProps) {	405	public boolean skipProcessing(STextEnvironment environment, String text, STextDirections dirProps) {
459	return false;	406	return false;
460	}	407	}
461		408

Lines 10-22 Link Here

(-)src/org/eclipse/equinox/bidi/internal/tests/STextTest.java (-4 / +2 lines)
10	******************************************************************************/	10	******************************************************************************/
11	package org.eclipse.equinox.bidi.internal.tests;	11	package org.eclipse.equinox.bidi.internal.tests;
12		12
13	import org.eclipse.equinox.bidi.STextEnvironment;
14	import org.eclipse.equinox.bidi.custom.STextProcessor;	13	import org.eclipse.equinox.bidi.custom.STextProcessor;
15		14
16	public class STextTest extends STextProcessor {	15	public class STextTest extends STextProcessor {
17		16
18	public String getSeparators(STextEnvironment env, String text, byte[] dirProps) {	17	public STextTest() {
19	return "-=.:";	18	super("-=.:");
20	}	19	}
21
22	}	20	}

Lines 10-15 Link Here

(-)src/org/eclipse/equinox/bidi/STextEngine.java (-1 / +3 lines)
10	******************************************************************************/	10	******************************************************************************/
11	package org.eclipse.equinox.bidi;	11	package org.eclipse.equinox.bidi;
12		12
		13	import org.eclipse.equinox.bidi.custom.STextDirections;
13	import org.eclipse.equinox.bidi.custom.STextProcessor;	14	import org.eclipse.equinox.bidi.custom.STextProcessor;
14	import org.eclipse.equinox.bidi.internal.STextImpl;	15	import org.eclipse.equinox.bidi.internal.STextImpl;
15		16
Lines 295-300 Link Here
295	return STextImpl.fullBidiCharOffsets(processor, environment, text, state);	296	return STextImpl.fullBidiCharOffsets(processor, environment, text, state);
296	}	297	}
297		298
		299	// TBD why is this method here and not just in the processor? Is it interesting in general?
298	/**	300	/**
299	* Get the base direction of a structured text. This base direction may depend on	301	* Get the base direction of a structured text. This base direction may depend on
300	* whether the text contains Arabic or Hebrew words. If the text contains both,	302	* whether the text contains Arabic or Hebrew words. If the text contains both,
Lines 312-318 Link Here
312	public static int getCurDirection(STextProcessor processor, STextEnvironment environment, String text) {	314	public static int getCurDirection(STextProcessor processor, STextEnvironment environment, String text) {
313	if (processor == null)	315	if (processor == null)
314	return DIR_LTR;	316	return DIR_LTR;
315	return STextImpl.getCurDirection(processor, environment, text, null);	317	return processor.getDirection(environment, text, new STextDirections(text));
316	}	318	}
317		319
318	}	320	}

Added Link Here

(-)src/org/eclipse/equinox/bidi/STextProcessorMultipass.java (+47 lines)
1	/*******************************************************************************
2	* Copyright (c) 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11	package org.eclipse.equinox.bidi;
12
13	import org.eclipse.equinox.bidi.custom.STextProcessor;
14	import org.eclipse.equinox.bidi.internal.STextImpl;
15
16	public class STextProcessorMultipass extends STextProcessor {
17
18	private int[] state = new int[] {0};
19
20	public STextProcessorMultipass() {
21
22	}
23
24	public String leanToFullText(STextProcessor processor, STextEnvironment environment, String text) {
25	return STextImpl.leanToFullText(processor, environment, text, state);
26	}
27
28	public int[] leanToFullMap(STextProcessor processor, STextEnvironment environment, String text) {
29	return STextImpl.leanToFullMap(processor, environment, text, state);
30	}
31
32	public int[] leanBidiCharOffsets(STextProcessor processor, STextEnvironment environment, String text) {
33	return STextImpl.leanBidiCharOffsets(processor, environment, text, state);
34	}
35
36	public String fullToLeanText(STextProcessor processor, STextEnvironment environment, String text) {
37	return STextImpl.fullToLeanText(processor, environment, text, state);
38	}
39
40	public int[] fullToLeanMap(STextProcessor processor, STextEnvironment environment, String text) {
41	return STextImpl.fullToLeanMap(processor, environment, text, state);
42	}
43
44	public int[] fullBidiCharOffsets(STextProcessor processor, STextEnvironment environment, String text) {
45	return STextImpl.fullBidiCharOffsets(processor, environment, text, state);
46	}
47	}