parseHTMLInteger() should take a StringView in parameter
[WebKit-https.git] / Source / WebCore / html / parser / HTMLParserIdioms.h
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 #ifndef HTMLParserIdioms_h
26 #define HTMLParserIdioms_h
27
28 #include <unicode/uchar.h>
29 #include <wtf/Forward.h>
30 #include <wtf/Optional.h>
31 #include <wtf/Vector.h>
32 #include <wtf/text/StringView.h>
33
34 namespace WebCore {
35
36 class Decimal;
37 class QualifiedName;
38
39 // Space characters as defined by the HTML specification.
40 template<typename CharacterType> bool isHTMLSpace(CharacterType);
41 template<typename CharacterType> bool isComma(CharacterType);
42 template<typename CharacterType> bool isHTMLSpaceOrComma(CharacterType);
43 bool isHTMLLineBreak(UChar);
44 bool isNotHTMLSpace(UChar);
45 bool isHTMLSpaceButNotLineBreak(UChar);
46
47 // 2147483647 is 2^31 - 1.
48 static const unsigned maxHTMLNonNegativeInteger = 2147483647;
49
50 // Strip leading and trailing whitespace as defined by the HTML specification. 
51 WEBCORE_EXPORT String stripLeadingAndTrailingHTMLSpaces(const String&);
52
53 // An implementation of the HTML specification's algorithm to convert a number to a string for number and range types.
54 String serializeForNumberType(const Decimal&);
55 String serializeForNumberType(double);
56
57 // Convert the specified string to a decimal/double. If the conversion fails, the return value is fallback value or NaN if not specified.
58 // Leading or trailing illegal characters cause failure, as does passing an empty string.
59 // The double* parameter may be 0 to check if the string can be parsed without getting the result.
60 Decimal parseToDecimalForNumberType(const String&);
61 Decimal parseToDecimalForNumberType(const String&, const Decimal& fallbackValue);
62 double parseToDoubleForNumberType(const String&);
63 double parseToDoubleForNumberType(const String&, double fallbackValue);
64
65 // http://www.whatwg.org/specs/web-apps/current-work/#rules-for-parsing-integers
66 WEBCORE_EXPORT Optional<int> parseHTMLInteger(StringView);
67
68 // http://www.whatwg.org/specs/web-apps/current-work/#rules-for-parsing-non-negative-integers
69 WEBCORE_EXPORT Optional<unsigned> parseHTMLNonNegativeInteger(StringView);
70
71 // https://html.spec.whatwg.org/#valid-non-negative-integer
72 Optional<int> parseValidHTMLNonNegativeInteger(StringView);
73
74 // https://html.spec.whatwg.org/#valid-floating-point-number
75 Optional<double> parseValidHTMLFloatingPointNumber(StringView);
76
77 // https://html.spec.whatwg.org/multipage/infrastructure.html#rules-for-parsing-floating-point-number-values
78 Vector<double> parseHTMLListOfOfFloatingPointNumberValues(StringView);
79
80 // https://html.spec.whatwg.org/multipage/semantics.html#attr-meta-http-equiv-refresh
81 bool parseMetaHTTPEquivRefresh(const StringView&, double& delay, String& url);
82
83 // https://html.spec.whatwg.org/multipage/infrastructure.html#cors-settings-attribute
84 String parseCORSSettingsAttribute(const AtomicString&);
85
86 bool threadSafeMatch(const QualifiedName&, const QualifiedName&);
87
88 // Inline implementations of some of the functions declared above.
89
90 template<typename CharacterType> inline bool isHTMLSpace(CharacterType character)
91 {
92     // Histogram from Apple's page load test combined with some ad hoc browsing some other test suites.
93     //
94     //     82%: 216330 non-space characters, all > U+0020
95     //     11%:  30017 plain space characters, U+0020
96     //      5%:  12099 newline characters, U+000A
97     //      2%:   5346 tab characters, U+0009
98     //
99     // No other characters seen. No U+000C or U+000D, and no other control characters.
100     // Accordingly, we check for non-spaces first, then space, then newline, then tab, then the other characters.
101
102     return character <= ' ' && (character == ' ' || character == '\n' || character == '\t' || character == '\r' || character == '\f');
103 }
104
105 inline bool isHTMLLineBreak(UChar character)
106 {
107     return character <= '\r' && (character == '\n' || character == '\r');
108 }
109
110 template<typename CharacterType> inline bool isComma(CharacterType character)
111 {
112     return character == ',';
113 }
114
115 template<typename CharacterType> inline bool isHTMLSpaceOrComma(CharacterType character)
116 {
117     return isComma(character) || isHTMLSpace(character);
118 }
119
120 inline bool isNotHTMLSpace(UChar character)
121 {
122     return !isHTMLSpace(character);
123 }
124
125 inline bool isHTMLSpaceButNotLineBreak(UChar character)
126 {
127     return isHTMLSpace(character) && !isHTMLLineBreak(character);
128 }
129
130 // https://html.spec.whatwg.org/multipage/infrastructure.html#limited-to-only-non-negative-numbers-greater-than-zero
131 inline unsigned limitToOnlyHTMLNonNegativeNumbersGreaterThanZero(unsigned value, unsigned defaultValue = 1)
132 {
133     return (value > 0 && value <= maxHTMLNonNegativeInteger) ? value : defaultValue;
134 }
135
136 inline unsigned limitToOnlyHTMLNonNegativeNumbersGreaterThanZero(StringView stringValue, unsigned defaultValue = 1)
137 {
138     ASSERT(defaultValue > 0);
139     ASSERT(defaultValue <= maxHTMLNonNegativeInteger);
140     auto optionalValue = parseHTMLNonNegativeInteger(stringValue);
141     unsigned value = optionalValue && optionalValue.value() ? optionalValue.value() : defaultValue;
142     ASSERT(value > 0);
143     ASSERT(value <= maxHTMLNonNegativeInteger);
144     return value;
145 }
146
147 // https://html.spec.whatwg.org/#reflecting-content-attributes-in-idl-attributes:idl-unsigned-long
148 inline unsigned limitToOnlyHTMLNonNegative(unsigned value, unsigned defaultValue = 0)
149 {
150     ASSERT(defaultValue <= maxHTMLNonNegativeInteger);
151     return value <= maxHTMLNonNegativeInteger ? value : defaultValue;
152 }
153
154 inline unsigned limitToOnlyHTMLNonNegative(StringView stringValue, unsigned defaultValue = 0)
155 {
156     ASSERT(defaultValue <= maxHTMLNonNegativeInteger);
157     unsigned value = parseHTMLNonNegativeInteger(stringValue).valueOr(defaultValue);
158     ASSERT(value <= maxHTMLNonNegativeInteger);
159     return value;
160 }
161
162 }
163
164 #endif