2011-11-19  Nikolas Zimmermann  <nzimmermann@rim.com>

        Add flags/precision arguments to String::number(double) to allow fine-grained control over the result string

        https://bugs.webkit.org/show_bug.cgi?id=72793

        Reviewed by NOBODY (OOPS!).

        This new code will be used in follow-up patches to replace the String::format("%.2f") usage in

        platform/text/TextStream.cpp, and String::format("%.6lg") usage in svg/SVGPathStringBuilder.cpp.

        The String::number(double) currently calls String::format("%.6lg") in trunk. In order to replace

        this by a variant that properly rounds to six significant figures, JSC code could be refactored.

        JSCs Number.toPrecision/toFixed uses wtf/dtoa/double-conversion which provides all features we need,

        except truncating trailing zeros, needed to mimic the "g" format, which is either f or e but with

        trailing zeros removed, producing shorter results. Changed the default signature to:

        "static String number(double, unsigned = ShouldRoundSignificantFigures | ShouldTruncateTrailingZeros, unsigned precision = 6);".

        In WebCore we can now replace String::format() calls like this:

        String::format("%.2f", f) -> String::number(f, ShouldRoundDecimalPlaces, 2)

        String::format("%.6lg", f) -> String::number(f)

        The default parameters for precison & flags exactly match the format of the string produced now, except that the result

        is rounded according to the rounding mode / formatting mode and precision. This paves the way towards reliable results

        in the d="" attribute dumps of SVG paths  across platforms. The dtoa rounding code enforces a unique zero, resolving

        all 0.0 vs. -0.0 issues currently seen on Windows, and some Gtk/Qt bots.

        * JavaScriptCore.exp: Change String::number(double) signature.

        * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def: Ditto.

        * runtime/NumberPrototype.cpp:

        (JSC::numberProtoFuncToFixed): Refactor this into numberToFixedPrecisionString(), move to wtf/dtoa.cpp.

        (JSC::numberProtoFuncToPrecision): Ditto, refactor this into numberToFixedWidthString.

        * wtf/dtoa.cpp: Moved fixedWidth/Precision helpers into dtoa, extend numberToFixedPrecisionString(). Add a mode which allows to truncate trailing zeros/decimal point.

                        to make it possible to use them to generate strings that match the output from String::format("%6.lg"), while using our dtoas rounding facilities.

        * wtf/dtoa.h:

        * wtf/dtoa/utils.h: Expose new helper method, which allows us to truncate the result, before generating the output const char*.

        (WTF::double_conversion::StringBuilder::SetPosition):

        * wtf/text/WTFString.cpp:

        (WTF::String::number): Remove String::format("%6.lg") usage! Switch to rounding to six significant figures, while matching the output of String::format.

        * wtf/text/WTFString.h:

__ZN3WTF11dtoaRoundDPEPcdiRbRiRj

__ZN3WTF11dtoaRoundSFEPcdiRbRiRj

    ?number@String@WTF@@SA?AV12@NII@Z

    ?numberToFixedPrecisionString@WTF@@YAPBDNIQAD_N@Z

    ?numberToFixedWidthString@WTF@@YAPBDNIQAD@Z

static inline const char* formatStringTruncatingTrailingZerosIfNeeded(NumberToStringBuffer buffer, double_conversion::StringBuilder& builder)

{

    size_t length = builder.position();

    size_t decimalPointPosition = 0;

    for (; decimalPointPosition < length; ++decimalPointPosition) {

        if (buffer[decimalPointPosition] == '.')

            break;

    }

    // No decimal seperator found, early exit.

    if (decimalPointPosition == length)

        return builder.Finalize();

    size_t truncatedLength = length - 1;

    for (; truncatedLength > decimalPointPosition; --truncatedLength) {

        if (buffer[truncatedLength] != '0')

            break;

    }

    // No trailing zeros found to strip.

    if (truncatedLength == length - 1)

        return builder.Finalize();

    // If we removed all trailing zeros, remove the decimal point as well.

    if (truncatedLength == decimalPointPosition) {

        ASSERT(truncatedLength > 0);

        --truncatedLength;

    }

    // Truncate the StringBuilder, and return the final result.

    builder.SetPosition(truncatedLength + 1);

    return builder.Finalize();

}

const char* numberToFixedPrecisionString(double d, unsigned significantFigures, NumberToStringBuffer buffer, bool truncateTrailingZeros)

{

    // Mimic String::format("%.[precision]g", ...), but use dtoas rounding facilities.

    // "g": Signed value printed in f or e format, whichever is more compact for the given value and precision.

    // The e format is used only when the exponent of the value is less than –4 or greater than or equal to the

    // precision argument. Trailing zeros are truncated, and the decimal point appears only if one or more digits follow it.

    // "precision": The precision specifies the maximum number of significant digits printed.

    double_conversion::StringBuilder builder(buffer, NumberToStringBufferLength);

    const double_conversion::DoubleToStringConverter& converter = double_conversion::DoubleToStringConverter::EcmaScriptConverter();

    converter.ToPrecision(d, significantFigures, &builder);

    if (!truncateTrailingZeros)

        return builder.Finalize();

    return formatStringTruncatingTrailingZerosIfNeeded(buffer, builder);

}

const char* numberToFixedWidthString(double d, unsigned decimalPlaces, NumberToStringBuffer buffer)

{

    // Mimic String::format("%.[precision]f", ...), but use dtoas rounding facilities.

    // "f": Signed value having the form [ – ]dddd.dddd, where dddd is one or more decimal digits.

    // The number of digits before the decimal point depends on the magnitude of the number, and

    // the number of digits after the decimal point depends on the requested precision.

    // "precision": The precision value specifies the number of digits after the decimal point.

    // If a decimal point appears, at least one digit appears before it.

    // The value is rounded to the appropriate number of digits.    

    double_conversion::StringBuilder builder(buffer, NumberToStringBufferLength);

    const double_conversion::DoubleToStringConverter& converter = double_conversion::DoubleToStringConverter::EcmaScriptConverter();

    converter.ToFixed(d, decimalPlaces, &builder);

    return builder.Finalize();

}

using WTF::numberToFixedPrecisionString;

using WTF::numberToFixedWidthString;

        // Set the current position in the builder.

        void SetPosition(int position)

        {

            ASSERT(!is_finalized());

            ASSERT(position < size());

            position_ = position;

        }

enum FloatConversionFlags {

    ShouldRoundSignificantFigures = 1 << 0,

    ShouldRoundDecimalPlaces = 1 << 1,

    ShouldTruncateTrailingZeros = 1 << 2

};

using WTF::ShouldRoundDecimalPlaces;