/*

 * Copyright (c) 1996, 2013, 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.

 */

package sun.misc;

import java.util.Arrays;

import java.util.regex.*;

/**

 * A class for converting between ASCII and decimal representations of a single

 * or double precision floating point number. Most conversions are provided via

 * static convenience methods, although a <code>BinaryToASCIIConverter</code>

 * instance may be obtained and reused.

 */

public class FloatingDecimal{

    //

    // Constants of the implementation;

    // most are IEEE-754 related.

    // (There are more really boring constants at the end.)

    //

    static final int    EXP_SHIFT = DoubleConsts.SIGNIFICAND_WIDTH - 1;

    static final long   FRACT_HOB = ( 1L<<EXP_SHIFT ); // assumed High-Order bit

    static final long   EXP_ONE   = ((long)DoubleConsts.EXP_BIAS)<<EXP_SHIFT; // exponent of 1.0

    static final int    MAX_SMALL_BIN_EXP = 62;

    static final int    MIN_SMALL_BIN_EXP = -( 63 / 3 );

    static final int    MAX_DECIMAL_DIGITS = 15;

    static final int    MAX_DECIMAL_EXPONENT = 308;

    static final int    MIN_DECIMAL_EXPONENT = -324;

    static final int    BIG_DECIMAL_EXPONENT = 324; // i.e. abs(MIN_DECIMAL_EXPONENT)

    static final int    MAX_NDIGITS = 1100;

    static final int    SINGLE_EXP_SHIFT  =   FloatConsts.SIGNIFICAND_WIDTH - 1;

    static final int    SINGLE_FRACT_HOB  =   1<<SINGLE_EXP_SHIFT;

    static final int    SINGLE_MAX_DECIMAL_DIGITS = 7;

    static final int    SINGLE_MAX_DECIMAL_EXPONENT = 38;

    static final int    SINGLE_MIN_DECIMAL_EXPONENT = -45;

    static final int    SINGLE_MAX_NDIGITS = 200;

    static final int    INT_DECIMAL_DIGITS = 9;

    /**

     * Converts a double precision floating point value to a <code>String</code>.

     *

     * @param d The double precision value.

     * @return The value converted to a <code>String</code>.

     */

    public static String toJavaFormatString(double d) {

        return getBinaryToASCIIConverter(d).toJavaFormatString();

    }

    /**

     * Converts a single precision floating point value to a <code>String</code>.

     *

     * @param f The single precision value.

     * @return The value converted to a <code>String</code>.

     */

    public static String toJavaFormatString(float f) {

        return getBinaryToASCIIConverter(f).toJavaFormatString();

    }

    /**

     * Appends a double precision floating point value to an <code>Appendable</code>.

     * @param d The double precision value.

     * @param buf The <code>Appendable</code> with the value appended.

     */

    public static void appendTo(double d, Appendable buf) {

        getBinaryToASCIIConverter(d).appendTo(buf);

    }

    /**

     * Appends a single precision floating point value to an <code>Appendable</code>.

     * @param f The single precision value.

     * @param buf The <code>Appendable</code> with the value appended.

     */

    public static void appendTo(float f, Appendable buf) {

        getBinaryToASCIIConverter(f).appendTo(buf);

    }

    /**

     * Converts a <code>String</code> to a double precision floating point value.

     *

     * @param s The <code>String</code> to convert.

     * @return The double precision value.

     * @throws NumberFormatException If the <code>String</code> does not

     * represent a properly formatted double precision value.

     */

    public static double parseDouble(String s) throws NumberFormatException {

        return readJavaFormatString(s).doubleValue();

    }

    /**

     * Converts a <code>String</code> to a single precision floating point value.

     *

     * @param s The <code>String</code> to convert.

     * @return The single precision value.

     * @throws NumberFormatException If the <code>String</code> does not

     * represent a properly formatted single precision value.

     */

    public static float parseFloat(String s) throws NumberFormatException {

        return readJavaFormatString(s).floatValue();

    }

    /**

     * A converter which can process single or double precision floating point

     * values into an ASCII <code>String</code> representation.

     */

    public interface BinaryToASCIIConverter {

        /**

         * Converts a floating point value into an ASCII <code>String</code>.

         * @return The value converted to a <code>String</code>.

         */

        public String toJavaFormatString();

        /**

         * Appends a floating point value to an <code>Appendable</code>.

         * @param buf The <code>Appendable</code> to receive the value.

         */

        public void appendTo(Appendable buf);

