058bb9339cfff5d183e49f7d258825873020ca12
[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     unsigned length = numberToString(number, buffer);
67     return String(buffer, length);
68 }
69
70 bool parseToDoubleForNumberType(const String& string, double* result)
71 {
72     // See HTML5 2.4.4.3 `Real numbers.'
73
74     // String::toDouble() accepts leading + and whitespace characters, which are not valid here.
75     UChar firstCharacter = string[0];
76     if (firstCharacter != '-' && !isASCIIDigit(firstCharacter))
77         return false;
78
79     bool valid = false;
80     double value = string.toDouble(&valid);
81     if (!valid)
82         return false;
83
84     // NaN and infinity are considered valid by String::toDouble, but not valid here.
85     if (!isfinite(value))
86         return false;
87
88     // Numbers are considered finite IEEE 754 single-precision floating point values.
89     // See HTML5 2.4.4.3 `Real numbers.'
90     if (-std::numeric_limits<float>::max() > value || value > std::numeric_limits<float>::max())
91         return false;
92
93     if (result) {
94         // The following expression converts -0 to +0.
95         *result = value ? value : 0;
96     }
97
98     return true;
99 }
100
101 bool parseToDoubleForNumberTypeWithDecimalPlaces(const String& string, double *result, unsigned *decimalPlaces)
102 {
103     if (decimalPlaces)
104         *decimalPlaces = 0;
105
106     if (!parseToDoubleForNumberType(string, result))
107         return false;
108
109     if (!decimalPlaces)
110         return true;
111
112     size_t dotIndex = string.find('.');
113     size_t eIndex = string.find('e');
114     if (eIndex == notFound) 
115         eIndex = string.find('E');
116
117     unsigned baseDecimalPlaces = 0;
118     if (dotIndex != notFound) {
119         if (eIndex == notFound)
120             baseDecimalPlaces = string.length() - dotIndex - 1;
121         else
122             baseDecimalPlaces = eIndex - dotIndex - 1;
123     }
124
125     int exponent = 0;
126     if (eIndex != notFound) {
127         unsigned cursor = eIndex + 1, cursorSaved;
128         int digit, exponentSign;
129         int32_t exponent32;
130         size_t length = string.length();
131
132         // Not using String.toInt() in order to perform the same computation as dtoa() does.
133         exponentSign = 0;
134         switch (digit = string[cursor]) {
135         case '-':
136             exponentSign = 1;
137         case '+':
138             digit = string[++cursor];
139         }
140         if (digit >= '0' && digit <= '9') {
141             while (cursor < length && digit == '0')
142                 digit = string[++cursor];
143             if (digit > '0' && digit <= '9') {
144                 exponent32 = digit - '0';
145                 cursorSaved = cursor;
146                 while (cursor < length && (digit = string[++cursor]) >= '0' && digit <= '9')
147                     exponent32 = (10 * exponent32) + digit - '0';
148                 if (cursor - cursorSaved > 8 || exponent32 > 19999)
149                     /* Avoid confusion from exponents
150                      * so large that e might overflow.
151                      */
152                     exponent = 19999; /* safe for 16 bit ints */
153                 else
154                     exponent = static_cast<int>(exponent32);
155                 if (exponentSign)
156                     exponent = -exponent;
157             } else
158                 exponent = 0;
159         }
160     }
161
162     int intDecimalPlaces = baseDecimalPlaces - exponent;
163     if (intDecimalPlaces < 0)
164         *decimalPlaces = 0;
165     else if (intDecimalPlaces > 19999)
166         *decimalPlaces = 19999;
167     else
168         *decimalPlaces = static_cast<unsigned>(intDecimalPlaces);
169
170     return true;
171 }
172
173 // http://www.whatwg.org/specs/web-apps/current-work/#rules-for-parsing-integers
174 bool parseHTMLInteger(const String& input, int& value)
175 {
176     // Step 1
177     // Step 2
178     const UChar* position = input.characters();
179     const UChar* end = position + input.length();
180
181     // Step 3
182     int sign = 1;
183
184     // Step 4
185     while (position < end) {
186         if (!isHTMLSpace(*position))
187             break;
188         ++position;
189     }
190
191     // Step 5
192     if (position == end)
193         return false;
194     ASSERT(position < end);
195
196     // Step 6
197     if (*position == '-') {
198         sign = -1;
199         ++position;
200     } else if (*position == '+')
201         ++position;
202     if (position == end)
203         return false;
204     ASSERT(position < end);
205
206     // Step 7
207     if (!isASCIIDigit(*position))
208         return false;
209
210     // Step 8
211     Vector<UChar, 16> digits;
212     while (position < end) {
213         if (!isASCIIDigit(*position))
214             break;
215         digits.append(*position++);
216     }
217
218     // Step 9
219     value = sign * charactersToIntStrict(digits.data(), digits.size());
220     return true;
221 }
222
223 // http://www.whatwg.org/specs/web-apps/current-work/#rules-for-parsing-non-negative-integers
224 bool parseHTMLNonNegativeInteger(const String& input, unsigned int& value)
225 {
226     // Step 1
227     // Step 2
228     const UChar* position = input.characters();
229     const UChar* end = position + input.length();
230
231     // Step 3
232     while (position < end) {
233         if (!isHTMLSpace(*position))
234             break;
235         ++position;
236     }
237
238     // Step 4
239     if (position == end)
240         return false;
241     ASSERT(position < end);
242
243     // Step 5
244     if (*position == '+')
245         ++position;
246
247     // Step 6
248     if (position == end)
249         return false;
250     ASSERT(position < end);
251
252     // Step 7
253     if (!isASCIIDigit(*position))
254         return false;
255
256     // Step 8
257     Vector<UChar, 16> digits;
258     while (position < end) {
259         if (!isASCIIDigit(*position))
260             break;
261         digits.append(*position++);
262     }
263
264     // Step 9
265     value = charactersToUIntStrict(digits.data(), digits.size());
266     return true;
267 }
268
269 }