Back to index...

	/*
	* 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) 2003-2004, International Business Machines Corporation and *
	* others. All Rights Reserved. *
	*******************************************************************************
	*/
	//
	// CHANGELOG
	// 2005-05-19 Edward Wang
	// - copy this file from icu4jsrc_3_2/src/com/ibm/icu/text/Punycode.java
	// - move from package com.ibm.icu.text to package sun.net.idn
	// - use ParseException instead of StringPrepParseException
	// 2007-08-14 Martin Buchholz
	// - remove redundant casts
	//
	package sun.net.idn;

	import java.text.ParseException;
	import sun.text.normalizer.UCharacter;
	import sun.text.normalizer.UTF16;

	/**
	* Ported code from ICU punycode.c
	* @author ram
	*/

	/* Package Private class */
	public final class Punycode {

	/* Punycode parameters for Bootstring */
	private static final int BASE = 36;
	private static final int TMIN = 1;
	private static final int TMAX = 26;
	private static final int SKEW = 38;
	private static final int DAMP = 700;
	private static final int INITIAL_BIAS = 72;
	private static final int INITIAL_N = 0x80;

	/* "Basic" Unicode/ASCII code points */
	private static final int HYPHEN = 0x2d;
	private static final int DELIMITER = HYPHEN;

	private static final int ZERO = 0x30;
	private static final int NINE = 0x39;

	private static final int SMALL_A = 0x61;
	private static final int SMALL_Z = 0x7a;

	private static final int CAPITAL_A = 0x41;
	private static final int CAPITAL_Z = 0x5a;

	// TODO: eliminate the 256 limitation
	private static final int MAX_CP_COUNT = 256;

	private static final int UINT_MAGIC = 0x80000000;
	private static final long ULONG_MAGIC = 0x8000000000000000L;

	private static int adaptBias(int delta, int length, boolean firstTime){
	if(firstTime){
	delta /=DAMP;
	}else{
	delta /= 2;
	}
	delta += delta/length;

	int count=0;
	for(; delta>((BASE-TMIN)*TMAX)/2; count+=BASE) {
	delta/=(BASE-TMIN);
	}

	return count+(((BASE-TMIN+1)*delta)/(delta+SKEW));
	}

	/**
	* basicToDigit[] contains the numeric value of a basic code
	* point (for use in representing integers) in the range 0 to
	* BASE-1, or -1 if b is does not represent a value.
	*/
	static final int[] basicToDigit= new int[]{
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, -1,

	-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
	15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,

	-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
	15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,

	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
	};

	private static char asciiCaseMap(char b, boolean uppercase) {
	if(uppercase) {
	if(SMALL_A<=b && b<=SMALL_Z) {
	b-=(SMALL_A-CAPITAL_A);
	}
	} else {
	if(CAPITAL_A<=b && b<=CAPITAL_Z) {
	b+=(SMALL_A-CAPITAL_A);
	}
	}
	return b;
	}

	/**
	* digitToBasic() returns the basic code point whose value
	* (when used for representing integers) is d, which must be in the
	* range 0 to BASE-1. The lowercase form is used unless the uppercase flag is
	* nonzero, in which case the uppercase form is used.
	*/
	private static char digitToBasic(int digit, boolean uppercase) {
	/* 0..25 map to ASCII a..z or A..Z */
	/* 26..35 map to ASCII 0..9 */
	if(digit<26) {
	if(uppercase) {
	return (char)(CAPITAL_A+digit);
	} else {
	return (char)(SMALL_A+digit);
	}
	} else {
	return (char)((ZERO-26)+digit);
	}
	}
	/**
	* Converts Unicode to Punycode.
	* The input string must not contain single, unpaired surrogates.
	* The output will be represented as an array of ASCII code points.
	*
	* @param src
	* @param caseFlags
	* @return
	* @throws ParseException
	*/
	public static StringBuffer encode(StringBuffer src, boolean[] caseFlags) throws ParseException{

	int[] cpBuffer = new int[MAX_CP_COUNT];
	int n, delta, handledCPCount, basicLength, destLength, bias, j, m, q, k, t, srcCPCount;
	char c, c2;
	int srcLength = src.length();
	int destCapacity = MAX_CP_COUNT;
	char[] dest = new char[destCapacity];
	StringBuffer result = new StringBuffer();
	/*
	* Handle the basic code points and
	* convert extended ones to UTF-32 in cpBuffer (caseFlag in sign bit):
	*/
	srcCPCount=destLength=0;

	for(j=0; j<srcLength; ++j) {
	if(srcCPCount==MAX_CP_COUNT) {
	/* too many input code points */
	throw new IndexOutOfBoundsException();
	}
	c=src.charAt(j);
	if(isBasic(c)) {
	if(destLength<destCapacity) {
	cpBuffer[srcCPCount++]=0;
	dest[destLength]=
	caseFlags!=null ?
	asciiCaseMap(c, caseFlags[j]) :
	c;
	}
	++destLength;
	} else {
	n=((caseFlags!=null && caseFlags[j])? 1 : 0)<<31L;
	if(!UTF16.isSurrogate(c)) {
	n\|=c;
	} else if(UTF16.isLeadSurrogate(c) && (j+1)<srcLength && UTF16.isTrailSurrogate(c2=src.charAt(j+1))) {
	++j;

	n\|=UCharacter.getCodePoint(c, c2);
	} else {
	/* error: unmatched surrogate */
	throw new ParseException("Illegal char found", -1);
	}
	cpBuffer[srcCPCount++]=n;
	}
	}

	/* Finish the basic string - if it is not empty - with a delimiter. */
	basicLength=destLength;
	if(basicLength>0) {
	if(destLength<destCapacity) {
	dest[destLength]=DELIMITER;
	}
	++destLength;
	}

	/*
	* handledCPCount is the number of code points that have been handled
	* basicLength is the number of basic code points
	* destLength is the number of chars that have been output
	*/

	/* Initialize the state: */
	n=INITIAL_N;
	delta=0;
	bias=INITIAL_BIAS;

	/* Main encoding loop: */
	for(handledCPCount=basicLength; handledCPCount<srcCPCount; /* no op */) {
	/*
	* All non-basic code points < n have been handled already.
	* Find the next larger one:
	*/
	for(m=0x7fffffff, j=0; j<srcCPCount; ++j) {
	q=cpBuffer[j]&0x7fffffff; /* remove case flag from the sign bit */
	if(n<=q && q<m) {
	m=q;
	}
	}

	/*
	* Increase delta enough to advance the decoder's
	* <n,i> state to <m,0>, but guard against overflow:
	*/
	if(m-n>(0x7fffffff-MAX_CP_COUNT-delta)/(handledCPCount+1)) {
	throw new RuntimeException("Internal program error");
	}
	delta+=(m-n)*(handledCPCount+1);
	n=m;

	/* Encode a sequence of same code points n */
	for(j=0; j<srcCPCount; ++j) {
	q=cpBuffer[j]&0x7fffffff; /* remove case flag from the sign bit */
	if(q<n) {
	++delta;
	} else if(q==n) {
	/* Represent delta as a generalized variable-length integer: */
	for(q=delta, k=BASE; /* no condition */; k+=BASE) {

	/** RAM: comment out the old code for conformance with draft-ietf-idn-punycode-03.txt

	t=k-bias;
	if(t<TMIN) {
	t=TMIN;
	} else if(t>TMAX) {
	t=TMAX;
	}
	*/

	t=k-bias;
	if(t<TMIN) {
	t=TMIN;
	} else if(k>=(bias+TMAX)) {
	t=TMAX;
	}

	if(q<t) {
	break;
	}

	if(destLength<destCapacity) {
	dest[destLength++]=digitToBasic(t+(q-t)%(BASE-t), false);
	}
	q=(q-t)/(BASE-t);
	}

	if(destLength<destCapacity) {
	dest[destLength++]=digitToBasic(q, (cpBuffer[j]<0));
	}
	bias=adaptBias(delta, handledCPCount+1,(handledCPCount==basicLength));
	delta=0;
	++handledCPCount;
	}
	}

	++delta;
	++n;
	}

	return result.append(dest, 0, destLength);
	}

	private static boolean isBasic(int ch){
	return (ch < INITIAL_N);
	}

	private static boolean isBasicUpperCase(int ch){
	return( CAPITAL_A <= ch && ch <= CAPITAL_Z);
	}

	private static boolean isSurrogate(int ch){
	return (((ch)&0xfffff800)==0xd800);
	}
	/**
	* Converts Punycode to Unicode.
	* The Unicode string will be at most as long as the Punycode string.
	*
	* @param src
	* @param caseFlags
	* @return
	* @throws ParseException
	*/
	public static StringBuffer decode(StringBuffer src, boolean[] caseFlags)
	throws ParseException{
	int srcLength = src.length();
	StringBuffer result = new StringBuffer();
	int n, destLength, i, bias, basicLength, j, in, oldi, w, k, digit, t,
	destCPCount, firstSupplementaryIndex, cpLength;
	char b;
	int destCapacity = MAX_CP_COUNT;
	char[] dest = new char[destCapacity];

	/*
	* Handle the basic code points:
	* Let basicLength be the number of input code points
	* before the last delimiter, or 0 if there is none,
	* then copy the first basicLength code points to the output.
	*
	* The two following loops iterate backward.
	*/
	for(j=srcLength; j>0;) {
	if(src.charAt(--j)==DELIMITER) {
	break;
	}
	}
	destLength=basicLength=destCPCount=j;

	while(j>0) {
	b=src.charAt(--j);
	if(!isBasic(b)) {
	throw new ParseException("Illegal char found", -1);
	}

	if(j<destCapacity) {
	dest[j]= b;

	if(caseFlags!=null) {
	caseFlags[j]=isBasicUpperCase(b);
	}
	}
	}

	/* Initialize the state: */
	n=INITIAL_N;
	i=0;
	bias=INITIAL_BIAS;
	firstSupplementaryIndex=1000000000;

	/*
	* Main decoding loop:
	* Start just after the last delimiter if any
	* basic code points were copied; start at the beginning otherwise.
	*/
	for(in=basicLength>0 ? basicLength+1 : 0; in<srcLength; /* no op */) {
	/*
	* in is the index of the next character to be consumed, and
	* destCPCount is the number of code points in the output array.
	*
	* Decode a generalized variable-length integer into delta,
	* which gets added to i. The overflow checking is easier
	* if we increase i as we go, then subtract off its starting
	* value at the end to obtain delta.
	*/
	for(oldi=i, w=1, k=BASE; /* no condition */; k+=BASE) {
	if(in>=srcLength) {
	throw new ParseException("Illegal char found", -1);
	}

	digit=basicToDigit[(byte)src.charAt(in++)];
	if(digit<0) {
	throw new ParseException("Invalid char found", -1);
	}
	if(digit>(0x7fffffff-i)/w) {
	/* integer overflow */
	throw new ParseException("Illegal char found", -1);
	}

	i+=digit*w;
	t=k-bias;
	if(t<TMIN) {
	t=TMIN;
	} else if(k>=(bias+TMAX)) {
	t=TMAX;
	}
	if(digit<t) {
	break;
	}

	if(w>0x7fffffff/(BASE-t)) {
	/* integer overflow */
	throw new ParseException("Illegal char found", -1);
	}
	w*=BASE-t;
	}

	/*
	* Modification from sample code:
	* Increments destCPCount here,
	* where needed instead of in for() loop tail.
	*/
	++destCPCount;
	bias=adaptBias(i-oldi, destCPCount, (oldi==0));

	/*
	* i was supposed to wrap around from (incremented) destCPCount to 0,
	* incrementing n each time, so we'll fix that now:
	*/
	if(i/destCPCount>(0x7fffffff-n)) {
	/* integer overflow */
	throw new ParseException("Illegal char found", -1);
	}

	n+=i/destCPCount;
	i%=destCPCount;
	/* not needed for Punycode: */
	/* if (decode_digit(n) <= BASE) return punycode_invalid_input; */

	if(n>0x10ffff \|\| isSurrogate(n)) {
	/* Unicode code point overflow */
	throw new ParseException("Illegal char found", -1);
	}

	/* Insert n at position i of the output: */
	cpLength=UTF16.getCharCount(n);
	if((destLength+cpLength)<destCapacity) {
	int codeUnitIndex;

	/*
	* Handle indexes when supplementary code points are present.
	*
	* In almost all cases, there will be only BMP code points before i
	* and even in the entire string.
	* This is handled with the same efficiency as with UTF-32.
	*
	* Only the rare cases with supplementary code points are handled
	* more slowly - but not too bad since this is an insertion anyway.
	*/
	if(i<=firstSupplementaryIndex) {
	codeUnitIndex=i;
	if(cpLength>1) {
	firstSupplementaryIndex=codeUnitIndex;
	} else {
	++firstSupplementaryIndex;
	}
	} else {
	codeUnitIndex=firstSupplementaryIndex;
	codeUnitIndex=UTF16.moveCodePointOffset(dest, 0, destLength, codeUnitIndex, i-codeUnitIndex);
	}

	/* use the UChar index codeUnitIndex instead of the code point index i */
	if(codeUnitIndex<destLength) {
	System.arraycopy(dest, codeUnitIndex,
	dest, codeUnitIndex+cpLength,
	(destLength-codeUnitIndex));
	if(caseFlags!=null) {
	System.arraycopy(caseFlags, codeUnitIndex,
	caseFlags, codeUnitIndex+cpLength,
	destLength-codeUnitIndex);
	}
	}
	if(cpLength==1) {
	/* BMP, insert one code unit */
	dest[codeUnitIndex]=(char)n;
	} else {
	/* supplementary character, insert two code units */
	dest[codeUnitIndex]=UTF16.getLeadSurrogate(n);
	dest[codeUnitIndex+1]=UTF16.getTrailSurrogate(n);
	}
	if(caseFlags!=null) {
	/* Case of last character determines uppercase flag: */
	caseFlags[codeUnitIndex]=isBasicUpperCase(src.charAt(in-1));
	if(cpLength==2) {
	caseFlags[codeUnitIndex+1]=false;
	}
	}
	}
	destLength+=cpLength;
	++i;
	}
	result.append(dest, 0, destLength);
	return result;
	}
	}

Back to index...