        /**

         * Retrieves the decimal exponent most closely corresponding to this value.

         * @return The decimal exponent.

         */

        public int getDecimalExponent();

        /**

         * Retrieves the value as an array of digits.

         * @param digits The digit array.

         * @return The number of valid digits copied into the array.

         */

        public int getDigits(char[] digits);

        /**

         * Indicates the sign of the value.

         * @return {@code value < 0.0}.

         */

        public boolean isNegative();

        /**

         * Indicates whether the value is either infinite or not a number.

         *

         * @return <code>true</code> if and only if the value is <code>NaN</code>

         * or infinite.

         */

        public boolean isExceptional();

        /**

         * Indicates whether the value was rounded up during the binary to ASCII

         * conversion.

         *

         * @return <code>true</code> if and only if the value was rounded up.

         */

        public boolean digitsRoundedUp();

        /**

         * Indicates whether the binary to ASCII conversion was exact.

         *

         * @return <code>true</code> if any only if the conversion was exact.

         */

        public boolean decimalDigitsExact();

    }

    /**

     * A <code>BinaryToASCIIConverter</code> which represents <code>NaN</code>

     * and infinite values.

     */

    private static class ExceptionalBinaryToASCIIBuffer implements BinaryToASCIIConverter {

        private boolean isNegative;

        public ExceptionalBinaryToASCIIBuffer(String image, boolean isNegative) {

            this.image = image;

            this.isNegative = isNegative;

        }

        @Override

        public String toJavaFormatString() {

            return image;

        }

        @Override

        public void appendTo(Appendable buf) {

            if (buf instanceof StringBuilder) {

                ((StringBuilder) buf).append(image);

            } else if (buf instanceof StringBuffer) {

                ((StringBuffer) buf).append(image);

            } else {

                assert false;

            }

        }

        @Override

        public int getDecimalExponent() {

            throw new IllegalArgumentException("Exceptional value does not have an exponent");

        }

        @Override

        public int getDigits(char[] digits) {

            throw new IllegalArgumentException("Exceptional value does not have digits");

        }

        @Override

        public boolean isNegative() {

            return isNegative;

        }

        @Override

        public boolean isExceptional() {

            return true;

        }

        @Override

        public boolean digitsRoundedUp() {

            throw new IllegalArgumentException("Exceptional value is not rounded");

        }

        @Override

        public boolean decimalDigitsExact() {

            throw new IllegalArgumentException("Exceptional value is not exact");

        }

    }

    private static final String INFINITY_REP = "Infinity";

    private static final int INFINITY_LENGTH = INFINITY_REP.length();

    private static final String NAN_REP = "NaN";

    private static final int NAN_LENGTH = NAN_REP.length();

    private static final BinaryToASCIIConverter B2AC_POSITIVE_INFINITY = new ExceptionalBinaryToASCIIBuffer(INFINITY_REP, false);

    private static final BinaryToASCIIConverter B2AC_NEGATIVE_INFINITY = new ExceptionalBinaryToASCIIBuffer("-" + INFINITY_REP, true);

    private static final BinaryToASCIIConverter B2AC_NOT_A_NUMBER = new ExceptionalBinaryToASCIIBuffer(NAN_REP, false);

    private static final BinaryToASCIIConverter B2AC_POSITIVE_ZERO = new BinaryToASCIIBuffer(false, new char[]{'0'});

    private static final BinaryToASCIIConverter B2AC_NEGATIVE_ZERO = new BinaryToASCIIBuffer(true,  new char[]{'0'});

    /**

     * A buffered implementation of <code>BinaryToASCIIConverter</code>.

     */

    static class BinaryToASCIIBuffer implements BinaryToASCIIConverter {

        private boolean isNegative;

        private int decExponent;

        private int firstDigitIndex;

        private int nDigits;

        private final char[] digits;

        private final char[] buffer = new char[26];

        //

        // The fields below provide additional information about the result of

        // the binary to decimal digits conversion done in dtoa() and roundup()

        // methods. They are changed if needed by those two methods.

        //

        // True if the dtoa() binary to decimal conversion was exact.

        private boolean exactDecimalConversion = false;

        // True if the result of the binary to decimal conversion was rounded-up

        // at the end of the conversion process, i.e. roundUp() method was called.

        private boolean decimalDigitsRoundedUp = false;

        /**

         * Default constructor; used for non-zero values,

         * <code>BinaryToASCIIBuffer</code> may be thread-local and reused

         */

