[Forms][Meter][Progress] Change function signature of parseToDoubleForNumberType
[WebKit-https.git] / Source / WebCore / html / parser / HTMLParserIdioms.cpp
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. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
16  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
17  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
18  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
19  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
20  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
22  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23  */
24
25 #include "config.h"
26 #include "HTMLParserIdioms.h"
27
28 #include <limits>
29 #include <wtf/MathExtras.h>
30 #include <wtf/dtoa.h>
31 #include <wtf/text/AtomicString.h>
32 #include <wtf/text/StringBuilder.h>
33
34 namespace WebCore {
35
36 String stripLeadingAndTrailingHTMLSpaces(const String& string)
37 {
38     const UChar* characters = string.characters();
39     unsigned length = string.length();
40
41     unsigned numLeadingSpaces;
42     for (numLeadingSpaces = 0; numLeadingSpaces < length; ++numLeadingSpaces) {
43         if (isNotHTMLSpace(characters[numLeadingSpaces]))
44             break;
45     }
46
47     if (numLeadingSpaces == length)
48         return string.isNull() ? string : emptyAtom.string();
49
50     unsigned numTrailingSpaces;
51     for (numTrailingSpaces = 0; numTrailingSpaces < length; ++numTrailingSpaces) {
52         if (isNotHTMLSpace(characters[length - numTrailingSpaces - 1]))
53             break;
54     }
55
56     ASSERT(numLeadingSpaces + numTrailingSpaces < length);
57
58     return string.substring(numLeadingSpaces, length - (numLeadingSpaces + numTrailingSpaces));
59 }
60
61 String serializeForNumberType(double number)
62 {
63     // According to HTML5, "the best representation of the number n as a floating
64     // point number" is a string produced by applying ToString() to n.
65     NumberToStringBuffer buffer;
66     return String(numberToString(number, buffer));
67 }
68
69 double parseToDoubleForNumberType(const String& string, double fallbackValue)
70 {
71     // See HTML5 2.5.4.3 `Real numbers.'
72
73     // String::toDouble() accepts leading + and whitespace characters, which are not valid here.
74     UChar firstCharacter = string[0];
75     if (firstCharacter != '-' && firstCharacter != '.' && !isASCIIDigit(firstCharacter))
76         return fallbackValue;
77
78     bool valid = false;
79     double value = string.toDouble(&valid);
80     if (!valid)
81         return fallbackValue;
82
83     // NaN and infinity are considered valid by String::toDouble, but not valid here.
84     if (!isfinite(value))
85         return fallbackValue;
86
87     // Numbers are considered finite IEEE 754 single-precision floating point values.
88     // See HTML5 2.5.4.3 `Real numbers.'
89     if (-std::numeric_limits<float>::max() > value || value > std::numeric_limits<float>::max())
90         return fallbackValue;
91
92     // The following expression converts -0 to +0.
93     return value ? value : 0;
94 }
95
96 double parseToDoubleForNumberType(const String& string)
97 {
98     return parseToDoubleForNumberType(string, std::numeric_limits<double>::quiet_NaN());
99 }
100
101 double parseToDoubleForNumberTypeWithDecimalPlaces(const String& string, unsigned *decimalPlaces, double fallbackValue)
102 {
103     if (decimalPlaces)
104         *decimalPlaces = 0;
105
106     double value = parseToDoubleForNumberType(string, std::numeric_limits<double>::quiet_NaN());
107     if (!isfinite(value))
108         return fallbackValue;
109
110     if (!decimalPlaces)
111         return value;
112
113     size_t dotIndex = string.find('.');
114     size_t eIndex = string.find('e');
115     if (eIndex == notFound) 
116         eIndex = string.find('E');
117
118     unsigned baseDecimalPlaces = 0;
119     if (dotIndex != notFound) {
120         if (eIndex == notFound)
121             baseDecimalPlaces = string.length() - dotIndex - 1;
122         else
123             baseDecimalPlaces = eIndex - dotIndex - 1;
124     }
125
126     int exponent = 0;
127     if (eIndex != notFound) {
128         unsigned cursor = eIndex + 1, cursorSaved;
129         int digit, exponentSign;
130         int32_t exponent32;
131         size_t length = string.length();
132
133         // Not using String.toInt() in order to perform the same computation as dtoa() does.
134         exponentSign = 0;
135         switch (digit = string[cursor]) {
136         case '-':
137             exponentSign = 1;
138         case '+':
139             digit = string[++cursor];
140         }
141         if (digit >= '0' && digit <= '9') {
142             while (cursor < length && digit == '0')
143                 digit = string[++cursor];
144             if (digit > '0' && digit <= '9') {
145                 exponent32 = digit - '0';
146                 cursorSaved = cursor;
147                 while (cursor < length && (digit = string[++cursor]) >= '0' && digit <= '9')
148                     exponent32 = (10 * exponent32) + digit - '0';
149                 if (cursor - cursorSaved > 8 || exponent32 > 19999)
150                     /* Avoid confusion from exponents
151                      * so large that e might overflow.
152                      */
153                     exponent = 19999; /* safe for 16 bit ints */
154                 else
155                     exponent = static_cast<int>(exponent32);
156                 if (exponentSign)
157                     exponent = -exponent;
158             } else
159                 exponent = 0;
160         }
161     }
162
163     int intDecimalPlaces = baseDecimalPlaces - exponent;
164     if (intDecimalPlaces < 0)
165         *decimalPlaces = 0;
166     else if (intDecimalPlaces > 19999)
167         *decimalPlaces = 19999;
168     else
169         *decimalPlaces = static_cast<unsigned>(intDecimalPlaces);
170
171     return value;
172 }
173
174 double parseToDoubleForNumberTypeWithDecimalPlaces(const String& string, unsigned *decimalPlaces)
175 {
176     return parseToDoubleForNumberTypeWithDecimalPlaces(string, decimalPlaces, std::numeric_limits<double>::quiet_NaN());
177 }
178
179 // http://www.whatwg.org/specs/web-apps/current-work/#rules-for-parsing-integers
180 bool parseHTMLInteger(const String& input, int& value)
181 {
182     // Step 1
183     // Step 2
184     const UChar* position = input.characters();
185     const UChar* end = position + input.length();
186
187     // Step 3
188     int sign = 1;
189
190     // Step 4
191     while (position < end) {
192         if (!isHTMLSpace(*position))
193             break;
194         ++position;
195     }
196
197     // Step 5
198     if (position == end)
199         return false;
200     ASSERT(position < end);
201
202     // Step 6
203     if (*position == '-') {
204         sign = -1;
205         ++position;
206     } else if (*position == '+')
207         ++position;
208     if (position == end)
209         return false;
210     ASSERT(position < end);
211
212     // Step 7
213     if (!isASCIIDigit(*position))
214         return false;
215
216     // Step 8
217     StringBuilder digits;
218     while (position < end) {
219         if (!isASCIIDigit(*position))
220             break;
221         digits.append(*position++);
222     }
223
224     // Step 9
225     bool ok;
226     value = sign * charactersToIntStrict(digits.characters(), digits.length(), &ok);
227     return ok;
228 }
229
230 // http://www.whatwg.org/specs/web-apps/current-work/#rules-for-parsing-non-negative-integers
231 bool parseHTMLNonNegativeInteger(const String& input, unsigned int& value)
232 {
233     // Step 1
234     // Step 2
235     const UChar* position = input.characters();
236     const UChar* end = position + input.length();
237
238     // Step 3
239     while (position < end) {
240         if (!isHTMLSpace(*position))
241             break;
242         ++position;
243     }
244
245     // Step 4
246     if (position == end)
247         return false;
248     ASSERT(position < end);
249
250     // Step 5
251     if (*position == '+')
252         ++position;
253
254     // Step 6
255     if (position == end)
256         return false;
257     ASSERT(position < end);
258
259     // Step 7
260     if (!isASCIIDigit(*position))
261         return false;
262
263     // Step 8
264     StringBuilder digits;
265     while (position < end) {
266         if (!isASCIIDigit(*position))
267             break;
268         digits.append(*position++);
269     }
270
271     // Step 9
272     bool ok;
273     value = charactersToUIntStrict(digits.characters(), digits.length(), &ok);
274     return ok;
275 }
276
277 }