Thread: [Jnode-svn-commits] SF.net SVN: jnode: [3200] trunk/core/src/openjdk/sun/sun

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Revision: 3200
          http://jnode.svn.sourceforge.net/jnode/?rev=3200&view=rev
Author:   lsantha
Date:     2007-05-13 10:11:27 -0700 (Sun, 13 May 2007)

Log Message:
-----------
First merges of OpenJDK.

Added Paths:
-----------
    trunk/core/src/openjdk/sun/sun/misc/
    trunk/core/src/openjdk/sun/sun/misc/DoubleConsts.java
    trunk/core/src/openjdk/sun/sun/misc/FloatConsts.java
    trunk/core/src/openjdk/sun/sun/misc/FloatingDecimal.java
    trunk/core/src/openjdk/sun/sun/misc/FpUtils.java
    trunk/core/src/openjdk/sun/sun/text/
    trunk/core/src/openjdk/sun/sun/text/Normalizer.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/
    trunk/core/src/openjdk/sun/sun/text/normalizer/CharTrie.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/CharacterIteratorWrapper.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/ICUBinary.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/ICUData.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/IntTrie.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/NormalizerBase.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/NormalizerDataReader.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/NormalizerImpl.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/RangeValueIterator.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/Replaceable.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/ReplaceableString.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/ReplaceableUCharacterIterator.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/RuleCharacterIterator.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/SymbolTable.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/Trie.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/TrieIterator.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/UCharacter.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/UCharacterIterator.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/UCharacterProperty.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/UCharacterPropertyReader.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/UProperty.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/UTF16.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/UnicodeMatcher.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/UnicodeSet.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/UnicodeSetIterator.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/Utility.java
    trunk/core/src/openjdk/sun/sun/text/normalizer/VersionInfo.java

Added: trunk/core/src/openjdk/sun/sun/misc/DoubleConsts.java
===================================================================

--- trunk/core/src/openjdk/sun/sun/misc/DoubleConsts.java	                        (rev 0)
+++ trunk/core/src/openjdk/sun/sun/misc/DoubleConsts.java	2007-05-13 17:11:27 UTC (rev 3200)
@@ -0,0 +1,118 @@
+/*
+ * Copyright 2003 Sun Microsystems, Inc.  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.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package sun.misc;
+
+/**
+ * This class contains additional constants documenting limits of the
+ * <code>double</code> type.
+ * 
+ * @author Joseph D. Darcy
+ * @version  1.7, 05/05/07
+ */
+
+public class DoubleConsts {
+    /**
+     * Don't let anyone instantiate this class.
+     */
+    private DoubleConsts() {}
+    
+    public static final double POSITIVE_INFINITY = java.lang.Double.POSITIVE_INFINITY;
+    public static final double NEGATIVE_INFINITY = java.lang.Double.NEGATIVE_INFINITY;
+    public static final double NaN = java.lang.Double.NaN;
+    public static final double MAX_VALUE = java.lang.Double.MAX_VALUE;
+    public static final double MIN_VALUE = java.lang.Double.MIN_VALUE;
+
+    /**
+     * A constant holding the smallest positive normal value of type
+     * <code>double</code>, 2<sup>-1022</sup>.  It is equal to the
+     * value returned by
+     * <code>Double.longBitsToDouble(0x0010000000000000L)</code>.
+     *
+     * @since 1.5
+     */
+    public static final double	MIN_NORMAL	= 2.2250738585072014E-308;
+
+
+    /**
+     * The number of logical bits in the significand of a
+     * <code>double</code> number, including the implicit bit.
+     */
+    public static final int SIGNIFICAND_WIDTH	= 53;
+
+    /**
+     * Maximum exponent a finite <code>double</code> number may have.
+     * It is equal to the value returned by
+     * <code>Math.ilogb(Double.MAX_VALUE)</code>.
+     */
+    public static final int	MAX_EXPONENT	= 1023;
+
+    /**
+     * Minimum exponent a normalized <code>double</code> number may
+     * have.  It is equal to the value returned by
+     * <code>Math.ilogb(Double.MIN_NORMAL)</code>.
+     */
+    public static final int	MIN_EXPONENT	= -1022;
+
+    /**
+     * The exponent the smallest positive <code>double</code>
+     * subnormal value would have if it could be normalized.  It is
+     * equal to the value returned by
+     * <code>FpUtils.ilogb(Double.MIN_VALUE)</code>.
+     */
+    public static final int	MIN_SUB_EXPONENT = MIN_EXPONENT - 
+	                                           (SIGNIFICAND_WIDTH - 1);
+
+    /**
+     * Bias used in representing a <code>double</code> exponent.
+     */
+    public static final int	EXP_BIAS	= 1023;
+
+    /**
+     * Bit mask to isolate the sign bit of a <code>double</code>.
+     */
+    public static final long	SIGN_BIT_MASK	= 0x8000000000000000L;
+
+    /**
+     * Bit mask to isolate the exponent field of a
+     * <code>double</code>.
+     */
+    public static final long	EXP_BIT_MASK	= 0x7FF0000000000000L;
+
+    /**
+     * Bit mask to isolate the significand field of a
+     * <code>double</code>.
+     */
+    public static final long	SIGNIF_BIT_MASK	= 0x000FFFFFFFFFFFFFL;
+    
+    static {
+	// verify bit masks cover all bit positions and that the bit
+	// masks are non-overlapping
+	assert(((SIGN_BIT_MASK | EXP_BIT_MASK | SIGNIF_BIT_MASK) == ~0L) &&
+	       (((SIGN_BIT_MASK & EXP_BIT_MASK) == 0L) &&
+		((SIGN_BIT_MASK & SIGNIF_BIT_MASK) == 0L) &&
+		((EXP_BIT_MASK & SIGNIF_BIT_MASK) == 0L)));
+    }
+}

