package java.text;

import java.io.BufferedInputStream;

import java.io.IOException;

import java.security.AccessController;

import java.security.PrivilegedActionException;

import java.security.PrivilegedExceptionAction;

import java.util.Vector;

import java.util.Stack;

import java.util.Hashtable;

import java.util.Enumeration;

import java.util.MissingResourceException;

import java.text.CharacterIterator;

import java.text.StringCharacterIterator;

import sun.text.CompactByteArray;

import sun.text.SupplementaryCharacterData;

class RuleBasedBreakIterator extends BreakIterator {

/**

protected static final byte IGNORE = -1;

/**

private static final short START_STATE = 1;

/**

private static final short STOP_STATE = 0;

/**

static final byte[] LABEL = {

(byte)'B', (byte)'I', (byte)'d', (byte)'a', (byte)'t', (byte)'a',

(byte)'\0'

};

static final int LABEL_LENGTH = LABEL.length;

/**

static final byte supportedVersion = 1;

/**

private static final int HEADER_LENGTH = 36;

/**

private static final int BMP_INDICES_LENGTH = 512;

/**

private CompactByteArray charCategoryTable = null;

private SupplementaryCharacterData supplementaryCharCategoryTable = null;

/**

private short[] stateTable = null;

/**

private short[] backwardsStateTable = null;

/**

private boolean[] endStates = null;

/**

private boolean[] lookaheadStates = null;

/**

private byte[] additionalData = null;

/**

private int numCategories;

/**

private CharacterIterator text = null;

/**

private long checksum;

//=======================================================================

// constructors

//=======================================================================

/**

public RuleBasedBreakIterator(String datafile)

throws IOException, MissingResourceException {

readTables(datafile);

}

/**

protected void readTables(String datafile)

throws IOException, MissingResourceException {

byte[] buffer = readFile(datafile);

/* Read header_info. */

int stateTableLength = BreakIterator.getInt(buffer, 0);

int backwardsStateTableLength = BreakIterator.getInt(buffer, 4);

int endStatesLength = BreakIterator.getInt(buffer, 8);

int lookaheadStatesLength = BreakIterator.getInt(buffer, 12);

int BMPdataLength = BreakIterator.getInt(buffer, 16);

int nonBMPdataLength = BreakIterator.getInt(buffer, 20);

int additionalDataLength = BreakIterator.getInt(buffer, 24);

checksum = BreakIterator.getLong(buffer, 28);

/* Read stateTable[numCategories * numRows] */

stateTable = new short[stateTableLength];

int offset = HEADER_LENGTH;

for (int i = 0; i < stateTableLength; i++, offset+=2) {

stateTable[i] = BreakIterator.getShort(buffer, offset);

}

/* Read backwardsStateTable[numCategories * numRows] */

backwardsStateTable = new short[backwardsStateTableLength];

for (int i = 0; i < backwardsStateTableLength; i++, offset+=2) {

backwardsStateTable[i] = BreakIterator.getShort(buffer, offset);

}

/* Read endStates[numRows] */

endStates = new boolean[endStatesLength];

for (int i = 0; i < endStatesLength; i++, offset++) {

endStates[i] = buffer[offset] == 1;

}

/* Read lookaheadStates[numRows] */

lookaheadStates = new boolean[lookaheadStatesLength];

for (int i = 0; i < lookaheadStatesLength; i++, offset++) {

lookaheadStates[i] = buffer[offset] == 1;

}

/* Read a category table and indices for BMP characters. */

short[] temp1 = new short[BMP_INDICES_LENGTH]; // BMPindices

for (int i = 0; i < BMP_INDICES_LENGTH; i++, offset+=2) {

temp1[i] = BreakIterator.getShort(buffer, offset);

}

byte[] temp2 = new byte[BMPdataLength]; // BMPdata

System.arraycopy(buffer, offset, temp2, 0, BMPdataLength);

offset += BMPdataLength;

charCategoryTable = new CompactByteArray(temp1, temp2);

/* Read a category table for non-BMP characters. */

int[] temp3 = new int[nonBMPdataLength];

for (int i = 0; i < nonBMPdataLength; i++, offset+=4) {

temp3[i] = BreakIterator.getInt(buffer, offset);

}

supplementaryCharCategoryTable = new SupplementaryCharacterData(temp3);

/* Read additional data */

if (additionalDataLength > 0) {

additionalData = new byte[additionalDataLength];

System.arraycopy(buffer, offset, additionalData, 0, additionalDataLength);

}

/* Set numCategories */

numCategories = stateTable.length / endStates.length;

}