        BinaryToASCIIBuffer(){

            this.digits = new char[20];

        }

        /**

         * Creates a specialized value (positive and negative zeros).

         */

        BinaryToASCIIBuffer(boolean isNegative, char[] digits){

            this.isNegative = isNegative;

            this.decExponent  = 0;

            this.digits = digits;

            this.firstDigitIndex = 0;

            this.nDigits = digits.length;

        }

        @Override

        public String toJavaFormatString() {

            int len = getChars(buffer);

            return new String(buffer, 0, len);

        }

        @Override

        public void appendTo(Appendable buf) {

            int len = getChars(buffer);

            if (buf instanceof StringBuilder) {

                ((StringBuilder) buf).append(buffer, 0, len);

            } else if (buf instanceof StringBuffer) {

                ((StringBuffer) buf).append(buffer, 0, len);

            } else {

                assert false;

            }

        }

        @Override

        public int getDecimalExponent() {

            return decExponent;

        }

        @Override

        public int getDigits(char[] digits) {

            System.arraycopy(this.digits,firstDigitIndex,digits,0,this.nDigits);

            return this.nDigits;

        }

        @Override

        public boolean isNegative() {

            return isNegative;

        }

        @Override

        public boolean isExceptional() {

            return false;

        }

        @Override

        public boolean digitsRoundedUp() {

            return decimalDigitsRoundedUp;

        }

        @Override

        public boolean decimalDigitsExact() {

            return exactDecimalConversion;

        }

        private void setSign(boolean isNegative) {

            this.isNegative = isNegative;

        }

        /**

         * 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, int insignificantDigits ){

            if ( insignificantDigits != 0 ){

                // Discard non-significant low-order bits, while rounding,

                // up to insignificant value.

                long pow10 = FDBigInteger.LONG_5_POW[insignificantDigits] << insignificantDigits; // 10^i == 5^i * 2^i;

                long residue = lvalue % pow10;

                lvalue /= pow10;

                decExponent += insignificantDigits;

                if ( residue >= (pow10>>1) ){

                    // round up based on the low-order bits we're discarding

                    lvalue++;

                }

            }

            int  digitno = digits.length -1;

            int  c;

            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;

                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.

                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');

            }

            this.decExponent = decExponent+1;

            this.firstDigitIndex = digitno;

            this.nDigits = this.digits.length - digitno;

        }

        private void dtoa( int binExp, long fractBits, int nSignificantBits, boolean isCompatibleFormat)

        {

            assert fractBits > 0 ; // fractBits here can't be zero or negative

            assert (fractBits & FRACT_HOB)!=0  ; // Hi-order bit should be set

            // 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.

            final int tailZeros = Long.numberOfTrailingZeros(fractBits);

            // number of significant bits of fractBits;

            final int nFractBits = EXP_SHIFT+1-tailZeros;

            // reset flags to default values as dtoa() does not always set these

            // flags and a prior call to dtoa() might have set them to incorrect

            // values with respect to the current state.

            decimalDigitsRoundedUp = false;

            exactDecimalConversion = false;

            // number of significant bits to the right of the point.

            int nTinyBits = Math.max( 0, nFractBits - binExp - 1 );

            if ( binExp <= MAX_SMALL_BIN_EXP && binExp >= MIN_SMALL_BIN_EXP ){

                // Look more closely at the number to decide if,

                // with scaling by 10^nTinyBits, the result will fit in

                // a long.

                if ( (nTinyBits < FDBigInteger.LONG_5_POW.length) && ((nFractBits + N_5_BITS[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 EXP_SHIFT-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.

                    //

                    if ( nTinyBits == 0 ) {

                        int insignificant;

                        if ( binExp > nSignificantBits ){

                            insignificant = insignificantDigitsForPow2(binExp-nSignificantBits-1);

                        } else {

                            insignificant = 0;

                        }

                        if ( binExp >= EXP_SHIFT ){

                            fractBits <<= (binExp-EXP_SHIFT);

                        } else {

                            fractBits >>>= (EXP_SHIFT-binExp) ;

                        }

                        developLongDigits( 0, fractBits, insignificant );

                        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 >>>= EXP_SHIFT+1-nFractBits;

                    //     fractBits//= long5pow[ nTinyBits ];

                    //     halfULP = long5pow[ nTinyBits ] >> (1+nSignificantBits-nFractBits);

                    //     developLongDigits( -nTinyBits, fractBits, insignificantDigits(halfULP) );

                    //     return;

                    // }

                    //

                }