1/*
2 * Copyright (C) 2010 Apple Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 *    notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 *    notice, this list of conditions and the following disclaimer in the
11 *    documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 */
25
26#include "config.h"
27#include "DecimalNumber.h"
28#include <math.h>
29#include <wtf/MathExtras.h>
30#include <wtf/text/WTFString.h>
31
32namespace WTF {
33
34unsigned DecimalNumber::bufferLengthForStringDecimal() const
35{
36    unsigned length = 0;
37    // if the exponent is negative the number decimal representation is of the form:
38    // [<sign>]0.[<zeros>]<significand>
39    if (m_exponent < 0) {
40        if (m_sign)
41            ++length;
42        length += 2; // for "0."
43        length += -m_exponent - 1;
44        length += m_precision;
45        return length;
46    }
47
48    unsigned digitsBeforeDecimalPoint = m_exponent + 1;
49
50    // If the precision is <= than the number of digits to get up to the decimal
51    // point, then there is no fractional part, number is of the form:
52    // [<sign>]<significand>[<zeros>]
53    if (m_precision <= digitsBeforeDecimalPoint) {
54        if (m_sign)
55            ++length;
56        length += m_precision;
57        length += digitsBeforeDecimalPoint - m_precision;
58        return length;
59    }
60
61    // If we get here, number starts before the decimal point, and ends after it,
62    // as such is of the form:
63    // [<sign>]<significand-begin>.<significand-end>
64    if (m_sign)
65        ++length;
66    length += digitsBeforeDecimalPoint;
67    ++length; // for decimal point
68    length += m_precision - digitsBeforeDecimalPoint;
69
70    return length;
71}
72
73unsigned DecimalNumber::bufferLengthForStringExponential() const
74{
75    unsigned length = 0;
76    if (m_sign)
77        ++length;
78
79    // Add the significand
80    ++length;
81
82    if (m_precision > 1) {
83        ++length; // for decimal point
84        length += m_precision - 1;
85    }
86
87    // Add "e+" or "e-"
88    length += 2;
89
90    int exponent = (m_exponent >= 0) ? m_exponent : -m_exponent;
91
92    // Add the exponent
93    if (exponent >= 100)
94        ++length;
95    if (exponent >= 10)
96        ++length;
97    ++length;
98
99    return length;
100}
101
102unsigned DecimalNumber::toStringDecimal(LChar* buffer, unsigned bufferLength) const
103{
104    ASSERT_UNUSED(bufferLength, bufferLength >= bufferLengthForStringDecimal());
105
106    // Should always be at least one digit to add to the string!
107    ASSERT(m_precision);
108    LChar* next = buffer;
109
110    // if the exponent is negative the number decimal representation is of the form:
111    // [<sign>]0.[<zeros>]<significand>
112    if (m_exponent < 0) {
113        unsigned zeros = -m_exponent - 1;
114
115        if (m_sign)
116            *next++ = '-';
117        *next++ = '0';
118        *next++ = '.';
119        for (unsigned i = 0; i < zeros; ++i)
120            *next++ = '0';
121        for (unsigned i = 0; i < m_precision; ++i)
122            *next++ = m_significand[i];
123
124        return next - buffer;
125    }
126
127    unsigned digitsBeforeDecimalPoint = m_exponent + 1;
128
129    // If the precision is <= than the number of digits to get up to the decimal
130    // point, then there is no fractional part, number is of the form:
131    // [<sign>]<significand>[<zeros>]
132    if (m_precision <= digitsBeforeDecimalPoint) {
133        if (m_sign)
134            *next++ = '-';
135        for (unsigned i = 0; i < m_precision; ++i)
136            *next++ = m_significand[i];
137        for (unsigned i = 0; i < (digitsBeforeDecimalPoint - m_precision); ++i)
138            *next++ = '0';
139
140        return next - buffer;
141    }
142
143    // If we get here, number starts before the decimal point, and ends after it,
144    // as such is of the form:
145    // [<sign>]<significand-begin>.<significand-end>
146
147    if (m_sign)
148        *next++ = '-';
149    for (unsigned i = 0; i < digitsBeforeDecimalPoint; ++i)
150        *next++ = m_significand[i];
151    *next++ = '.';
152    for (unsigned i = digitsBeforeDecimalPoint; i < m_precision; ++i)
153        *next++ = m_significand[i];
154
155    return next - buffer;
156}
157
158unsigned DecimalNumber::toStringExponential(LChar* buffer, unsigned bufferLength) const
159{
160    ASSERT_UNUSED(bufferLength, bufferLength >= bufferLengthForStringExponential());
161
162    // Should always be at least one digit to add to the string!
163    ASSERT(m_precision);
164    LChar* next = buffer;
165
166    // Add the sign
167    if (m_sign)
168        *next++ = '-';
169
170    // Add the significand
171    *next++ = m_significand[0];
172    if (m_precision > 1) {
173        *next++ = '.';
174        for (unsigned i = 1; i < m_precision; ++i)
175            *next++ = m_significand[i];
176    }
177
178    // Add "e+" or "e-"
179    *next++ = 'e';
180    int exponent;
181    if (m_exponent >= 0) {
182        *next++ = '+';
183        exponent = m_exponent;
184    } else {
185        *next++ = '-';
186        exponent = -m_exponent;
187    }
188
189    // Add the exponent
190    if (exponent >= 100)
191        *next++ = '0' + exponent / 100;
192    if (exponent >= 10)
193        *next++ = '0' + (exponent % 100) / 10;
194    *next++ = '0' + exponent % 10;
195
196    return next - buffer;
197}
198
199} // namespace WTF
200