protected byte[] readFile(final String datafile)

throws IOException, MissingResourceException {

BufferedInputStream is;

try {

is = (BufferedInputStream)AccessController.doPrivileged(

new PrivilegedExceptionAction() {

public Object run() throws Exception {

return new BufferedInputStream(getClass().getResourceAsStream("/sun/text/resources/" + datafile));

}

}

);

}

catch (PrivilegedActionException e) {

throw new InternalError(e.toString());

}

int offset = 0;

/* First, read magic, version, and header_info. */

int len = LABEL_LENGTH + 5;

byte[] buf = new byte[len];

if (is.read(buf) != len) {

throw new MissingResourceException("Wrong header length",

datafile, "");

}

/* Validate the magic number. */

for (int i = 0; i < LABEL_LENGTH; i++, offset++) {

if (buf[offset] != LABEL[offset]) {

throw new MissingResourceException("Wrong magic number",

datafile, "");

}

}

/* Validate the version number. */

if (buf[offset] != supportedVersion) {

throw new MissingResourceException("Unsupported version(" + buf[offset] + ")",

datafile, "");

}

/* Read data: totalDataSize + 8(for checksum) */

len = BreakIterator.getInt(buf, ++offset);

buf = new byte[len];

if (is.read(buf) != len) {

throw new MissingResourceException("Wrong data length",

datafile, "");

}

is.close();

return buf;

}

byte[] getAdditionalData() {

return additionalData;

}

void setAdditionalData(byte[] b) {

additionalData = b;

}

//=======================================================================

// boilerplate

//=======================================================================

