Update std::expected to match libc++ coding style
[WebKit-https.git] / Source / WebCore / html / parser / HTMLParserIdioms.h
1 /*
2  * Copyright (C) 2010-2017 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 #pragma once
26
27 #include <unicode/uchar.h>
28 #include <wtf/Expected.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 isNotHTMLSpace(CharacterType);
42 template<typename CharacterType> bool isComma(CharacterType);
43 template<typename CharacterType> bool isHTMLSpaceOrComma(CharacterType);
44 bool isHTMLLineBreak(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 enum class HTMLIntegerParsingError { NegativeOverflow, PositiveOverflow, Other };
67
68 WEBCORE_EXPORT Expected<int, HTMLIntegerParsingError> parseHTMLInteger(StringView);
69
70 // http://www.whatwg.org/specs/web-apps/current-work/#rules-for-parsing-non-negative-integers
71 WEBCORE_EXPORT Expected<unsigned, HTMLIntegerParsingError> parseHTMLNonNegativeInteger(StringView);
72
73 // https://html.spec.whatwg.org/#valid-non-negative-integer
74 std::optional<int> parseValidHTMLNonNegativeInteger(StringView);
75
76 // https://html.spec.whatwg.org/#valid-floating-point-number
77 std::optional<double> parseValidHTMLFloatingPointNumber(StringView);
78
79 // https://html.spec.whatwg.org/multipage/infrastructure.html#rules-for-parsing-floating-point-number-values
80 Vector<double> parseHTMLListOfOfFloatingPointNumberValues(StringView);
81
82 // https://html.spec.whatwg.org/multipage/semantics.html#attr-meta-http-equiv-refresh
83 bool parseMetaHTTPEquivRefresh(const StringView&, double& delay, String& url);
84
85 // https://html.spec.whatwg.org/multipage/infrastructure.html#cors-settings-attribute
86 String parseCORSSettingsAttribute(const AtomicString&);
87
88 bool threadSafeMatch(const QualifiedName&, const QualifiedName&);
89
90 AtomicString parseHTMLHashNameReference(StringView);
91
92 // Inline implementations of some of the functions declared above.
93
94 template<typename CharacterType> inline bool isHTMLSpace(CharacterType character)
95 {
96     // Histogram from Apple's page load test combined with some ad hoc browsing some other test suites.
97     //
98     //     82%: 216330 non-space characters, all > U+0020
99     //     11%:  30017 plain space characters, U+0020
100     //      5%:  12099 newline characters, U+000A
101     //      2%:   5346 tab characters, U+0009
102     //
103     // No other characters seen. No U+000C or U+000D, and no other control characters.
104     // Accordingly, we check for non-spaces first, then space, then newline, then tab, then the other characters.
105
106     return character <= ' ' && (character == ' ' || character == '\n' || character == '\t' || character == '\r' || character == '\f');
107 }
108
109 template<typename CharacterType> inline bool isNotHTMLSpace(CharacterType character)
110 {
111     return !isHTMLSpace(character);
112 }
113
114 inline bool isHTMLLineBreak(UChar character)
115 {
116     return character <= '\r' && (character == '\n' || character == '\r');
117 }
118
119 template<typename CharacterType> inline bool isComma(CharacterType character)
120 {
121     return character == ',';
122 }
123
124 template<typename CharacterType> inline bool isHTMLSpaceOrComma(CharacterType character)
125 {
126     return isComma(character) || isHTMLSpace(character);
127 }
128
129 inline bool isHTMLSpaceButNotLineBreak(UChar character)
130 {
131     return isHTMLSpace(character) && !isHTMLLineBreak(character);
132 }
133
134 // https://html.spec.whatwg.org/multipage/infrastructure.html#limited-to-only-non-negative-numbers-greater-than-zero
135 inline unsigned limitToOnlyHTMLNonNegativeNumbersGreaterThanZero(unsigned value, unsigned defaultValue = 1)
136 {
137     return (value > 0 && value <= maxHTMLNonNegativeInteger) ? value : defaultValue;
138 }
139
140 inline unsigned limitToOnlyHTMLNonNegativeNumbersGreaterThanZero(StringView stringValue, unsigned defaultValue = 1)
141 {
142     ASSERT(defaultValue > 0);
143     ASSERT(defaultValue <= maxHTMLNonNegativeInteger);
144     auto optionalValue = parseHTMLNonNegativeInteger(stringValue);
145     unsigned value = optionalValue && optionalValue.value() ? optionalValue.value() : defaultValue;
146     ASSERT(value > 0);
147     ASSERT(value <= maxHTMLNonNegativeInteger);
148     return value;
149 }
150
151 // https://html.spec.whatwg.org/#reflecting-content-attributes-in-idl-attributes:idl-unsigned-long
152 inline unsigned limitToOnlyHTMLNonNegative(unsigned value, unsigned defaultValue = 0)
153 {
154     ASSERT(defaultValue <= maxHTMLNonNegativeInteger);
155     return value <= maxHTMLNonNegativeInteger ? value : defaultValue;
156 }
157
158 inline unsigned limitToOnlyHTMLNonNegative(StringView stringValue, unsigned defaultValue = 0)
159 {
160     ASSERT(defaultValue <= maxHTMLNonNegativeInteger);
161     unsigned value = parseHTMLNonNegativeInteger(stringValue).value_or(defaultValue);
162     ASSERT(value <= maxHTMLNonNegativeInteger);
163     return value;
164 }
165
166 // https://html.spec.whatwg.org/#clamped-to-the-range
167 inline unsigned clampHTMLNonNegativeIntegerToRange(StringView stringValue, unsigned min, unsigned max, unsigned defaultValue = 0)
168 {
169     ASSERT(defaultValue >= min);
170     ASSERT(defaultValue <= max);
171     auto optionalValue = parseHTMLNonNegativeInteger(stringValue);
172     if (optionalValue)
173         return std::min(std::max(optionalValue.value(), min), max);
174
175     return optionalValue.error() == HTMLIntegerParsingError::PositiveOverflow ? max : defaultValue;
176 }
177
178 } // namespace WebCore