Back to index...

	/*
	* Copyright (c) 2009, 2020, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	/*
	*******************************************************************************
	* Copyright (C) 2009-2014, International Business Machines
	* Corporation and others. All Rights Reserved.
	*******************************************************************************
	*/
	package jdk.internal.icu.impl;

	import java.io.IOException;
	import java.nio.ByteBuffer;

	import jdk.internal.icu.lang.UCharacter;
	import jdk.internal.icu.text.Normalizer2;
	import jdk.internal.icu.text.UTF16;
	import jdk.internal.icu.util.CodePointTrie;
	import jdk.internal.icu.util.VersionInfo;

	// Original filename in ICU4J: Normalizer2Impl.java
	public final class NormalizerImpl {
	public static final class Hangul {
	/* Korean Hangul and Jamo constants */
	public static final int JAMO_L_BASE=0x1100; /* "lead" jamo */
	public static final int JAMO_V_BASE=0x1161; /* "vowel" jamo */
	public static final int JAMO_T_BASE=0x11a7; /* "trail" jamo */

	public static final int HANGUL_BASE=0xac00;
	public static final int HANGUL_END=0xd7a3;

	public static final int JAMO_L_COUNT=19;
	public static final int JAMO_V_COUNT=21;
	public static final int JAMO_T_COUNT=28;

	public static final int HANGUL_COUNT=JAMO_L_COUNTJAMO_V_COUNTJAMO_T_COUNT;
	public static final int HANGUL_LIMIT=HANGUL_BASE+HANGUL_COUNT;

	public static boolean isHangul(int c) {
	return HANGUL_BASE<=c && c<HANGUL_LIMIT;
	}
	public static boolean isHangulLV(int c) {
	c-=HANGUL_BASE;
	return 0<=c && c<HANGUL_COUNT && c%JAMO_T_COUNT==0;
	}

	/**
	* Decomposes c, which must be a Hangul syllable, into buffer
	* and returns the length of the decomposition (2 or 3).
	*/
	public static int decompose(int c, Appendable buffer) {
	try {
	c-=HANGUL_BASE;
	int c2=c%JAMO_T_COUNT;
	c/=JAMO_T_COUNT;
	buffer.append((char)(JAMO_L_BASE+c/JAMO_V_COUNT));
	buffer.append((char)(JAMO_V_BASE+c%JAMO_V_COUNT));
	if(c2==0) {
	return 2;
	} else {
	buffer.append((char)(JAMO_T_BASE+c2));
	return 3;
	}
	} catch(IOException e) {
	throw new InternalError(e);
	}
	}
	}

	/**
	* Writable buffer that takes care of canonical ordering.
	* Its Appendable methods behave like the C++ implementation's
	* appendZeroCC() methods.
	* <p>
	* If dest is a StringBuilder, then the buffer writes directly to it.
	* Otherwise, the buffer maintains a StringBuilder for intermediate text segments
	* until no further changes are necessary and whole segments are appended.
	* append() methods that take combining-class values always write to the StringBuilder.
	* Other append() methods flush and append to the Appendable.
	*/
	public static final class ReorderingBuffer implements Appendable {
	public ReorderingBuffer(NormalizerImpl ni, Appendable dest, int destCapacity) {
	impl=ni;
	app=dest;
	if (app instanceof StringBuilder) {
	appIsStringBuilder=true;
	str=(StringBuilder)dest;
	// In Java, the constructor subsumes public void init(int destCapacity)
	str.ensureCapacity(destCapacity);
	reorderStart=0;
	if(str.length()==0) {
	lastCC=0;
	} else {
	setIterator();
	lastCC=previousCC();
	// Set reorderStart after the last code point with cc<=1 if there is one.
	if(lastCC>1) {
	while(previousCC()>1) {}
	}
	reorderStart=codePointLimit;
	}
	} else {
	appIsStringBuilder=false;
	str=new StringBuilder();
	reorderStart=0;
	lastCC=0;
	}
	}

	public boolean isEmpty() { return str.length()==0; }
	public int length() { return str.length(); }
	public int getLastCC() { return lastCC; }

	public StringBuilder getStringBuilder() { return str; }

	public boolean equals(CharSequence s, int start, int limit) {
	return UTF16Plus.equal(str, 0, str.length(), s, start, limit);
	}

	public void append(int c, int cc) {
	if(lastCC<=cc \|\| cc==0) {
	str.appendCodePoint(c);
	lastCC=cc;
	if(cc<=1) {
	reorderStart=str.length();
	}
	} else {
	insert(c, cc);
	}
	}
	public void append(CharSequence s, int start, int limit, boolean isNFD,
	int leadCC, int trailCC) {
	if(start==limit) {
	return;
	}
	if(lastCC<=leadCC \|\| leadCC==0) {
	if(trailCC<=1) {
	reorderStart=str.length()+(limit-start);
	} else if(leadCC<=1) {
	reorderStart=str.length()+1; // Ok if not a code point boundary.
	}
	str.append(s, start, limit);
	lastCC=trailCC;
	} else {
	int c=Character.codePointAt(s, start);
	start+=Character.charCount(c);
	insert(c, leadCC); // insert first code point
	while(start<limit) {
	c=Character.codePointAt(s, start);
	start+=Character.charCount(c);
	if(start<limit) {
	if (isNFD) {
	leadCC = getCCFromYesOrMaybe(impl.getNorm16(c));
	} else {
	leadCC = impl.getCC(impl.getNorm16(c));
	}
	} else {
	leadCC=trailCC;
	}
	append(c, leadCC);
	}
	}
	}
	// The following append() methods work like C++ appendZeroCC().
	// They assume that the cc or trailCC of their input is 0.
	// Most of them implement Appendable interface methods.
	@Override
	public ReorderingBuffer append(char c) {
	str.append(c);
	lastCC=0;
	reorderStart=str.length();
	return this;
	}
	public void appendZeroCC(int c) {
	str.appendCodePoint(c);
	lastCC=0;
	reorderStart=str.length();
	}
	@Override
	public ReorderingBuffer append(CharSequence s) {
	if(s.length()!=0) {
	str.append(s);
	lastCC=0;
	reorderStart=str.length();
	}
	return this;
	}
	@Override
	public ReorderingBuffer append(CharSequence s, int start, int limit) {
	if(start!=limit) {
	str.append(s, start, limit);
	lastCC=0;
	reorderStart=str.length();
	}
	return this;
	}
	/**
	* Flushes from the intermediate StringBuilder to the Appendable,
	* if they are different objects.
	* Used after recomposition.
	* Must be called at the end when writing to a non-StringBuilder Appendable.
	*/
	public void flush() {
	if(appIsStringBuilder) {
	reorderStart=str.length();
	} else {
	try {
	app.append(str);
	str.setLength(0);
	reorderStart=0;
	} catch(IOException e) {
	throw new InternalError(e); // Avoid declaring "throws IOException".
	}
	}
	lastCC=0;
	}
	/**
	* Flushes from the intermediate StringBuilder to the Appendable,
	* if they are different objects.
	* Then appends the new text to the Appendable or StringBuilder.
	* Normally used after quick check loops find a non-empty sequence.
	*/
	public ReorderingBuffer flushAndAppendZeroCC(CharSequence s, int start, int limit) {
	if(appIsStringBuilder) {
	str.append(s, start, limit);
	reorderStart=str.length();
	} else {
	try {
	app.append(str).append(s, start, limit);
	str.setLength(0);
	reorderStart=0;
	} catch(IOException e) {
	throw new InternalError(e); // Avoid declaring "throws IOException".
	}
	}
	lastCC=0;
	return this;
	}
	public void remove() {
	str.setLength(0);
	lastCC=0;
	reorderStart=0;
	}
	public void removeSuffix(int suffixLength) {
	int oldLength=str.length();
	str.delete(oldLength-suffixLength, oldLength);
	lastCC=0;
	reorderStart=str.length();
	}

	// Inserts c somewhere before the last character.
	// Requires 0<cc<lastCC which implies reorderStart<limit.
	private void insert(int c, int cc) {
	for(setIterator(), skipPrevious(); previousCC()>cc;) {}
	// insert c at codePointLimit, after the character with prevCC<=cc
	if(c<=0xffff) {
	str.insert(codePointLimit, (char)c);
	if(cc<=1) {
	reorderStart=codePointLimit+1;
	}
	} else {
	str.insert(codePointLimit, Character.toChars(c));
	if(cc<=1) {
	reorderStart=codePointLimit+2;
	}
	}
	}

	private final NormalizerImpl impl;
	private final Appendable app;
	private final StringBuilder str;
	private final boolean appIsStringBuilder;
	private int reorderStart;
	private int lastCC;

	// private backward iterator
	private void setIterator() { codePointStart=str.length(); }
	private void skipPrevious() { // Requires 0<codePointStart.
	codePointLimit=codePointStart;
	codePointStart=str.offsetByCodePoints(codePointStart, -1);
	}
	private int previousCC() { // Returns 0 if there is no previous character.
	codePointLimit=codePointStart;
	if(reorderStart>=codePointStart) {
	return 0;
	}
	int c=str.codePointBefore(codePointStart);
	codePointStart-=Character.charCount(c);
	return impl.getCCFromYesOrMaybeCP(c);
	}
	private int codePointStart, codePointLimit;
	}

	// TODO: Propose as public API on the UTF16 class.
	// TODO: Propose widening UTF16 methods that take char to take int.
	// TODO: Propose widening UTF16 methods that take String to take CharSequence.
	public static final class UTF16Plus {
	/**
	* Is this code point a lead surrogate (U+d800..U+dbff)?
	* @param c code unit or code point
	* @return true or false
	*/
	public static boolean isLeadSurrogate(int c) { return (c & 0xfffffc00) == 0xd800; }
	/**
	* Assuming c is a surrogate code point (UTF16.isSurrogate(c)),
	* is it a lead surrogate?
	* @param c code unit or code point
	* @return true or false
	*/
	public static boolean isSurrogateLead(int c) { return (c&0x400)==0; }

	/**
	* Compares two CharSequence subsequences for binary equality.
	* @param s1 first sequence
	* @param start1 start offset in first sequence
	* @param limit1 limit offset in first sequence
	* @param s2 second sequence
	* @param start2 start offset in second sequence
	* @param limit2 limit offset in second sequence
	* @return true if s1.subSequence(start1, limit1) contains the same text
	* as s2.subSequence(start2, limit2)
	*/
	public static boolean equal(CharSequence s1, int start1, int limit1,
	CharSequence s2, int start2, int limit2) {
	if((limit1-start1)!=(limit2-start2)) {
	return false;
	}
	if(s1==s2 && start1==start2) {
	return true;
	}
	while(start1<limit1) {
	if(s1.charAt(start1++)!=s2.charAt(start2++)) {
	return false;
	}
	}
	return true;
	}
	}

	public NormalizerImpl() {}

	private static final class IsAcceptable implements ICUBinary.Authenticate {
	public boolean isDataVersionAcceptable(byte version[]) {
	return version[0]==4;
	}
	}
	private static final IsAcceptable IS_ACCEPTABLE = new IsAcceptable();
	private static final int DATA_FORMAT = 0x4e726d32; // "Nrm2"

	public NormalizerImpl load(ByteBuffer bytes) {
	try {
	dataVersion=ICUBinary.readHeaderAndDataVersion(bytes, DATA_FORMAT, IS_ACCEPTABLE);
	int indexesLength=bytes.getInt()/4; // inIndexes[IX_NORM_TRIE_OFFSET]/4
	if(indexesLength<=IX_MIN_LCCC_CP) {
	throw new InternalError("Normalizer2 data: not enough indexes");
	}
	int[] inIndexes=new int[indexesLength];
	inIndexes[0]=indexesLength*4;
	for(int i=1; i<indexesLength; ++i) {
	inIndexes[i]=bytes.getInt();
	}

	minDecompNoCP=inIndexes[IX_MIN_DECOMP_NO_CP];
	minCompNoMaybeCP=inIndexes[IX_MIN_COMP_NO_MAYBE_CP];
	minLcccCP=inIndexes[IX_MIN_LCCC_CP];

	minYesNo=inIndexes[IX_MIN_YES_NO];
	minYesNoMappingsOnly=inIndexes[IX_MIN_YES_NO_MAPPINGS_ONLY];
	minNoNo=inIndexes[IX_MIN_NO_NO];
	minNoNoCompBoundaryBefore=inIndexes[IX_MIN_NO_NO_COMP_BOUNDARY_BEFORE];
	minNoNoCompNoMaybeCC=inIndexes[IX_MIN_NO_NO_COMP_NO_MAYBE_CC];
	minNoNoEmpty=inIndexes[IX_MIN_NO_NO_EMPTY];
	limitNoNo=inIndexes[IX_LIMIT_NO_NO];
	minMaybeYes=inIndexes[IX_MIN_MAYBE_YES];
	assert((minMaybeYes&7)==0); // 8-aligned for noNoDelta bit fields
	centerNoNoDelta=(minMaybeYes>>DELTA_SHIFT)-MAX_DELTA-1;

	// Read the normTrie.
	int offset=inIndexes[IX_NORM_TRIE_OFFSET];
	int nextOffset=inIndexes[IX_EXTRA_DATA_OFFSET];
	int triePosition = bytes.position();
	normTrie = CodePointTrie.Fast16.fromBinary(bytes);
	int trieLength = bytes.position() - triePosition;
	if(trieLength>(nextOffset-offset)) {
	throw new InternalError("Normalizer2 data: not enough bytes for normTrie");
	}
	ICUBinary.skipBytes(bytes, (nextOffset-offset)-trieLength); // skip padding after trie bytes

	// Read the composition and mapping data.
	offset=nextOffset;
	nextOffset=inIndexes[IX_SMALL_FCD_OFFSET];
	int numChars=(nextOffset-offset)/2;
	if(numChars!=0) {
	maybeYesCompositions=ICUBinary.getString(bytes, numChars, 0);
	extraData=maybeYesCompositions.substring((MIN_NORMAL_MAYBE_YES-minMaybeYes)>>OFFSET_SHIFT);
	}

	// smallFCD: new in formatVersion 2
	offset=nextOffset;
	smallFCD=new byte[0x100];
	bytes.get(smallFCD);

	return this;
	} catch(IOException e) {
	throw new InternalError(e);
	}
	}
	public NormalizerImpl load(String name) {
	return load(ICUBinary.getRequiredData(name));
	}

	// The trie stores values for lead surrogate code units.
	// Surrogate code points are inert.
	public int getNorm16(int c) {
	return UTF16Plus.isLeadSurrogate(c) ? INERT : normTrie.get(c);
	}
	public int getRawNorm16(int c) { return normTrie.get(c); }
	public boolean isAlgorithmicNoNo(int norm16) { return limitNoNo<=norm16 && norm16<minMaybeYes; }
	public boolean isCompNo(int norm16) { return minNoNo<=norm16 && norm16<minMaybeYes; }
	public boolean isDecompYes(int norm16) { return norm16<minYesNo \|\| minMaybeYes<=norm16; }

	public int getCC(int norm16) {
	if(norm16>=MIN_NORMAL_MAYBE_YES) {
	return getCCFromNormalYesOrMaybe(norm16);
	}
	if(norm16<minNoNo \|\| limitNoNo<=norm16) {
	return 0;
	}
	return getCCFromNoNo(norm16);
	}
	public static int getCCFromNormalYesOrMaybe(int norm16) {
	return (norm16 >> OFFSET_SHIFT) & 0xff;
	}
	public static int getCCFromYesOrMaybe(int norm16) {
	return norm16>=MIN_NORMAL_MAYBE_YES ? getCCFromNormalYesOrMaybe(norm16) : 0;
	}
	public int getCCFromYesOrMaybeCP(int c) {
	if (c < minCompNoMaybeCP) { return 0; }
	return getCCFromYesOrMaybe(getNorm16(c));
	}

	/**
	* Returns the FCD data for code point c.
	* @param c A Unicode code point.
	* @return The lccc(c) in bits 15..8 and tccc(c) in bits 7..0.
	*/
	public int getFCD16(int c) {
	if(c<minDecompNoCP) {
	return 0;
	} else if(c<=0xffff) {
	if(!singleLeadMightHaveNonZeroFCD16(c)) { return 0; }
	}
	return getFCD16FromNormData(c);
	}
	/** Returns true if the single-or-lead code unit c might have non-zero FCD data. */
	public boolean singleLeadMightHaveNonZeroFCD16(int lead) {
	// 0<=lead<=0xffff
	byte bits=smallFCD[lead>>8];
	if(bits==0) { return false; }
	return ((bits>>((lead>>5)&7))&1)!=0;
	}

	/** Gets the FCD value from the regular normalization data. */
	public int getFCD16FromNormData(int c) {
	int norm16=getNorm16(c);
	if (norm16 >= limitNoNo) {
	if(norm16>=MIN_NORMAL_MAYBE_YES) {
	// combining mark
	norm16=getCCFromNormalYesOrMaybe(norm16);
	return norm16\|(norm16<<8);
	} else if(norm16>=minMaybeYes) {
	return 0;
	} else { // isDecompNoAlgorithmic(norm16)
	int deltaTrailCC = norm16 & DELTA_TCCC_MASK;
	if (deltaTrailCC <= DELTA_TCCC_1) {
	return deltaTrailCC >> OFFSET_SHIFT;
	}
	// Maps to an isCompYesAndZeroCC.
	c=mapAlgorithmic(c, norm16);
	norm16=getRawNorm16(c);
	}
	}
	if(norm16<=minYesNo \|\| isHangulLVT(norm16)) {
	// no decomposition or Hangul syllable, all zeros
	return 0;
	}
	// c decomposes, get everything from the variable-length extra data
	int mapping=norm16>>OFFSET_SHIFT;
	int firstUnit=extraData.charAt(mapping);
	int fcd16=firstUnit>>8; // tccc
	if((firstUnit&MAPPING_HAS_CCC_LCCC_WORD)!=0) {
	fcd16\|=extraData.charAt(mapping-1)&0xff00; // lccc
	}
	return fcd16;
	}

	/**
	* Gets the decomposition for one code point.
	* @param c code point
	* @return c's decomposition, if it has one; returns null if it does not have a decomposition
	*/
	public String getDecomposition(int c) {
	int norm16;
	if(c<minDecompNoCP \|\| isMaybeOrNonZeroCC(norm16=getNorm16(c))) {
	// c does not decompose
	return null;
	}
	int decomp = -1;
	if(isDecompNoAlgorithmic(norm16)) {
	// Maps to an isCompYesAndZeroCC.
	decomp=c=mapAlgorithmic(c, norm16);
	// The mapping might decompose further.
	norm16 = getRawNorm16(c);
	}
	if (norm16 < minYesNo) {
	if(decomp<0) {
	return null;
	} else {
	return UTF16.valueOf(decomp);
	}
	} else if(isHangulLV(norm16) \|\| isHangulLVT(norm16)) {
	// Hangul syllable: decompose algorithmically
	StringBuilder buffer=new StringBuilder();
	Hangul.decompose(c, buffer);
	return buffer.toString();
	}
	// c decomposes, get everything from the variable-length extra data
	int mapping=norm16>>OFFSET_SHIFT;
	int length=extraData.charAt(mapping++)&MAPPING_LENGTH_MASK;
	return extraData.substring(mapping, mapping+length);
	}

	// Fixed norm16 values.
	public static final int MIN_YES_YES_WITH_CC=0xfe02;
	public static final int JAMO_VT=0xfe00;
	public static final int MIN_NORMAL_MAYBE_YES=0xfc00;
	public static final int JAMO_L=2; // offset=1 hasCompBoundaryAfter=FALSE
	public static final int INERT=1; // offset=0 hasCompBoundaryAfter=TRUE

	// norm16 bit 0 is comp-boundary-after.
	public static final int HAS_COMP_BOUNDARY_AFTER=1;
	public static final int OFFSET_SHIFT=1;

	// For algorithmic one-way mappings, norm16 bits 2..1 indicate the
	// tccc (0, 1, >1) for quick FCC boundary-after tests.
	public static final int DELTA_TCCC_0=0;
	public static final int DELTA_TCCC_1=2;
	public static final int DELTA_TCCC_GT_1=4;
	public static final int DELTA_TCCC_MASK=6;
	public static final int DELTA_SHIFT=3;

	public static final int MAX_DELTA=0x40;

	// Byte offsets from the start of the data, after the generic header.
	public static final int IX_NORM_TRIE_OFFSET=0;
	public static final int IX_EXTRA_DATA_OFFSET=1;
	public static final int IX_SMALL_FCD_OFFSET=2;
	public static final int IX_RESERVED3_OFFSET=3;
	public static final int IX_TOTAL_SIZE=7;
	public static final int MIN_CCC_LCCC_CP=0x300;
	// Code point thresholds for quick check codes.
	public static final int IX_MIN_DECOMP_NO_CP=8;
	public static final int IX_MIN_COMP_NO_MAYBE_CP=9;

	// Norm16 value thresholds for quick check combinations and types of extra data.

	/** Mappings & compositions in [minYesNo..minYesNoMappingsOnly[. */
	public static final int IX_MIN_YES_NO=10;
	/** Mappings are comp-normalized. */
	public static final int IX_MIN_NO_NO=11;
	public static final int IX_LIMIT_NO_NO=12;
	public static final int IX_MIN_MAYBE_YES=13;

	/** Mappings only in [minYesNoMappingsOnly..minNoNo[. */
	public static final int IX_MIN_YES_NO_MAPPINGS_ONLY=14;
	/** Mappings are not comp-normalized but have a comp boundary before. */
	public static final int IX_MIN_NO_NO_COMP_BOUNDARY_BEFORE=15;
	/** Mappings do not have a comp boundary before. */
	public static final int IX_MIN_NO_NO_COMP_NO_MAYBE_CC=16;
	/** Mappings to the empty string. */
	public static final int IX_MIN_NO_NO_EMPTY=17;

	public static final int IX_MIN_LCCC_CP=18;
	public static final int IX_COUNT=20;

	public static final int MAPPING_HAS_CCC_LCCC_WORD=0x80;
	public static final int MAPPING_HAS_RAW_MAPPING=0x40;
	// unused bit 0x20;
	public static final int MAPPING_LENGTH_MASK=0x1f;

	public static final int COMP_1_LAST_TUPLE=0x8000;
	public static final int COMP_1_TRIPLE=1;
	public static final int COMP_1_TRAIL_LIMIT=0x3400;
	public static final int COMP_1_TRAIL_MASK=0x7ffe;
	public static final int COMP_1_TRAIL_SHIFT=9; // 10-1 for the "triple" bit
	public static final int COMP_2_TRAIL_SHIFT=6;
	public static final int COMP_2_TRAIL_MASK=0xffc0;

	// higher-level functionality ------------------------------------------ ***

	/**
	* Decomposes s[src, limit[ and writes the result to dest.
	* limit can be NULL if src is NUL-terminated.
	* destLengthEstimate is the initial dest buffer capacity and can be -1.
	*/
	public void decompose(CharSequence s, int src, int limit, StringBuilder dest,
	int destLengthEstimate) {
	if(destLengthEstimate<0) {
	destLengthEstimate=limit-src;
	}
	dest.setLength(0);
	ReorderingBuffer buffer=new ReorderingBuffer(this, dest, destLengthEstimate);
	decompose(s, src, limit, buffer);
	}

	// Dual functionality:
	// buffer!=NULL: normalize
	// buffer==NULL: isNormalized/quickCheck/spanQuickCheckYes
	public int decompose(CharSequence s, int src, int limit,
	ReorderingBuffer buffer) {
	int minNoCP=minDecompNoCP;

	int prevSrc;
	int c=0;
	int norm16=0;

	// only for quick check
	int prevBoundary=src;
	int prevCC=0;

	for(;;) {
	// count code units below the minimum or with irrelevant data for the quick check
	for(prevSrc=src; src!=limit;) {
	if( (c=s.charAt(src))<minNoCP \|\|
	isMostDecompYesAndZeroCC(norm16=normTrie.bmpGet(c))
	) {
	++src;
	} else if(!UTF16Plus.isLeadSurrogate(c)) {
	break;
	} else {
	char c2;
	if ((src + 1) != limit && Character.isLowSurrogate(c2 = s.charAt(src + 1))) {
	c = Character.toCodePoint((char)c, c2);
	norm16 = normTrie.suppGet(c);
	if (isMostDecompYesAndZeroCC(norm16)) {
	src += 2;
	} else {
	break;
	}
	} else {
	++src; // unpaired lead surrogate: inert
	}
	}
	}
	// copy these code units all at once
	if(src!=prevSrc) {
	if(buffer!=null) {
	buffer.flushAndAppendZeroCC(s, prevSrc, src);
	} else {
	prevCC=0;
	prevBoundary=src;
	}
	}
	if(src==limit) {
	break;
	}

	// Check one above-minimum, relevant code point.
	src+=Character.charCount(c);
	if(buffer!=null) {
	decompose(c, norm16, buffer);
	} else {
	if(isDecompYes(norm16)) {
	int cc=getCCFromYesOrMaybe(norm16);
	if(prevCC<=cc \|\| cc==0) {
	prevCC=cc;
	if(cc<=1) {
	prevBoundary=src;
	}
	continue;
	}
	}
	return prevBoundary; // "no" or cc out of order
	}
	}
	return src;
	}
	public void decomposeAndAppend(CharSequence s, boolean doDecompose, ReorderingBuffer buffer) {
	int limit=s.length();
	if(limit==0) {
	return;
	}
	if(doDecompose) {
	decompose(s, 0, limit, buffer);
	return;
	}
	// Just merge the strings at the boundary.
	int c=Character.codePointAt(s, 0);
	int src=0;
	int firstCC, prevCC, cc;
	firstCC=prevCC=cc=getCC(getNorm16(c));
	while(cc!=0) {
	prevCC=cc;
	src+=Character.charCount(c);
	if(src>=limit) {
	break;
	}
	c=Character.codePointAt(s, src);
	cc=getCC(getNorm16(c));
	};
	buffer.append(s, 0, src, false, firstCC, prevCC);
	buffer.append(s, src, limit);
	}

	// Very similar to composeQuickCheck(): Make the same changes in both places if relevant.
	// doCompose: normalize
	// !doCompose: isNormalized (buffer must be empty and initialized)
	public boolean compose(CharSequence s, int src, int limit,
	boolean onlyContiguous,
	boolean doCompose,
	ReorderingBuffer buffer) {
	int prevBoundary=src;
	int minNoMaybeCP=minCompNoMaybeCP;

	for (;;) {
	// Fast path: Scan over a sequence of characters below the minimum "no or maybe" code point,
	// or with (compYes && ccc==0) properties.
	int prevSrc;
	int c = 0;
	int norm16 = 0;
	for (;;) {
	if (src == limit) {
	if (prevBoundary != limit && doCompose) {
	buffer.append(s, prevBoundary, limit);
	}
	return true;
	}
	if( (c=s.charAt(src))<minNoMaybeCP \|\|
	isCompYesAndZeroCC(norm16=normTrie.bmpGet(c))
	) {
	++src;
	} else {
	prevSrc = src++;
	if (!UTF16Plus.isLeadSurrogate(c)) {
	break;
	} else {
	char c2;
	if (src != limit && Character.isLowSurrogate(c2 = s.charAt(src))) {
	++src;
	c = Character.toCodePoint((char)c, c2);
	norm16 = normTrie.suppGet(c);
	if (!isCompYesAndZeroCC(norm16)) {
	break;
	}
	}
	}
	}
	}
	// isCompYesAndZeroCC(norm16) is false, that is, norm16>=minNoNo.
	// The current character is either a "noNo" (has a mapping)
	// or a "maybeYes" (combines backward)
	// or a "yesYes" with ccc!=0.
	// It is not a Hangul syllable or Jamo L because those have "yes" properties.

	// Medium-fast path: Handle cases that do not require full decomposition and recomposition.
	if (!isMaybeOrNonZeroCC(norm16)) { // minNoNo <= norm16 < minMaybeYes
	if (!doCompose) {
	return false;
	}
	// Fast path for mapping a character that is immediately surrounded by boundaries.
	// In this case, we need not decompose around the current character.
	if (isDecompNoAlgorithmic(norm16)) {
	// Maps to a single isCompYesAndZeroCC character
	// which also implies hasCompBoundaryBefore.
	if (norm16HasCompBoundaryAfter(norm16, onlyContiguous) \|\|
	hasCompBoundaryBefore(s, src, limit)) {
	if (prevBoundary != prevSrc) {
	buffer.append(s, prevBoundary, prevSrc);
	}
	buffer.append(mapAlgorithmic(c, norm16), 0);
	prevBoundary = src;
	continue;
	}
	} else if (norm16 < minNoNoCompBoundaryBefore) {
	// The mapping is comp-normalized which also implies hasCompBoundaryBefore.
	if (norm16HasCompBoundaryAfter(norm16, onlyContiguous) \|\|
	hasCompBoundaryBefore(s, src, limit)) {
	if (prevBoundary != prevSrc) {
	buffer.append(s, prevBoundary, prevSrc);
	}
	int mapping = norm16 >> OFFSET_SHIFT;
	int length = extraData.charAt(mapping++) & MAPPING_LENGTH_MASK;
	buffer.append(extraData, mapping, mapping + length);
	prevBoundary = src;
	continue;
	}
	} else if (norm16 >= minNoNoEmpty) {
	// The current character maps to nothing.
	// Simply omit it from the output if there is a boundary before _or_ after it.
	// The character itself implies no boundaries.
	if (hasCompBoundaryBefore(s, src, limit) \|\|
	hasCompBoundaryAfter(s, prevBoundary, prevSrc, onlyContiguous)) {
	if (prevBoundary != prevSrc) {
	buffer.append(s, prevBoundary, prevSrc);
	}
	prevBoundary = src;
	continue;
	}
	}
	// Other "noNo" type, or need to examine more text around this character:
	// Fall through to the slow path.
	} else if (isJamoVT(norm16) && prevBoundary != prevSrc) {
	char prev=s.charAt(prevSrc-1);
	if(c<Hangul.JAMO_T_BASE) {
	// The current character is a Jamo Vowel,
	// compose with previous Jamo L and following Jamo T.
	char l = (char)(prev-Hangul.JAMO_L_BASE);
	if(l<Hangul.JAMO_L_COUNT) {
	if (!doCompose) {
	return false;
	}
	int t;
	if (src != limit &&
	0 < (t = (s.charAt(src) - Hangul.JAMO_T_BASE)) &&
	t < Hangul.JAMO_T_COUNT) {
	// The next character is a Jamo T.
	++src;
	} else if (hasCompBoundaryBefore(s, src, limit)) {
	// No Jamo T follows, not even via decomposition.
	t = 0;
	} else {
	t = -1;
	}
	if (t >= 0) {
	int syllable = Hangul.HANGUL_BASE +
	(lHangul.JAMO_V_COUNT + (c-Hangul.JAMO_V_BASE))
	Hangul.JAMO_T_COUNT + t;
	--prevSrc; // Replace the Jamo L as well.
	if (prevBoundary != prevSrc) {
	buffer.append(s, prevBoundary, prevSrc);
	}
	buffer.append((char)syllable);
	prevBoundary = src;
	continue;
	}
	// If we see L+V+x where x!=T then we drop to the slow path,
	// decompose and recompose.
	// This is to deal with NFKC finding normal L and V but a
	// compatibility variant of a T.
	// We need to either fully compose that combination here
	// (which would complicate the code and may not work with strange custom data)
	// or use the slow path.
	}
	} else if (Hangul.isHangulLV(prev)) {
	// The current character is a Jamo Trailing consonant,
	// compose with previous Hangul LV that does not contain a Jamo T.
	if (!doCompose) {
	return false;
	}
	int syllable = prev + c - Hangul.JAMO_T_BASE;
	--prevSrc; // Replace the Hangul LV as well.
	if (prevBoundary != prevSrc) {
	buffer.append(s, prevBoundary, prevSrc);
	}
	buffer.append((char)syllable);
	prevBoundary = src;
	continue;
	}
	// No matching context, or may need to decompose surrounding text first:
	// Fall through to the slow path.
	} else if (norm16 > JAMO_VT) { // norm16 >= MIN_YES_YES_WITH_CC
	// One or more combining marks that do not combine-back:
	// Check for canonical order, copy unchanged if ok and
	// if followed by a character with a boundary-before.
	int cc = getCCFromNormalYesOrMaybe(norm16); // cc!=0
	if (onlyContiguous /* FCC */ && getPreviousTrailCC(s, prevBoundary, prevSrc) > cc) {
	// Fails FCD test, need to decompose and contiguously recompose.
	if (!doCompose) {
	return false;
	}
	} else {
	// If !onlyContiguous (not FCC), then we ignore the tccc of
	// the previous character which passed the quick check "yes && ccc==0" test.
	int n16;
	for (;;) {
	if (src == limit) {
	if (doCompose) {
	buffer.append(s, prevBoundary, limit);
	}
	return true;
	}
	int prevCC = cc;
	c = Character.codePointAt(s, src);
	n16 = normTrie.get(c);
	if (n16 >= MIN_YES_YES_WITH_CC) {
	cc = getCCFromNormalYesOrMaybe(n16);
	if (prevCC > cc) {
	if (!doCompose) {
	return false;
	}
	break;
	}
	} else {
	break;
	}
	src += Character.charCount(c);
	}
	// p is after the last in-order combining mark.
	// If there is a boundary here, then we continue with no change.
	if (norm16HasCompBoundaryBefore(n16)) {
	if (isCompYesAndZeroCC(n16)) {
	src += Character.charCount(c);
	}
	continue;
	}
	// Use the slow path. There is no boundary in [prevSrc, src[.
	}
	}

	// Slow path: Find the nearest boundaries around the current character,
	// decompose and recompose.
	if (prevBoundary != prevSrc && !norm16HasCompBoundaryBefore(norm16)) {
	c = Character.codePointBefore(s, prevSrc);
	norm16 = normTrie.get(c);
	if (!norm16HasCompBoundaryAfter(norm16, onlyContiguous)) {
	prevSrc -= Character.charCount(c);
	}
	}
	if (doCompose && prevBoundary != prevSrc) {
	buffer.append(s, prevBoundary, prevSrc);
	}
	int recomposeStartIndex=buffer.length();
	// We know there is not a boundary here.
	decomposeShort(s, prevSrc, src, false /* !stopAtCompBoundary */, onlyContiguous,
	buffer);
	// Decompose until the next boundary.
	src = decomposeShort(s, src, limit, true /* stopAtCompBoundary */, onlyContiguous,
	buffer);
	recompose(buffer, recomposeStartIndex, onlyContiguous);
	if(!doCompose) {
	if(!buffer.equals(s, prevSrc, src)) {
	return false;
	}
	buffer.remove();
	}
	prevBoundary=src;
	}
	}

	/**
	* Very similar to compose(): Make the same changes in both places if relevant.
	* doSpan: spanQuickCheckYes (ignore bit 0 of the return value)
	* !doSpan: quickCheck
	* @return bits 31..1: spanQuickCheckYes (==s.length() if "yes") and
	* bit 0: set if "maybe"; otherwise, if the span length<s.length()
	* then the quick check result is "no"
	*/
	public int composeQuickCheck(CharSequence s, int src, int limit,
	boolean onlyContiguous, boolean doSpan) {
	int qcResult=0;
	int prevBoundary=src;
	int minNoMaybeCP=minCompNoMaybeCP;

	for(;;) {
	// Fast path: Scan over a sequence of characters below the minimum "no or maybe" code point,
	// or with (compYes && ccc==0) properties.
	int prevSrc;
	int c = 0;
	int norm16 = 0;
	for (;;) {
	if(src==limit) {
	return (src<<1)\|qcResult; // "yes" or "maybe"
	}
	if( (c=s.charAt(src))<minNoMaybeCP \|\|
	isCompYesAndZeroCC(norm16=normTrie.bmpGet(c))
	) {
	++src;
	} else {
	prevSrc = src++;
	if (!UTF16Plus.isLeadSurrogate(c)) {
	break;
	} else {
	char c2;
	if (src != limit && Character.isLowSurrogate(c2 = s.charAt(src))) {
	++src;
	c = Character.toCodePoint((char)c, c2);
	norm16 = normTrie.suppGet(c);
	if (!isCompYesAndZeroCC(norm16)) {
	break;
	}
	}
	}
	}
	}
	// isCompYesAndZeroCC(norm16) is false, that is, norm16>=minNoNo.
	// The current character is either a "noNo" (has a mapping)
	// or a "maybeYes" (combines backward)
	// or a "yesYes" with ccc!=0.
	// It is not a Hangul syllable or Jamo L because those have "yes" properties.

	int prevNorm16 = INERT;
	if (prevBoundary != prevSrc) {
	prevBoundary = prevSrc;
	if (!norm16HasCompBoundaryBefore(norm16)) {
	c = Character.codePointBefore(s, prevSrc);
	int n16 = getNorm16(c);
	if (!norm16HasCompBoundaryAfter(n16, onlyContiguous)) {
	prevBoundary -= Character.charCount(c);
	prevNorm16 = n16;
	}
	}
	}

	if(isMaybeOrNonZeroCC(norm16)) {
	int cc=getCCFromYesOrMaybe(norm16);
	if (onlyContiguous /* FCC */ && cc != 0 &&
	getTrailCCFromCompYesAndZeroCC(prevNorm16) > cc) {
	// The [prevBoundary..prevSrc[ character
	// passed the quick check "yes && ccc==0" test
	// but is out of canonical order with the current combining mark.
	} else {
	// If !onlyContiguous (not FCC), then we ignore the tccc of
	// the previous character which passed the quick check "yes && ccc==0" test.
	for (;;) {
	if (norm16 < MIN_YES_YES_WITH_CC) {
	if (!doSpan) {
	qcResult = 1;
	} else {
	return prevBoundary << 1; // spanYes does not care to know it's "maybe"
	}
	}
	if (src == limit) {
	return (src<<1) \| qcResult; // "yes" or "maybe"
	}
	int prevCC = cc;
	c = Character.codePointAt(s, src);
	norm16 = getNorm16(c);
	if (isMaybeOrNonZeroCC(norm16)) {
	cc = getCCFromYesOrMaybe(norm16);
	if (!(prevCC <= cc \|\| cc == 0)) {
	break;
	}
	} else {
	break;
	}
	src += Character.charCount(c);
	}
	// src is after the last in-order combining mark.
	if (isCompYesAndZeroCC(norm16)) {
	prevBoundary = src;
	src += Character.charCount(c);
	continue;
	}
	}
	}
	return prevBoundary<<1; // "no"
	}
	}
	public void composeAndAppend(CharSequence s,
	boolean doCompose,
	boolean onlyContiguous,
	ReorderingBuffer buffer) {
	int src=0, limit=s.length();
	if(!buffer.isEmpty()) {
	int firstStarterInSrc=findNextCompBoundary(s, 0, limit, onlyContiguous);
	if(0!=firstStarterInSrc) {
	int lastStarterInDest=findPreviousCompBoundary(buffer.getStringBuilder(),
	buffer.length(), onlyContiguous);
	StringBuilder middle=new StringBuilder((buffer.length()-lastStarterInDest)+
	firstStarterInSrc+16);
	middle.append(buffer.getStringBuilder(), lastStarterInDest, buffer.length());
	buffer.removeSuffix(buffer.length()-lastStarterInDest);
	middle.append(s, 0, firstStarterInSrc);
	compose(middle, 0, middle.length(), onlyContiguous, true, buffer);
	src=firstStarterInSrc;
	}
	}
	if(doCompose) {
	compose(s, src, limit, onlyContiguous, true, buffer);
	} else {
	buffer.append(s, src, limit);
	}
	}
	// Dual functionality:
	// buffer!=NULL: normalize
	// buffer==NULL: isNormalized/quickCheck/spanQuickCheckYes
	public int makeFCD(CharSequence s, int src, int limit, ReorderingBuffer buffer) {
	// Note: In this function we use buffer->appendZeroCC() because we track
	// the lead and trail combining classes here, rather than leaving it to
	// the ReorderingBuffer.
	// The exception is the call to decomposeShort() which uses the buffer
	// in the normal way.

	// Tracks the last FCD-safe boundary, before lccc=0 or after properly-ordered tccc<=1.
	// Similar to the prevBoundary in the compose() implementation.
	int prevBoundary=src;
	int prevSrc;
	int c=0;
	int prevFCD16=0;
	int fcd16=0;

	for(;;) {
	// count code units with lccc==0
	for(prevSrc=src; src!=limit;) {
	if((c=s.charAt(src))<minLcccCP) {
	prevFCD16=~c;
	++src;
	} else if(!singleLeadMightHaveNonZeroFCD16(c)) {
	prevFCD16=0;
	++src;
	} else {
	if (UTF16Plus.isLeadSurrogate(c)) {
	char c2;
	if ((src + 1) != limit && Character.isLowSurrogate(c2 = s.charAt(src + 1))) {
	c = Character.toCodePoint((char)c, c2);
	}
	}
	if((fcd16=getFCD16FromNormData(c))<=0xff) {
	prevFCD16=fcd16;
	src+=Character.charCount(c);
	} else {
	break;
	}
	}
	}
	// copy these code units all at once
	if(src!=prevSrc) {
	if(src==limit) {
	if(buffer!=null) {
	buffer.flushAndAppendZeroCC(s, prevSrc, src);
	}
	break;
	}
	prevBoundary=src;
	// We know that the previous character's lccc==0.
	if(prevFCD16<0) {
	// Fetching the fcd16 value was deferred for this below-minLcccCP code point.
	int prev=~prevFCD16;
	if(prev<minDecompNoCP) {
	prevFCD16=0;
	} else {
	prevFCD16=getFCD16FromNormData(prev);
	if(prevFCD16>1) {
	--prevBoundary;
	}
	}
	} else {
	int p=src-1;
	if( Character.isLowSurrogate(s.charAt(p)) && prevSrc<p &&
	Character.isHighSurrogate(s.charAt(p-1))
	) {
	--p;
	// Need to fetch the previous character's FCD value because
	// prevFCD16 was just for the trail surrogate code point.
	prevFCD16=getFCD16FromNormData(Character.toCodePoint(s.charAt(p), s.charAt(p+1)));
	// Still known to have lccc==0 because its lead surrogate unit had lccc==0.
	}
	if(prevFCD16>1) {
	prevBoundary=p;
	}
	}
	if(buffer!=null) {
	// The last lccc==0 character is excluded from the
	// flush-and-append call in case it needs to be modified.
	buffer.flushAndAppendZeroCC(s, prevSrc, prevBoundary);
	buffer.append(s, prevBoundary, src);
	}
	// The start of the current character (c).
	prevSrc=src;
	} else if(src==limit) {
	break;
	}

	src+=Character.charCount(c);
	// The current character (c) at [prevSrc..src[ has a non-zero lead combining class.
	// Check for proper order, and decompose locally if necessary.
	if((prevFCD16&0xff)<=(fcd16>>8)) {
	// proper order: prev tccc <= current lccc
	if((fcd16&0xff)<=1) {
	prevBoundary=src;
	}
	if(buffer!=null) {
	buffer.appendZeroCC(c);
	}
	prevFCD16=fcd16;
	continue;
	} else if(buffer==null) {
	return prevBoundary; // quick check "no"
	} else {
	/*
	* Back out the part of the source that we copied or appended
	* already but is now going to be decomposed.
	* prevSrc is set to after what was copied/appended.
	*/
	buffer.removeSuffix(prevSrc-prevBoundary);
	/*
	* Find the part of the source that needs to be decomposed,
	* up to the next safe boundary.
	*/
	src=findNextFCDBoundary(s, src, limit);
	/*
	* The source text does not fulfill the conditions for FCD.
	* Decompose and reorder a limited piece of the text.
	*/
	decomposeShort(s, prevBoundary, src, false, false, buffer);
	prevBoundary=src;
	prevFCD16=0;
	}
	}
	return src;
	}

	public boolean hasDecompBoundaryBefore(int c) {
	return c < minLcccCP \|\| (c <= 0xffff && !singleLeadMightHaveNonZeroFCD16(c)) \|\|
	norm16HasDecompBoundaryBefore(getNorm16(c));
	}
	public boolean norm16HasDecompBoundaryBefore(int norm16) {
	if (norm16 < minNoNoCompNoMaybeCC) {
	return true;
	}
	if (norm16 >= limitNoNo) {
	return norm16 <= MIN_NORMAL_MAYBE_YES \|\| norm16 == JAMO_VT;
	}
	// c decomposes, get everything from the variable-length extra data
	int mapping=norm16>>OFFSET_SHIFT;
	int firstUnit=extraData.charAt(mapping);
	// true if leadCC==0 (hasFCDBoundaryBefore())
	return (firstUnit&MAPPING_HAS_CCC_LCCC_WORD)==0 \|\| (extraData.charAt(mapping-1)&0xff00)==0;
	}
	public boolean hasDecompBoundaryAfter(int c) {
	if (c < minDecompNoCP) {
	return true;
	}
	if (c <= 0xffff && !singleLeadMightHaveNonZeroFCD16(c)) {
	return true;
	}
	return norm16HasDecompBoundaryAfter(getNorm16(c));
	}
	public boolean norm16HasDecompBoundaryAfter(int norm16) {
	if(norm16 <= minYesNo \|\| isHangulLVT(norm16)) {
	return true;
	}
	if (norm16 >= limitNoNo) {
	if (isMaybeOrNonZeroCC(norm16)) {
	return norm16 <= MIN_NORMAL_MAYBE_YES \|\| norm16 == JAMO_VT;
	}
	// Maps to an isCompYesAndZeroCC.
	return (norm16 & DELTA_TCCC_MASK) <= DELTA_TCCC_1;
	}
	// c decomposes, get everything from the variable-length extra data
	int mapping=norm16>>OFFSET_SHIFT;
	int firstUnit=extraData.charAt(mapping);
	// decomp after-boundary: same as hasFCDBoundaryAfter(),
	// fcd16<=1 \|\| trailCC==0
	if(firstUnit>0x1ff) {
	return false; // trailCC>1
	}
	if(firstUnit<=0xff) {
	return true; // trailCC==0
	}
	// if(trailCC==1) test leadCC==0, same as checking for before-boundary
	// true if leadCC==0 (hasFCDBoundaryBefore())
	return (firstUnit&MAPPING_HAS_CCC_LCCC_WORD)==0 \|\| (extraData.charAt(mapping-1)&0xff00)==0;
	}
	public boolean isDecompInert(int c) { return isDecompYesAndZeroCC(getNorm16(c)); }

	public boolean hasCompBoundaryBefore(int c) {
	return c<minCompNoMaybeCP \|\| norm16HasCompBoundaryBefore(getNorm16(c));
	}
	public boolean hasCompBoundaryAfter(int c, boolean onlyContiguous) {
	return norm16HasCompBoundaryAfter(getNorm16(c), onlyContiguous);
	}

	private boolean isMaybe(int norm16) { return minMaybeYes<=norm16 && norm16<=JAMO_VT; }
	private boolean isMaybeOrNonZeroCC(int norm16) { return norm16>=minMaybeYes; }
	private static boolean isInert(int norm16) { return norm16==INERT; }
	private static boolean isJamoVT(int norm16) { return norm16==JAMO_VT; }
	private int hangulLVT() { return minYesNoMappingsOnly\|HAS_COMP_BOUNDARY_AFTER; }
	private boolean isHangulLV(int norm16) { return norm16==minYesNo; }
	private boolean isHangulLVT(int norm16) {
	return norm16==hangulLVT();
	}
	private boolean isCompYesAndZeroCC(int norm16) { return norm16<minNoNo; }
	// UBool isCompYes(uint16_t norm16) const {
	// return norm16>=MIN_YES_YES_WITH_CC \|\| norm16<minNoNo;
	// }
	// UBool isCompYesOrMaybe(uint16_t norm16) const {
	// return norm16<minNoNo \|\| minMaybeYes<=norm16;
	// }
	// private boolean hasZeroCCFromDecompYes(int norm16) {
	// return norm16<=MIN_NORMAL_MAYBE_YES \|\| norm16==JAMO_VT;
	// }
	private boolean isDecompYesAndZeroCC(int norm16) {
	return norm16<minYesNo \|\|
	norm16==JAMO_VT \|\|
	(minMaybeYes<=norm16 && norm16<=MIN_NORMAL_MAYBE_YES);
	}
	/**
	* A little faster and simpler than isDecompYesAndZeroCC() but does not include
	* the MaybeYes which combine-forward and have ccc=0.
	* (Standard Unicode 10 normalization does not have such characters.)
	*/
	private boolean isMostDecompYesAndZeroCC(int norm16) {
	return norm16<minYesNo \|\| norm16==MIN_NORMAL_MAYBE_YES \|\| norm16==JAMO_VT;
	}
	private boolean isDecompNoAlgorithmic(int norm16) { return norm16>=limitNoNo; }

	// For use with isCompYes().
	// Perhaps the compiler can combine the two tests for MIN_YES_YES_WITH_CC.
	// static uint8_t getCCFromYes(uint16_t norm16) {
	// return norm16>=MIN_YES_YES_WITH_CC ? getCCFromNormalYesOrMaybe(norm16) : 0;
	// }
	private int getCCFromNoNo(int norm16) {
	int mapping=norm16>>OFFSET_SHIFT;
	if((extraData.charAt(mapping)&MAPPING_HAS_CCC_LCCC_WORD)!=0) {
	return extraData.charAt(mapping-1)&0xff;
	} else {
	return 0;
	}
	}
	int getTrailCCFromCompYesAndZeroCC(int norm16) {
	if(norm16<=minYesNo) {
	return 0; // yesYes and Hangul LV have ccc=tccc=0
	} else {
	// For Hangul LVT we harmlessly fetch a firstUnit with tccc=0 here.
	return extraData.charAt(norm16>>OFFSET_SHIFT)>>8; // tccc from yesNo
	}
	}

	// Requires algorithmic-NoNo.
	private int mapAlgorithmic(int c, int norm16) {
	return c+(norm16>>DELTA_SHIFT)-centerNoNoDelta;
	}

	// Requires minYesNo<norm16<limitNoNo.
	// private int getMapping(int norm16) { return extraData+(norm16>>OFFSET_SHIFT); }

	/**
	* @return index into maybeYesCompositions, or -1
	*/
	private int getCompositionsListForDecompYes(int norm16) {
	if(norm16<JAMO_L \|\| MIN_NORMAL_MAYBE_YES<=norm16) {
	return -1;
	} else {
	if((norm16-=minMaybeYes)<0) {
	// norm16<minMaybeYes: index into extraData which is a substring at
	// maybeYesCompositions[MIN_NORMAL_MAYBE_YES-minMaybeYes]
	// same as (MIN_NORMAL_MAYBE_YES-minMaybeYes)+norm16
	norm16+=MIN_NORMAL_MAYBE_YES; // for yesYes; if Jamo L: harmless empty list
	}
	return norm16>>OFFSET_SHIFT;
	}
	}
	/**
	* @return index into maybeYesCompositions
	*/
	private int getCompositionsListForComposite(int norm16) {
	// A composite has both mapping & compositions list.
	int list=((MIN_NORMAL_MAYBE_YES-minMaybeYes)+norm16)>>OFFSET_SHIFT;
	int firstUnit=maybeYesCompositions.charAt(list);
	return list+ // mapping in maybeYesCompositions
	1+ // +1 to skip the first unit with the mapping length
	(firstUnit&MAPPING_LENGTH_MASK); // + mapping length
	}

	// Decompose a short piece of text which is likely to contain characters that
	// fail the quick check loop and/or where the quick check loop's overhead
	// is unlikely to be amortized.
	// Called by the compose() and makeFCD() implementations.
	// Public in Java for collation implementation code.
	private int decomposeShort(
	CharSequence s, int src, int limit,
	boolean stopAtCompBoundary, boolean onlyContiguous,
	ReorderingBuffer buffer) {
	while(src<limit) {
	int c=Character.codePointAt(s, src);
	if (stopAtCompBoundary && c < minCompNoMaybeCP) {
	return src;
	}
	int norm16 = getNorm16(c);
	if (stopAtCompBoundary && norm16HasCompBoundaryBefore(norm16)) {
	return src;
	}
	src+=Character.charCount(c);
	decompose(c, norm16, buffer);
	if (stopAtCompBoundary && norm16HasCompBoundaryAfter(norm16, onlyContiguous)) {
	return src;
	}
	}
	return src;
	}
	private void decompose(int c, int norm16, ReorderingBuffer buffer) {
	// get the decomposition and the lead and trail cc's
	if (norm16 >= limitNoNo) {
	if (isMaybeOrNonZeroCC(norm16)) {
	buffer.append(c, getCCFromYesOrMaybe(norm16));
	return;
	}
	// Maps to an isCompYesAndZeroCC.
	c=mapAlgorithmic(c, norm16);
	norm16=getRawNorm16(c);
	}
	if (norm16 < minYesNo) {
	// c does not decompose
	buffer.append(c, 0);
	} else if(isHangulLV(norm16) \|\| isHangulLVT(norm16)) {
	// Hangul syllable: decompose algorithmically
	Hangul.decompose(c, buffer);
	} else {
	// c decomposes, get everything from the variable-length extra data
	int mapping=norm16>>OFFSET_SHIFT;
	int firstUnit=extraData.charAt(mapping);
	int length=firstUnit&MAPPING_LENGTH_MASK;
	int leadCC, trailCC;
	trailCC=firstUnit>>8;
	if((firstUnit&MAPPING_HAS_CCC_LCCC_WORD)!=0) {
	leadCC=extraData.charAt(mapping-1)>>8;
	} else {
	leadCC=0;
	}
	++mapping; // skip over the firstUnit
	buffer.append(extraData, mapping, mapping+length, true, leadCC, trailCC);
	}
	}

	/**
	* Finds the recomposition result for
	* a forward-combining "lead" character,
	* specified with a pointer to its compositions list,
	* and a backward-combining "trail" character.
	*
	* <p>If the lead and trail characters combine, then this function returns
	* the following "compositeAndFwd" value:
	* <pre>
	* Bits 21..1 composite character
	* Bit 0 set if the composite is a forward-combining starter
	* </pre>
	* otherwise it returns -1.
	*
	* <p>The compositions list has (trail, compositeAndFwd) pair entries,
	* encoded as either pairs or triples of 16-bit units.
	* The last entry has the high bit of its first unit set.
	*
	* <p>The list is sorted by ascending trail characters (there are no duplicates).
	* A linear search is used.
	*
	* <p>See normalizer2impl.h for a more detailed description
	* of the compositions list format.
	*/
	private static int combine(String compositions, int list, int trail) {
	int key1, firstUnit;
	if(trail<COMP_1_TRAIL_LIMIT) {
	// trail character is 0..33FF
	// result entry may have 2 or 3 units
	key1=(trail<<1);
	while(key1>(firstUnit=compositions.charAt(list))) {
	list+=2+(firstUnit&COMP_1_TRIPLE);
	}
	if(key1==(firstUnit&COMP_1_TRAIL_MASK)) {
	if((firstUnit&COMP_1_TRIPLE)!=0) {
	return (compositions.charAt(list+1)<<16)\|compositions.charAt(list+2);
	} else {
	return compositions.charAt(list+1);
	}
	}
	} else {
	// trail character is 3400..10FFFF
	// result entry has 3 units
	key1=COMP_1_TRAIL_LIMIT+(((trail>>COMP_1_TRAIL_SHIFT))&~COMP_1_TRIPLE);
	int key2=(trail<<COMP_2_TRAIL_SHIFT)&0xffff;
	int secondUnit;
	for(;;) {
	if(key1>(firstUnit=compositions.charAt(list))) {
	list+=2+(firstUnit&COMP_1_TRIPLE);
	} else if(key1==(firstUnit&COMP_1_TRAIL_MASK)) {
	if(key2>(secondUnit=compositions.charAt(list+1))) {
	if((firstUnit&COMP_1_LAST_TUPLE)!=0) {
	break;
	} else {
	list+=3;
	}
	} else if(key2==(secondUnit&COMP_2_TRAIL_MASK)) {
	return ((secondUnit&~COMP_2_TRAIL_MASK)<<16)\|compositions.charAt(list+2);
	} else {
	break;
	}
	} else {
	break;
	}
	}
	}
	return -1;
	}

	/*
	* Recomposes the buffer text starting at recomposeStartIndex
	* (which is in NFD - decomposed and canonically ordered),
	* and truncates the buffer contents.
	*
	* Note that recomposition never lengthens the text:
	* Any character consists of either one or two code units;
	* a composition may contain at most one more code unit than the original starter,
	* while the combining mark that is removed has at least one code unit.
	*/
	private void recompose(ReorderingBuffer buffer, int recomposeStartIndex,
	boolean onlyContiguous) {
	StringBuilder sb=buffer.getStringBuilder();
	int p=recomposeStartIndex;
	if(p==sb.length()) {
	return;
	}

	int starter, pRemove;
	int compositionsList;
	int c, compositeAndFwd;
	int norm16;
	int cc, prevCC;
	boolean starterIsSupplementary;

	// Some of the following variables are not used until we have a forward-combining starter
	// and are only initialized now to avoid compiler warnings.
	compositionsList=-1; // used as indicator for whether we have a forward-combining starter
	starter=-1;
	starterIsSupplementary=false;
	prevCC=0;

	for(;;) {
	c=sb.codePointAt(p);
	p+=Character.charCount(c);
	norm16=getNorm16(c);
	cc=getCCFromYesOrMaybe(norm16);
	if( // this character combines backward and
	isMaybe(norm16) &&
	// we have seen a starter that combines forward and
	compositionsList>=0 &&
	// the backward-combining character is not blocked
	(prevCC<cc \|\| prevCC==0)
	) {
	if(isJamoVT(norm16)) {
	// c is a Jamo V/T, see if we can compose it with the previous character.
	if(c<Hangul.JAMO_T_BASE) {
	// c is a Jamo Vowel, compose with previous Jamo L and following Jamo T.
	char prev=(char)(sb.charAt(starter)-Hangul.JAMO_L_BASE);
	if(prev<Hangul.JAMO_L_COUNT) {
	pRemove=p-1;
	char syllable=(char)
	(Hangul.HANGUL_BASE+
	(prevHangul.JAMO_V_COUNT+(c-Hangul.JAMO_V_BASE))
	Hangul.JAMO_T_COUNT);
	char t;
	if(p!=sb.length() && (t=(char)(sb.charAt(p)-Hangul.JAMO_T_BASE))<Hangul.JAMO_T_COUNT) {
	++p;
	syllable+=t; // The next character was a Jamo T.
	}
	sb.setCharAt(starter, syllable);
	// remove the Jamo V/T
	sb.delete(pRemove, p);
	p=pRemove;
	}
	}
	/*
	* No "else" for Jamo T:
	* Since the input is in NFD, there are no Hangul LV syllables that
	* a Jamo T could combine with.
	* All Jamo Ts are combined above when handling Jamo Vs.
	*/
	if(p==sb.length()) {
	break;
	}
	compositionsList=-1;
	continue;
	} else if((compositeAndFwd=combine(maybeYesCompositions, compositionsList, c))>=0) {
	// The starter and the combining mark (c) do combine.
	int composite=compositeAndFwd>>1;

	// Remove the combining mark.
	pRemove=p-Character.charCount(c); // pRemove & p: start & limit of the combining mark
	sb.delete(pRemove, p);
	p=pRemove;
	// Replace the starter with the composite.
	if(starterIsSupplementary) {
	if(composite>0xffff) {
	// both are supplementary
	sb.setCharAt(starter, UTF16.getLeadSurrogate(composite));
	sb.setCharAt(starter+1, UTF16.getTrailSurrogate(composite));
	} else {
	sb.setCharAt(starter, (char)c);
	sb.deleteCharAt(starter+1);
	// The composite is shorter than the starter,
	// move the intermediate characters forward one.
	starterIsSupplementary=false;
	--p;
	}
	} else if(composite>0xffff) {
	// The composite is longer than the starter,
	// move the intermediate characters back one.
	starterIsSupplementary=true;
	sb.setCharAt(starter, UTF16.getLeadSurrogate(composite));
	sb.insert(starter+1, UTF16.getTrailSurrogate(composite));
	++p;
	} else {
	// both are on the BMP
	sb.setCharAt(starter, (char)composite);
	}

	// Keep prevCC because we removed the combining mark.

	if(p==sb.length()) {
	break;
	}
	// Is the composite a starter that combines forward?
	if((compositeAndFwd&1)!=0) {
	compositionsList=
	getCompositionsListForComposite(getRawNorm16(composite));
	} else {
	compositionsList=-1;
	}

	// We combined; continue with looking for compositions.
	continue;
	}
	}

	// no combination this time
	prevCC=cc;
	if(p==sb.length()) {
	break;
	}

	// If c did not combine, then check if it is a starter.
	if(cc==0) {
	// Found a new starter.
	if((compositionsList=getCompositionsListForDecompYes(norm16))>=0) {
	// It may combine with something, prepare for it.
	if(c<=0xffff) {
	starterIsSupplementary=false;
	starter=p-1;
	} else {
	starterIsSupplementary=true;
	starter=p-2;
	}
	}
	} else if(onlyContiguous) {
	// FCC: no discontiguous compositions; any intervening character blocks.
	compositionsList=-1;
	}
	}
	buffer.flush();
	}

	/**
	* Does c have a composition boundary before it?
	* True if its decomposition begins with a character that has
	* ccc=0 && NFC_QC=Yes (isCompYesAndZeroCC()).
	* As a shortcut, this is true if c itself has ccc=0 && NFC_QC=Yes
	* (isCompYesAndZeroCC()) so we need not decompose.
	*/
	private boolean hasCompBoundaryBefore(int c, int norm16) {
	return c<minCompNoMaybeCP \|\| norm16HasCompBoundaryBefore(norm16);
	}
	private boolean norm16HasCompBoundaryBefore(int norm16) {
	return norm16 < minNoNoCompNoMaybeCC \|\| isAlgorithmicNoNo(norm16);
	}
	private boolean hasCompBoundaryBefore(CharSequence s, int src, int limit) {
	return src == limit \|\| hasCompBoundaryBefore(Character.codePointAt(s, src));
	}
	private boolean norm16HasCompBoundaryAfter(int norm16, boolean onlyContiguous) {
	return (norm16 & HAS_COMP_BOUNDARY_AFTER) != 0 &&
	(!onlyContiguous \|\| isTrailCC01ForCompBoundaryAfter(norm16));
	}
	private boolean hasCompBoundaryAfter(CharSequence s, int start, int p, boolean onlyContiguous) {
	return start == p \|\| hasCompBoundaryAfter(Character.codePointBefore(s, p), onlyContiguous);
	}
	/** For FCC: Given norm16 HAS_COMP_BOUNDARY_AFTER, does it have tccc<=1? */
	private boolean isTrailCC01ForCompBoundaryAfter(int norm16) {
	return isInert(norm16) \|\| (isDecompNoAlgorithmic(norm16) ?
	(norm16 & DELTA_TCCC_MASK) <= DELTA_TCCC_1 : extraData.charAt(norm16 >> OFFSET_SHIFT) <= 0x1ff);
	}

	private int findPreviousCompBoundary(CharSequence s, int p, boolean onlyContiguous) {
	while(p>0) {
	int c=Character.codePointBefore(s, p);
	int norm16 = getNorm16(c);
	if (norm16HasCompBoundaryAfter(norm16, onlyContiguous)) {
	break;
	}
	p-=Character.charCount(c);
	if(hasCompBoundaryBefore(c, norm16)) {
	break;
	}
	}
	return p;
	}
	private int findNextCompBoundary(CharSequence s, int p, int limit, boolean onlyContiguous) {
	while(p<limit) {
	int c=Character.codePointAt(s, p);
	int norm16=normTrie.get(c);
	if(hasCompBoundaryBefore(c, norm16)) {
	break;
	}
	p+=Character.charCount(c);
	if (norm16HasCompBoundaryAfter(norm16, onlyContiguous)) {
	break;
	}
	}
	return p;
	}


	private int findNextFCDBoundary(CharSequence s, int p, int limit) {
	while(p<limit) {
	int c=Character.codePointAt(s, p);
	int norm16;
	if (c < minLcccCP \|\| norm16HasDecompBoundaryBefore(norm16 = getNorm16(c))) {
	break;
	}
	p+=Character.charCount(c);
	if (norm16HasDecompBoundaryAfter(norm16)) {
	break;
	}
	}
	return p;
	}

	/**
	* Get the canonical decomposition
	* sherman for ComposedCharIter
	*/
	public static int getDecompose(int chars[], String decomps[]) {
	Normalizer2 impl = Normalizer2.getNFDInstance();

	int length=0;
	int norm16 = 0;
	int ch = -1;
	int i = 0;

	while (++ch < 0x2fa1e) { //no cannoical above 0x3ffff
	//TBD !!!! the hack code heres save us about 50ms for startup
	//need a better solution/lookup
	if (ch == 0x30ff)
	ch = 0xf900;
	else if (ch == 0x115bc)
	ch = 0x1d15e;
	else if (ch == 0x1d1c1)
	ch = 0x2f800;

	String s = impl.getDecomposition(ch);

	if(s != null && i < chars.length) {
	chars[i] = ch;
	decomps[i++] = s;
	}
	}
	return i;
	}

	//------------------------------------------------------
	// special method for Collation (RBTableBuilder.build())
	//------------------------------------------------------
	private static boolean needSingleQuotation(char c) {
	return (c >= 0x0009 && c <= 0x000D) \|\|
	(c >= 0x0020 && c <= 0x002F) \|\|
	(c >= 0x003A && c <= 0x0040) \|\|
	(c >= 0x005B && c <= 0x0060) \|\|
	(c >= 0x007B && c <= 0x007E);
	}

	public static String canonicalDecomposeWithSingleQuotation(String string) {
	Normalizer2 impl = Normalizer2.getNFDInstance();
	char[] src = string.toCharArray();
	int srcIndex = 0;
	int srcLimit = src.length;
	char[] dest = new char[src.length * 3]; //MAX_BUF_SIZE_DECOMPOSE = 3
	int destIndex = 0;
	int destLimit = dest.length;

	int prevSrc;
	String norm;
	int reorderStartIndex, length;
	char c1, c2;
	int cp;
	int minNoMaybe = 0x00c0;
	int cc, prevCC, trailCC;
	char[] p;
	int pStart;

	// initialize
	reorderStartIndex = 0;
	prevCC = 0;
	norm = null;
	cp = 0;
	pStart = 0;

	cc = trailCC = -1; // initialize to bogus value
	c1 = 0;
	for (;;) {
	prevSrc=srcIndex;
	//quick check (1)less than minNoMaybe (2)no decomp (3)hangual
	while (srcIndex != srcLimit &&
	((c1 = src[srcIndex]) < minNoMaybe \|\|
	(norm = impl.getDecomposition(cp = string.codePointAt(srcIndex))) == null \|\|
	(c1 >= '\uac00' && c1 <= '\ud7a3'))) { // Hangul Syllables
	prevCC = 0;
	srcIndex += (cp < 0x10000) ? 1 : 2;
	}

	// copy these code units all at once
	if (srcIndex != prevSrc) {
	length = srcIndex - prevSrc;
	if ((destIndex + length) <= destLimit) {
	System.arraycopy(src,prevSrc,dest,destIndex,length);
	}

	destIndex += length;
	reorderStartIndex = destIndex;
	}

	// end of source reached?
	if (srcIndex == srcLimit) {
	break;
	}

	// cp already contains *src and norm32 is set for it, increment src
	srcIndex += (cp < 0x10000) ? 1 : 2;

	if (cp < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
	c2 = 0;
	length = 1;

	if (Character.isHighSurrogate(c1)
	\|\| Character.isLowSurrogate(c1)) {
	norm = null;
	}
	} else {
	length = 2;
	c2 = src[srcIndex-1];
	}

	// get the decomposition and the lead and trail cc's
	if (norm == null) {
	// cp does not decompose
	cc = trailCC = UCharacter.getCombiningClass(cp);
	p = null;
	pStart = -1;
	} else {

	pStart = 0;
	p = norm.toCharArray();
	length = p.length;
	int cpNum = norm.codePointCount(0, length);
	cc= UCharacter.getCombiningClass(norm.codePointAt(0));
	trailCC= UCharacter.getCombiningClass(norm.codePointAt(cpNum-1));
	if (length == 1) {
	// fastpath a single code unit from decomposition
	c1 = p[pStart];
	c2 = 0;
	p = null;
	pStart = -1;
	}
	}

	if((destIndex + length * 3) >= destLimit) { // 2 SingleQuotations
	// buffer overflow
	char[] tmpBuf = new char[destLimit * 2];
	System.arraycopy(dest, 0, tmpBuf, 0, destIndex);
	dest = tmpBuf;
	destLimit = dest.length;
	}

	// append the decomposition to the destination buffer, assume length>0
	{
	int reorderSplit = destIndex;
	if (p == null) {
	// fastpath: single code point
	if (needSingleQuotation(c1)) {
	//if we need single quotation, no need to consider "prevCC"
	//and it must NOT be a supplementary pair
	dest[destIndex++] = '\'';
	dest[destIndex++] = c1;
	dest[destIndex++] = '\'';
	trailCC = 0;
	} else if(cc != 0 && cc < prevCC) {
	// (c1, c2) is out of order with respect to the preceding
	// text
	destIndex += length;
	trailCC = insertOrdered(dest, reorderStartIndex,
	reorderSplit, destIndex, c1, c2, cc);
	} else {
	// just append (c1, c2)
	dest[destIndex++] = c1;
	if(c2 != 0) {
	dest[destIndex++] = c2;
	}
	}
	} else {
	// general: multiple code points (ordered by themselves)
	// from decomposition
	if (needSingleQuotation(p[pStart])) {
	dest[destIndex++] = '\'';
	dest[destIndex++] = p[pStart++];
	dest[destIndex++] = '\'';
	length--;
	do {
	dest[destIndex++] = p[pStart++];
	} while(--length > 0);
	} else if (cc != 0 && cc < prevCC) {
	destIndex += length;
	trailCC = mergeOrdered(dest, reorderStartIndex,
	reorderSplit, p, pStart,
	pStart+length);
	} else {
	// just append the decomposition
	do {
	dest[destIndex++] = p[pStart++];
	} while (--length > 0);
	}
	}
	}
	prevCC = trailCC;
	if(prevCC == 0) {
	reorderStartIndex = destIndex;
	}
	}

	return new String(dest, 0, destIndex);
	}

	/**
	* simpler, single-character version of mergeOrdered() -
	* bubble-insert one single code point into the preceding string
	* which is already canonically ordered
	* (c, c2) may or may not yet have been inserted at src[current]..src[p]
	*
	* it must be p=current+lengthof(c, c2) i.e. p=current+(c2==0 ? 1 : 2)
	*
	* before: src[start]..src[current] is already ordered, and
	* src[current]..src[p] may or may not hold (c, c2) but
	* must be exactly the same length as (c, c2)
	* after: src[start]..src[p] is ordered
	*
	* @return the trailing combining class
	*/
	private static int/unsigned byte/ insertOrdered(char[] source,
	int start,
	int current, int p,
	char c1, char c2,
	int/unsigned byte/ cc) {
	int back, preBack;
	int r;
	int prevCC, trailCC=cc;

	if (start<current && cc!=0) {
	// search for the insertion point where cc>=prevCC
	preBack=back=current;

	PrevArgs prevArgs = new PrevArgs();
	prevArgs.current = current;
	prevArgs.start = start;
	prevArgs.src = source;
	prevArgs.c1 = c1;
	prevArgs.c2 = c2;

	// get the prevCC
	prevCC=getPrevCC(prevArgs);
	preBack = prevArgs.current;

	if(cc<prevCC) {
	// this will be the last code point, so keep its cc
	trailCC=prevCC;
	back=preBack;
	while(start<preBack) {
	prevCC=getPrevCC(prevArgs);
	preBack=prevArgs.current;
	if(cc>=prevCC) {
	break;
	}
	back=preBack;
	}

	// this is where we are right now with all these indicies:
	// [start]..[pPreBack] 0..? code points that we can ignore
	// [pPreBack]..[pBack] 0..1 code points with prevCC<=cc
	// [pBack]..[current] 0..n code points with >cc, move up to insert (c, c2)
	// [current]..[p] 1 code point (c, c2) with cc

	// move the code units in between up
	r=p;
	do {
	source[--r]=source[--current];
	} while (back!=current);
	}
	}

	// insert (c1, c2)
	source[current] = c1;
	if (c2!=0) {
	source[(current+1)] = c2;
	}

	// we know the cc of the last code point
	return trailCC;
	}
	/**
	* merge two UTF-16 string parts together
	* to canonically order (order by combining classes) their concatenation
	*
	* the two strings may already be adjacent, so that the merging is done
	* in-place if the two strings are not adjacent, then the buffer holding the
	* first one must be large enough
	* the second string may or may not be ordered in itself
	*
	* before: [start]..[current] is already ordered, and
	* [next]..[limit] may be ordered in itself, but
	* is not in relation to [start..current[
	* after: [start..current+(limit-next)[ is ordered
	*
	* the algorithm is a simple bubble-sort that takes the characters from
	* src[next++] and inserts them in correct combining class order into the
	* preceding part of the string
	*
	* since this function is called much less often than the single-code point
	* insertOrdered(), it just uses that for easier maintenance
	*
	* @return the trailing combining class
	*/
	private static int /unsigned byte/ mergeOrdered(char[] source,
	int start,
	int current,
	char[] data,
	int next,
	int limit) {
	int r;
	int /unsigned byte/ cc, trailCC=0;
	boolean adjacent;

	adjacent= current==next;
	NextCCArgs ncArgs = new NextCCArgs();
	ncArgs.source = data;
	ncArgs.next = next;
	ncArgs.limit = limit;

	if(start!=current) {

	while(ncArgs.next<ncArgs.limit) {
	cc=getNextCC(ncArgs);
	if(cc==0) {
	// does not bubble back
	trailCC=0;
	if(adjacent) {
	current=ncArgs.next;
	} else {
	data[current++]=ncArgs.c1;
	if(ncArgs.c2!=0) {
	data[current++]=ncArgs.c2;
	}
	}
	break;
	} else {
	r=current+(ncArgs.c2==0 ? 1 : 2);
	trailCC=insertOrdered(source,start, current, r,
	ncArgs.c1, ncArgs.c2, cc);
	current=r;
	}
	}
	}

	if(ncArgs.next==ncArgs.limit) {
	// we know the cc of the last code point
	return trailCC;
	} else {
	if(!adjacent) {
	// copy the second string part
	do {
	source[current++]=data[ncArgs.next++];
	} while(ncArgs.next!=ncArgs.limit);
	ncArgs.limit=current;
	}
	PrevArgs prevArgs = new PrevArgs();
	prevArgs.src = data;
	prevArgs.start = start;
	prevArgs.current = ncArgs.limit;
	return getPrevCC(prevArgs);
	}

	}
	private static final class PrevArgs{
	char[] src;
	int start;
	int current;
	char c1;
	char c2;
	}

	private static final class NextCCArgs{
	char[] source;
	int next;
	int limit;
	char c1;
	char c2;
	}
	private static int /unsigned byte/ getNextCC(NextCCArgs args) {
	args.c1=args.source[args.next++];
	args.c2=0;

	if (UTF16.isTrailSurrogate(args.c1)) {
	/* unpaired second surrogate */
	return 0;
	} else if (!UTF16.isLeadSurrogate(args.c1)) {
	return UCharacter.getCombiningClass(args.c1);
	} else if (args.next!=args.limit &&
	UTF16.isTrailSurrogate(args.c2=args.source[args.next])){
	++args.next;
	return UCharacter.getCombiningClass(Character.toCodePoint(args.c1, args.c2));
	} else {
	/* unpaired first surrogate */
	args.c2=0;
	return 0;
	}
	}
	private static int /unsigned/ getPrevCC(PrevArgs args) {
	args.c1=args.src[--args.current];
	args.c2=0;

	if (args.c1 < MIN_CCC_LCCC_CP) {
	return 0;
	} else if (UTF16.isLeadSurrogate(args.c1)) {
	/* unpaired first surrogate */
	return 0;
	} else if (!UTF16.isTrailSurrogate(args.c1)) {
	return UCharacter.getCombiningClass(args.c1);
	} else if (args.current!=args.start &&
	UTF16.isLeadSurrogate(args.c2=args.src[args.current-1])) {
	--args.current;
	return UCharacter.getCombiningClass(Character.toCodePoint(args.c2, args.c1));
	} else {
	/* unpaired second surrogate */
	args.c2=0;
	return 0;
	}
	}

	private int getPreviousTrailCC(CharSequence s, int start, int p) {
	if (start == p) {
	return 0;
	}
	return getFCD16(Character.codePointBefore(s, p));
	}

	private VersionInfo dataVersion;

	// BMP code point thresholds for quick check loops looking at single UTF-16 code units.
	private int minDecompNoCP;
	private int minCompNoMaybeCP;
	private int minLcccCP;

	// Norm16 value thresholds for quick check combinations and types of extra data.
	private int minYesNo;
	private int minYesNoMappingsOnly;
	private int minNoNo;
	private int minNoNoCompBoundaryBefore;
	private int minNoNoCompNoMaybeCC;
	private int minNoNoEmpty;
	private int limitNoNo;
	private int centerNoNoDelta;
	private int minMaybeYes;

	private CodePointTrie.Fast16 normTrie;
	private String maybeYesCompositions;
	private String extraData; // mappings and/or compositions for yesYes, yesNo & noNo characters
	private byte[] smallFCD; // [0x100] one bit per 32 BMP code points, set if any FCD!=0
	}

Back to index...