Added: trunk/core/src/openjdk/sun/sun/misc/FloatConsts.java
===================================================================
--- trunk/core/src/openjdk/sun/sun/misc/FloatConsts.java	                        (rev 0)
+++ trunk/core/src/openjdk/sun/sun/misc/FloatConsts.java	2007-05-13 17:11:27 UTC (rev 3200)
@@ -0,0 +1,113 @@
+/*
+ * Copyright 2003 Sun Microsystems, Inc.  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.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package sun.misc;
+
+/**
+ * This class contains additional constants documenting limits of the
+ * <code>float</code> type.
+ * 
+ * @author Joseph D. Darcy
+ * @version  1.7, 05/05/07
+ */
+
+public class FloatConsts {
+    /**
+     * Don't let anyone instantiate this class.
+     */
+    private FloatConsts() {}
+
+    public static final float POSITIVE_INFINITY = java.lang.Float.POSITIVE_INFINITY;
+    public static final float NEGATIVE_INFINITY = java.lang.Float.NEGATIVE_INFINITY;
+    public static final float NaN = java.lang.Float.NaN;
+    public static final float MAX_VALUE = java.lang.Float.MAX_VALUE;
+    public static final float MIN_VALUE = java.lang.Float.MIN_VALUE;
+
+    /**
+     * A constant holding the smallest positive normal value of type
+     * <code>float</code>, 2<sup>-126</sup>.  It is equal to the value
+     * returned by <code>Float.intBitsToFloat(0x00800000)</code>.
+     */
+    public static final float	MIN_NORMAL	= 1.17549435E-38f;
+
+    /**
+     * The number of logical bits in the significand of a
+     * <code>float</code> number, including the implicit bit.
+     */
+    public static final int SIGNIFICAND_WIDTH	= 24;
+
+    /**
+     * Maximum exponent a finite <code>float</code> number may have.
+     * It is equal to the value returned by
+     * <code>Math.ilogb(Float.MAX_VALUE)</code>.
+     */
+    public static final int	MAX_EXPONENT	= 127;
+    
+    /**
+     * Minimum exponent a normalized <code>float</code> number may
+     * have.  It is equal to the value returned by
+     * <code>Math.ilogb(Float.MIN_NORMAL)</code>.
+     */
+    public static final int	MIN_EXPONENT	= -126;
+
+    /**
+     * The exponent the smallest positive <code>float</code> subnormal
+     * value would have if it could be normalized.  It is equal to the
+     * value returned by <code>FpUtils.ilogb(Float.MIN_VALUE)</code>.
+     */
+    public static final int	MIN_SUB_EXPONENT = MIN_EXPONENT - 
+	                                           (SIGNIFICAND_WIDTH - 1);
+
+    /**
+     * Bias used in representing a <code>float</code> exponent.
+     */
+    public static final int	EXP_BIAS	= 127;	
+
+    /**
+     * Bit mask to isolate the sign bit of a <code>float</code>.
+     */
+    public static final int	SIGN_BIT_MASK	= 0x80000000;
+
+    /**
+     * Bit mask to isolate the exponent field of a
+     * <code>float</code>.
+     */
+    public static final int 	EXP_BIT_MASK	= 0x7F800000;
+
+    /**
+     * Bit mask to isolate the significand field of a
+     * <code>float</code>.
+     */
+    public static final int 	SIGNIF_BIT_MASK	= 0x007FFFFF;
+
+    static {
+	// verify bit masks cover all bit positions and that the bit
+	// masks are non-overlapping
+	assert(((SIGN_BIT_MASK | EXP_BIT_MASK | SIGNIF_BIT_MASK) == ~0) &&
+	       (((SIGN_BIT_MASK & EXP_BIT_MASK) == 0) &&
+		((SIGN_BIT_MASK & SIGNIF_BIT_MASK) == 0) &&
+		((EXP_BIT_MASK & SIGNIF_BIT_MASK) == 0)));
+    }
+}