/**

public Object clone() {

RuleBasedBreakIterator result = (RuleBasedBreakIterator) super.clone();

if (text != null) {

result.text = (CharacterIterator) text.clone();

}

return result;

}

/**

public boolean equals(Object that) {

try {

if (that == null) {

return false;

}

RuleBasedBreakIterator other = (RuleBasedBreakIterator) that;

if (checksum != other.checksum) {

return false;

}

if (text == null) {

return other.text == null;

} else {

return text.equals(other.text);

}

}

catch(ClassCastException e) {

return false;

}

}

/**

public String toString() {

StringBuffer sb = new StringBuffer();

sb.append('[');

sb.append("checksum=0x" + Long.toHexString(checksum));

sb.append(']');

return sb.toString();

}

/**

public int hashCode() {

return (int)checksum;

}

//=======================================================================

// BreakIterator overrides

//=======================================================================

/**

public int first() {

CharacterIterator t = getText();

t.first();

return t.getIndex();

}

/**

public int last() {

CharacterIterator t = getText();

// I'm not sure why, but t.last() returns the offset of the last character,

// rather than the past-the-end offset

t.setIndex(t.getEndIndex());

return t.getIndex();

}

/**

public int next(int n) {

int result = current();

while (n > 0) {

result = handleNext();

--n;

}

while (n < 0) {

result = previous();

++n;

}

return result;

}

/**

public int next() {

return handleNext();

}

private int cachedLastKnownBreak = BreakIterator.DONE;

/**

public int previous() {

// if we're already sitting at the beginning of the text, return DONE

CharacterIterator text = getText();

if (current() == text.getBeginIndex()) {

return BreakIterator.DONE;

}

// set things up. handlePrevious() will back us up to some valid

// break position before the current position (we back our internal

// iterator up one step to prevent handlePrevious() from returning

// the current position), but not necessarily the last one before

// where we started

int start = current();

int lastResult = cachedLastKnownBreak;

if (lastResult >= start || lastResult <= BreakIterator.DONE) {

getPrevious();

lastResult = handlePrevious();

} else {

//it might be better to check if handlePrevious() give us closer

//safe value but handlePrevious() is slow too

//So, this has to be done carefully

text.setIndex(lastResult);

}

int result = lastResult;

// iterate forward from the known break position until we pass our

// starting point. The last break position before the starting

// point is our return value

while (result != BreakIterator.DONE && result < start) {

lastResult = result;

result = handleNext();

}

// set the current iteration position to be the last break position

// before where we started, and then return that value

text.setIndex(lastResult);

cachedLastKnownBreak = lastResult;

return lastResult;

}

/**

private int getPrevious() {

char c2 = text.previous();

if (Character.isLowSurrogate(c2) &&

text.getIndex() > text.getBeginIndex()) {

char c1 = text.previous();

if (Character.isHighSurrogate(c1)) {

return Character.toCodePoint(c1, c2);

} else {

text.next();

}

}

return (int)c2;

}

/**

int getCurrent() {

char c1 = text.current();

if (Character.isHighSurrogate(c1) &&

text.getIndex() < text.getEndIndex()) {

char c2 = text.next();

text.previous();

if (Character.isLowSurrogate(c2)) {

return Character.toCodePoint(c1, c2);

}

}

return (int)c1;

}

/**

private int getCurrentCodePointCount() {

char c1 = text.current();

if (Character.isHighSurrogate(c1) &&

text.getIndex() < text.getEndIndex()) {

char c2 = text.next();

text.previous();

if (Character.isLowSurrogate(c2)) {

return 2;

}

}

return 1;

}

/**

int getNext() {

int index = text.getIndex();

int endIndex = text.getEndIndex();

if (index == endIndex ||

(index = index + getCurrentCodePointCount()) >= endIndex) {

return CharacterIterator.DONE;

}

text.setIndex(index);

return getCurrent();

}

/**

private int getNextIndex() {

int index = text.getIndex() + getCurrentCodePointCount();

int endIndex = text.getEndIndex();

if (index > endIndex) {

return endIndex;

} else {

return index;

}

}

/**

protected static final void checkOffset(int offset, CharacterIterator text) {

if (offset < text.getBeginIndex() || offset > text.getEndIndex()) {

throw new IllegalArgumentException("offset out of bounds");

}

}

/**

public int following(int offset) {

CharacterIterator text = getText();

checkOffset(offset, text);

// Set our internal iteration position (temporarily)

// to the position passed in. If this is the _beginning_ position,

// then we can just use next() to get our return value

text.setIndex(offset);

if (offset == text.getBeginIndex()) {

cachedLastKnownBreak = handleNext();

return cachedLastKnownBreak;

}

// otherwise, we have to sync up first. Use handlePrevious() to back

// us up to a known break position before the specified position (if

// we can determine that the specified position is a break position,

// we don't back up at all). This may or may not be the last break

// position at or before our starting position. Advance forward

// from here until we've passed the starting position. The position

// we stop on will be the first break position after the specified one.

int result = cachedLastKnownBreak;

if (result >= offset || result <= BreakIterator.DONE) {

result = handlePrevious();

} else {

//it might be better to check if handlePrevious() give us closer

//safe value but handlePrevious() is slow too

//So, this has to be done carefully

text.setIndex(result);

}

while (result != BreakIterator.DONE && result <= offset) {

result = handleNext();

}

cachedLastKnownBreak = result;

return result;

}

/**

public int preceding(int offset) {

// if we start by updating the current iteration position to the

// position specified by the caller, we can just use previous()

// to carry out this operation

CharacterIterator text = getText();

checkOffset(offset, text);

text.setIndex(offset);

return previous();

}

/**

public boolean isBoundary(int offset) {

CharacterIterator text = getText();

checkOffset(offset, text);

if (offset == text.getBeginIndex()) {

return true;

}

// to check whether this is a boundary, we can use following() on the

// position before the specified one and return true if the position we

// get back is the one the user specified

else {

return following(offset - 1) == offset;

}

}

/**

public int current() {

return getText().getIndex();

}

/**

public CharacterIterator getText() {

// The iterator is initialized pointing to no text at all, so if this

// function is called while we're in that state, we have to fudge an

// iterator to return.

if (text == null) {

text = new StringCharacterIterator("");

}

return text;

}

/**

public void setText(CharacterIterator newText) {

// Test iterator to see if we need to wrap it in a SafeCharIterator.

// The correct behavior for CharacterIterators is to allow the

// position to be set to the endpoint of the iterator. Many

// CharacterIterators do not uphold this, so this is a workaround

// to permit them to use this class.

int end = newText.getEndIndex();

boolean goodIterator;

try {

newText.setIndex(end); // some buggy iterators throw an exception here

goodIterator = newText.getIndex() == end;

}

catch(IllegalArgumentException e) {

goodIterator = false;

}

if (goodIterator) {

text = newText;

}

else {

text = new SafeCharIterator(newText);

}

text.first();

cachedLastKnownBreak = BreakIterator.DONE;

}

//=======================================================================

// implementation

//=======================================================================

/**

protected int handleNext() {

// if we're already at the end of the text, return DONE.

CharacterIterator text = getText();

if (text.getIndex() == text.getEndIndex()) {

return BreakIterator.DONE;

}

// no matter what, we always advance at least one character forward

int result = getNextIndex();

int lookaheadResult = 0;

// begin in state 1

int state = START_STATE;

int category;

int c = getCurrent();

// loop until we reach the end of the text or transition to state 0

while (c != CharacterIterator.DONE && state != STOP_STATE) {

// look up the current character's character category (which tells us

// which column in the state table to look at)

category = lookupCategory(c);

// if the character isn't an ignore character, look up a state

// transition in the state table

if (category != IGNORE) {

state = lookupState(state, category);

}

// if the state we've just transitioned to is a lookahead state,

// (but not also an end state), save its position. If it's

// both a lookahead state and an end state, update the break position

// to the last saved lookup-state position

if (lookaheadStates[state]) {

if (endStates[state]) {

result = lookaheadResult;

}

else {

lookaheadResult = getNextIndex();

}

}

// otherwise, if the state we've just transitioned to is an accepting

// state, update the break position to be the current iteration position

else {

if (endStates[state]) {

result = getNextIndex();

}

}

c = getNext();

}

// if we've run off the end of the text, and the very last character took us into

// a lookahead state, advance the break position to the lookahead position

// (the theory here is that if there are no characters at all after the lookahead

// position, that always matches the lookahead criteria)

if (c == CharacterIterator.DONE && lookaheadResult == text.getEndIndex()) {

result = lookaheadResult;

}

text.setIndex(result);

return result;

}

/**

protected int handlePrevious() {

CharacterIterator text = getText();

int state = START_STATE;

int category = 0;

int lastCategory = 0;

int c = getCurrent();

// loop until we reach the beginning of the text or transition to state 0

while (c != CharacterIterator.DONE && state != STOP_STATE) {

// save the last character's category and look up the current

// character's category

lastCategory = category;

category = lookupCategory(c);

// if the current character isn't an ignore character, look up a

// state transition in the backwards state table

if (category != IGNORE) {

state = lookupBackwardState(state, category);

}

// then advance one character backwards

c = getPrevious();

}

// if we didn't march off the beginning of the text, we're either one or two

// positions away from the real break position. (One because of the call to

// previous() at the end of the loop above, and another because the character

// that takes us into the stop state will always be the character BEFORE

// the break position.)

if (c != CharacterIterator.DONE) {

if (lastCategory != IGNORE) {

getNext();

getNext();

}

else {

getNext();

}

}

return text.getIndex();

}

/**

protected int lookupCategory(int c) {

if (c < Character.MIN_SUPPLEMENTARY_CODE_POINT) {

return charCategoryTable.elementAt((char)c);

} else {

return supplementaryCharCategoryTable.getValue(c);

}

}

/**

protected int lookupState(int state, int category) {

return stateTable[state * numCategories + category];

}

/**

protected int lookupBackwardState(int state, int category) {

return backwardsStateTable[state * numCategories + category];

}

/*

private static final class SafeCharIterator implements CharacterIterator,

Cloneable {

private CharacterIterator base;

private int rangeStart;

private int rangeLimit;

private int currentIndex;

SafeCharIterator(CharacterIterator base) {

this.base = base;

this.rangeStart = base.getBeginIndex();

this.rangeLimit = base.getEndIndex();

this.currentIndex = base.getIndex();

}

public char first() {

return setIndex(rangeStart);

}

public char last() {

return setIndex(rangeLimit - 1);

}

public char current() {

if (currentIndex < rangeStart || currentIndex >= rangeLimit) {

return DONE;

}

else {

return base.setIndex(currentIndex);

}

}

public char next() {

currentIndex++;

if (currentIndex >= rangeLimit) {

currentIndex = rangeLimit;

return DONE;

}

else {

return base.setIndex(currentIndex);

}

}

public char previous() {

currentIndex--;

if (currentIndex < rangeStart) {

currentIndex = rangeStart;

return DONE;

}

else {

return base.setIndex(currentIndex);

}

}

public char setIndex(int i) {

if (i < rangeStart || i > rangeLimit) {

throw new IllegalArgumentException("Invalid position");

}

currentIndex = i;

return current();

}

public int getBeginIndex() {

return rangeStart;

}

public int getEndIndex() {

return rangeLimit;

}

public int getIndex() {

return currentIndex;

}

public Object clone() {

SafeCharIterator copy = null;

try {

copy = (SafeCharIterator) super.clone();

}

catch(CloneNotSupportedException e) {

throw new Error("Clone not supported: " + e);

}

CharacterIterator copyOfBase = (CharacterIterator) base.clone();

copy.base = copyOfBase;

return copy;

}

}

}