Added: trunk/core/src/openjdk/sun/sun/misc/FloatingDecimal.java
===================================================================
--- trunk/core/src/openjdk/sun/sun/misc/FloatingDecimal.java	                        (rev 0)
+++ trunk/core/src/openjdk/sun/sun/misc/FloatingDecimal.java	2007-05-13 17:11:27 UTC (rev 3200)
@@ -0,0 +1,2876 @@
+/*
+ * Copyright 1996-2004 Sun Microsystems, Inc.  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.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package sun.misc;
+
+import sun.misc.FpUtils;
+import sun.misc.DoubleConsts;
+import sun.misc.FloatConsts;
+import java.util.regex.*;
+
+public class FloatingDecimal{
+    boolean	isExceptional;
+    boolean	isNegative;
+    int		decExponent;
+    char	digits[];
+    int		nDigits;
+    int		bigIntExp;
+    int		bigIntNBits;
+    boolean	mustSetRoundDir = false;
+    boolean	fromHex = false;
+    int		roundDir = 0; // set by doubleValue
+
+    private	FloatingDecimal( boolean negSign, int decExponent, char []digits, int n,  boolean e )
+    {
+	isNegative = negSign;
+	isExceptional = e;
+	this.decExponent = decExponent;
+	this.digits = digits;
+	this.nDigits = n;
+    }
+
+    /*
+     * Constants of the implementation
+     * Most are IEEE-754 related.
+     * (There are more really boring constants at the end.)
+     */
+    static final long	signMask = 0x8000000000000000L;
+    static final long	expMask  = 0x7ff0000000000000L;
+    static final long	fractMask= ~(signMask|expMask);
+    static final int	expShift = 52;
+    static final int	expBias  = 1023;
+    static final long	fractHOB = ( 1L<<expShift ); // assumed High-Order bit
+    static final long	expOne	 = ((long)expBias)<<expShift; // exponent of 1.0
+    static final int	maxSmallBinExp = 62;
+    static final int	minSmallBinExp = -( 63 / 3 );
+    static final int	maxDecimalDigits = 15;
+    static final int	maxDecimalExponent = 308;
+    static final int	minDecimalExponent = -324;
+    static final int	bigDecimalExponent = 324; // i.e. abs(minDecimalExponent)
+
+    static final long	highbyte = 0xff00000000000000L;
+    static final long	highbit  = 0x8000000000000000L;
+    static final long	lowbytes = ~highbyte;
+
+    static final int	singleSignMask =    0x80000000;
+    static final int	singleExpMask  =    0x7f800000;
+    static final int	singleFractMask =   ~(singleSignMask|singleExpMask);
+    static final int	singleExpShift	=   23;
+    static final int	singleFractHOB	=   1<<singleExpShift;
+    static final int	singleExpBias	=   127;
+    static final int	singleMaxDecimalDigits = 7;
+    static final int	singleMaxDecimalExponent = 38;
+    static final int	singleMinDecimalExponent = -45;
+
+    static final int	intDecimalDigits = 9;
+
+
+    /*
+     * count number of bits from high-order 1 bit to low-order 1 bit,
+     * inclusive.
+     */
+    private static int
+    countBits( long v ){
+	//
+	// the strategy is to shift until we get a non-zero sign bit
+	// then shift until we have no bits left, counting the difference.
+	// we do byte shifting as a hack. Hope it helps.
+	//
+	if ( v == 0L ) return 0;
+
+	while ( ( v & highbyte ) == 0L ){
+	    v <<= 8;
+	}
+	while ( v > 0L ) { // i.e. while ((v&highbit) == 0L )
+	    v <<= 1;
+	}
+
+	int n = 0;
+	while (( v & lowbytes ) != 0L ){
+	    v <<= 8;
+	    n += 8;
+	}
+	while ( v != 0L ){
+	    v <<= 1;
+	    n += 1;
+	}
+	return n;
+    }
+
+    /*
+     * Keep big powers of 5 handy for future reference.
+     */
+    private static FDBigInt b5p[];
+
+    private static synchronized FDBigInt
+    big5pow( int p ){
+        assert p >= 0 : p; // negative power of 5
+	if ( b5p == null ){
+	    b5p = new FDBigInt[ p+1 ];
+	}else if (b5p.length <= p ){
+	    FDBigInt t[] = new FDBigInt[ p+1 ];
+	    System.arraycopy( b5p, 0, t, 0, b5p.length );
+	    b5p = t;
+	}
+	if ( b5p[p] != null )
+	    return b5p[p];
+	else if ( p < small5pow.length )
+	    return b5p[p] = new FDBigInt( small5pow[p] );
+	else if ( p < long5pow.length )
+	    return b5p[p] = new FDBigInt( long5pow[p] );
+	else {
+	    // construct the value.
+	    // recursively.
+	    int q, r;
+	    // in order to compute 5^p,
+	    // compute its square root, 5^(p/2) and square.
+	    // or, let q = p / 2, r = p -q, then
+	    // 5^p = 5^(q+r) = 5^q * 5^r
+	    q = p >> 1;
+	    r = p - q;
+	    FDBigInt bigq =  b5p[q];
+	    if ( bigq == null )
+		bigq = big5pow ( q );
+	    if ( r < small5pow.length ){
+		return (b5p[p] = bigq.mult( small5pow[r] ) );
+	    }else{
+		FDBigInt bigr = b5p[ r ];
+		if ( bigr == null )
+		    bigr = big5pow( r );
+		return (b5p[p] = bigq.mult( bigr ) );
+	    }
+	}
+    }
+
+    //
+    // a common operation
+    //
+    private static FDBigInt
+    multPow52( FDBigInt v, int p5, int p2 ){
+	if ( p5 != 0 ){
+	    if ( p5 < small5pow.length ){
+		v = v.mult( small5pow[p5] );
+	    } else {
+		v = v.mult( big5pow( p5 ) );
+	    }
+	}
+	if ( p2 != 0 ){
+	    v.lshiftMe( p2 );
+	}
+	return v;
+    }
+
+    //
+    // another common operation
+    //
+    private static FDBigInt
+    constructPow52( int p5, int p2 ){
+	FDBigInt v = new FDBigInt( big5pow( p5 ) );
+	if ( p2 != 0 ){
+	    v.lshiftMe( p2 );
+	}
+	return v;
+    }
+
+    /*
+     * Make a floating double into a FDBigInt.
+     * This could also be structured as a FDBigInt
+     * constructor, but we'd have to build a lot of knowledge
+     * about floating-point representation into it, and we don't want to.
+     *
+     * AS A SIDE EFFECT, THIS METHOD WILL SET THE INSTANCE VARIABLES
+     * bigIntExp and bigIntNBits
+     *
+     */
+    private FDBigInt
+    doubleToBigInt( double dval ){
+	long lbits = Double.doubleToLongBits( dval ) & ~signMask;
+	int binexp = (int)(lbits >>> expShift);
+	lbits &= fractMask;
+	if ( binexp > 0 ){
+	    lbits |= fractHOB;
+	} else {
+            assert lbits != 0L : lbits; // doubleToBigInt(0.0)
+	    binexp +=1;
+	    while ( (lbits & fractHOB ) == 0L){
+		lbits <<= 1;
+		binexp -= 1;
+	    }
+	}
+	binexp -= expBias;
+	int nbits = countBits( lbits );
+	/*
+	 * We now know where the high-order 1 bit is,
+	 * and we know how many there are.
+	 */
+	int lowOrderZeros = expShift+1-nbits;
+	lbits >>>= lowOrderZeros;
+
+	bigIntExp = binexp+1-nbits;
+	bigIntNBits = nbits;
+	return new FDBigInt( lbits );
+    }
+
+    /*
+     * Compute a number that is the ULP of the given value,
+     * for purposes of addition/subtraction. Generally easy.
+     * More difficult if subtracting and the argument
+     * is a normalized a power of 2, as the ULP changes at these points.
+     */
+    private static double
+    ulp( double dval, boolean subtracting ){
+	long lbits = Double.doubleToLongBits( dval ) & ~signMask;
+	int binexp = (int)(lbits >>> expShift);
+	double ulpval;
+	if ( subtracting && ( binexp >= expShift ) && ((lbits&fractMask) == 0L) ){
+	    // for subtraction from normalized, powers of 2,
+	    // use next-smaller exponent
+	    binexp -= 1;
+	}
+	if ( binexp > expShift ){
+	    ulpval = Double.longBitsToDouble( ((long)(binexp-expShift))<<expShift );
+	} else if ( binexp == 0 ){
+	    ulpval = Double.MIN_VALUE;
+	} else {
+	    ulpval = Double.longBitsToDouble( 1L<<(binexp-1) );
+	}
+	if ( subtracting ) ulpval = - ulpval;
+
+	return ulpval;
+    }
+
+    /*
+     * Round a double to a float.
+     * In addition to the fraction bits of the double,
+     * look at the class instance variable roundDir,
+     * which should help us avoid double-rounding error.
+     * roundDir was set in hardValueOf if the estimate was
+     * close enough, but not exact. It tells us which direction
+     * of rounding is preferred.
+     */
+    float
+    stickyRound( double dval ){
+	long lbits = Double.doubleToLongBits( dval );
+	long binexp = lbits & expMask;
+	if ( binexp == 0L || binexp == expMask ){
+	    // what we have here is special.
+	    // don't worry, the right thing will happen.
+	    return (float) dval;
+	}
+	lbits += (long)roundDir; // hack-o-matic.
+	return (float)Double.longBitsToDouble( lbits );
+    }
+
+
+    /*
+     * This is the easy subcase --
+     * all the significant bits, after scaling, are held in lvalue.
+     * negSign and decExponent tell us what processing and scaling
+     * has already been done. Exceptional cases have already been
+     * stripped out.
+     * In particular:
+     * lvalue is a finite number (not Inf, nor NaN)
+     * lvalue > 0L (not zero, nor negative).
+     *
+     * The only reason that we develop the digits here, rather than
+     * calling on Long.toString() is that we can do it a little faster,
+     * and besides want to treat trailing 0s specially. If Long.toString
+     * changes, we should re-evaluate this strategy!
+     */
+    private void
+    developLongDigits( int decExponent, long lvalue, long insignificant ){
+	char digits[];
+	int  ndigits;
+	int  digitno;
+	int  c;
+	//
+	// Discard non-significant low-order bits, while rounding,
+	// up to insignificant value.
+	int i;
+	for ( i = 0; insignificant >= 10L; i++ )
+	    insignificant /= 10L;
+	if ( i != 0 ){
+	    long pow10 = long5pow[i] << i; // 10^i == 5^i * 2^i;
+	    long residue = lvalue % pow10;
+	    lvalue /= pow10;
+	    decExponent += i;
+	    if ( residue >= (pow10>>1) ){
+		// round up based on the low-order bits we're discarding
+		lvalue++;
+	    }
+	}
+	if ( lvalue <= Integer.MAX_VALUE ){
+            assert lvalue > 0L : lvalue; // lvalue <= 0
+	    // even easier subcase!
+	    // can do int arithmetic rather than long!
+	    int  ivalue = (int)lvalue;
+            ndigits = 10;
+            digits = (char[])(perThreadBuffer.get());
+	    digitno = ndigits-1;
+	    c = ivalue%10;
+	    ivalue /= 10;
+	    while ( c == 0 ){
+		decExponent++;
+		c = ivalue%10;
+		ivalue /= 10;
+	    }
+	    while ( ivalue != 0){
+		digits[digitno--] = (char)(c+'0');
+		decExponent++;
+		c = ivalue%10;
+		ivalue /= 10;
+	    }
+	    digits[digitno] = (char)(c+'0');
+	} else {
+	    // same algorithm as above (same bugs, too )
+	    // but using long arithmetic.
+            ndigits = 20;
+	    digits = (char[])(perThreadBuffer.get());
+	    digitno = ndigits-1;
+	    c = (int)(lvalue%10L);
+	    lvalue /= 10L;
+	    while ( c == 0 ){
+		decExponent++;
+		c = (int)(lvalue%10L);
+		lvalue /= 10L;
+	    }
+	    while ( lvalue != 0L ){
+		digits[digitno--] = (char)(c+'0');
+		decExponent++;
+		c = (int)(lvalue%10L);
+		lvalue /= 10;
+	    }
+	    digits[digitno] = (char)(c+'0');
+	}
+	char result [];
+	ndigits -= digitno;
+	result = new char[ ndigits ];
+	System.arraycopy( digits, digitno, result, 0, ndigits );
+	this.digits = result;
+	this.decExponent = decExponent+1;
+	this.nDigits = ndigits;
+    }
+
+    //
+    // add one to the least significant digit.
+    // in the unlikely event there is a carry out,
+    // deal with it.
+    // assert that this will only happen where there
+    // is only one digit, e.g. (float)1e-44 seems to do it.
+    //
+    private void
+    roundup(){
+	int i;
+	int q = digits[ i = (nDigits-1)];
+	if ( q == '9' ){
+	    while ( q == '9' && i > 0 ){
+		digits[i] = '0';
+		q = digits[--i];
+	    }
+	    if ( q == '9' ){
+		// carryout! High-order 1, rest 0s, larger exp.
+		decExponent += 1;
+		digits[0] = '1';
+		return;
+	    }
+	    // else fall through.
+	}
+	digits[i] = (char)(q+1);
+    }
+
+    /*
+     * FIRST IMPORTANT CONSTRUCTOR: DOUBLE
+     */
+    public FloatingDecimal( double d )
+    {
+	long	dBits = Double.doubleToLongBits( d );
+	long	fractBits;
+	int	binExp;
+	int	nSignificantBits;
+
+	// discover and delete sign
+	if ( (dBits&signMask) != 0 ){
+	    isNegative = true;
+	    dBits ^= signMask;
+	} else {
+	    isNegative = false;
+	}
+	// Begin to unpack
+	// Discover obvious special cases of NaN and Infinity.
+	binExp = (int)( (dBits&expMask) >> expShift );
+	fractBits = dBits&fractMask;
+	if ( binExp == (int)(expMask>>expShift) ) {
+	    isExceptional = true;
+	    if ( fractBits == 0L ){
+		digits =  infinity;
+	    } else {
+		digits = notANumber;
+		isNegative = false; // NaN has no sign!
+	    }
+	    nDigits = digits.length;
+	    return;
+	}
+	isExceptional = false;
+	// Finish unpacking
+	// Normalize denormalized numbers.
+	// Insert assumed high-order bit for normalized numbers.
+	// Subtract exponent bias.
+	if ( binExp == 0 ){
+	    if ( fractBits == 0L ){
+		// not a denorm, just a 0!
+		decExponent = 0;
+		digits = zero;
+		nDigits = 1;
+		return;
+	    }
+	    while ( (fractBits&fractHOB) == 0L ){
+		fractBits <<= 1;
+		binExp -= 1;
+	    }
+	    nSignificantBits = expShift + binExp +1; // recall binExp is  - shift count.
+	    binExp += 1;
+	} else {
+	    fractBits |= fractHOB;
+	    nSignificantBits = expShift+1;
+	}
+	binExp -= expBias;
+	// call the routine that actually does all the hard work.
+	dtoa( binExp, fractBits, nSignificantBits );
+    }
+
+    /*
+     * SECOND IMPORTANT CONSTRUCTOR: SINGLE
+     */
+    public FloatingDecimal( float f )
+    {
+	int	fBits = Float.floatToIntBits( f );
+	int	fractBits;
+	int	binExp;
+	int	nSignificantBits;
+
+	// discover and delete sign
+	if ( (fBits&singleSignMask) != 0 ){
+	    isNegative = true;
+	    fBits ^= singleSignMask;
+	} else {
+	    isNegative = false;
+	}
+	// Begin to unpack
+	// Discover obvious special cases of NaN and Infinity.
+	binExp = (int)( (fBits&singleExpMask) >> singleExpShift );
+	fractBits = fBits&singleFractMask;
+	if ( binExp == (int)(singleExpMask>>singleExpShift) ) {
+	    isExceptional = true;
+	    if ( fractBits == 0L ){
+		digits =  infinity;
+	    } else {
+		digits = notANumber;
+		isNegative = false; // NaN has no sign!
+	    }
+	    nDigits = digits.length;
+	    return;
+	}
+	isExceptional = false;
+	// Finish unpacking
+	// Normalize denormalized numbers.
+	// Insert assumed high-order bit for normalized numbers.
+	// Subtract exponent bias.
+	if ( binExp == 0 ){
+	    if ( fractBits == 0 ){
+		// not a denorm, just a 0!
+		decExponent = 0;
+		digits = zero;
+		nDigits = 1;
+		return;
+	    }
+	    while ( (fractBits&singleFractHOB) == 0 ){
+		fractBits <<= 1;
+		binExp -= 1;
+	    }
+	    nSignificantBits = singleExpShift + binExp +1; // recall binExp is  - shift count.
+	    binExp += 1;
+	} else {
+	    fractBits |= singleFractHOB;
+	    nSignificantBits = singleExpShift+1;
+	}
+	binExp -= singleExpBias;
+	// call the routine that actually does all the hard work.
+	dtoa( binExp, ((long)fractBits)<<(expShift-singleExpShift), nSignificantBits );
+    }
+
+    private void
+    dtoa( int binExp, long fractBits, int nSignificantBits )
+    {
+	int	nFractBits; // number of significant bits of fractBits;
+	int	nTinyBits;  // number of these to the right of the point.
+	int	decExp;
+
+	// Examine number. Determine if it is an easy case,
+	// which we can do pretty trivially using float/long conversion,
+	// or whether we must do real work.
+	nFractBits = countBits( fractBits );
+	nTinyBits = Math.max( 0, nFractBits - binExp - 1 );
+	if ( binExp <= maxSmallBinExp && binExp >= minSmallBinExp ){
+	    // Look more closely at the number to decide if,
+	    // with scaling by 10^nTinyBits, the result will fit in
+	    // a long.
+	    if ( (nTinyBits < long5pow.length) && ((nFractBits + n5bits[nTinyBits]) < 64 ) ){
+		/*
+		 * We can do this:
+		 * take the fraction bits, which are normalized.
+		 * (a) nTinyBits == 0: Shift left or right appropriately
+		 *     to align the binary point at the extreme right, i.e.
+		 *     where a long int point is expected to be. The integer
+		 *     result is easily converted to a string.
+		 * (b) nTinyBits > 0: Shift right by expShift-nFractBits,
+		 *     which effectively converts to long and scales by
+		 *     2^nTinyBits. Then multiply by 5^nTinyBits to
+		 *     complete the scaling. We know this won't overflow
+		 *     because we just counted the number of bits necessary
+		 *     in the result. The integer you get from this can
+		 *     then be converted to a string pretty easily.
+		 */
+		long halfULP;
+		if ( nTinyBits == 0 ) {
+		    if ( binExp > nSignificantBits ){
+			halfULP = 1L << ( binExp-nSignificantBits-1);
+		    } else {
+			halfULP = 0L;
+		    }
+		    if ( binExp >= expShift ){
+			fractBits <<= (binExp-expShift);
+		    } else {
+			fractBits >>>= (expShift-binExp) ;
+		    }
+		    developLongDigits( 0, fractBits, halfULP );
+		    return;
+		}
+		/*
+		 * The following causes excess digits to be printed
+		 * out in the single-float case. Our manipulation of
+		 * halfULP here is apparently not correct. If we
+		 * better understand how this works, perhaps we can
+		 * use this special case again. But for the time being,
+		 * we do not.
+		 * else {
+		 *     fractBits >>>= expShift+1-nFractBits;
+		 *     fractBits *= long5pow[ nTinyBits ];
+		 *     halfULP = long5pow[ nTinyBits ] >> (1+nSignificantBits-nFractBits);
+		 *     developLongDigits( -nTinyBits, fractBits, halfULP );
+		 *     return;
+		 * }
+		 */
+	    }
+	}
+	/*
+	 * This is the hard case. We are going to compute large positive
+	 * integers B and S and integer decExp, s.t.
+	 *	d = ( B / S ) * 10^decExp
+	 *	1 <= B / S < 10
+	 * Obvious choices are:
+	 *	decExp = floor( log10(d) )
+	 * 	B      = d * 2^nTinyBits * 10^max( 0, -decExp )
+	 *	S      = 10^max( 0, decExp) * 2^nTinyBits
+	 * (noting that nTinyBits has already been forced to non-negative)
+	 * I am also going to compute a large positive integer
+	 *	M      = (1/2^nSignificantBits) * 2^nTinyBits * 10^max( 0, -decExp )
+	 * i.e. M is (1/2) of the ULP of d, scaled like B.
+	 * When we iterate through dividing ...
 
[truncated message content]

Thread: [Jnode-svn-commits] SF.net SVN: jnode: [3200] trunk/core/src/openjdk/sun/sun

jnode-svn-commits