Integrate most of GoogleURL in WTFURL
[WebKit-https.git] / Source / WTF / wtf / url / src / URLParseInternal.h
1 /*
2  * Copyright 2007 Google Inc. All rights reserved.
3  * Copyright 2012 Apple Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are
7  * met:
8  *
9  *     * Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *     * Redistributions in binary form must reproduce the above
12  * copyright notice, this list of conditions and the following disclaimer
13  * in the documentation and/or other materials provided with the
14  * distribution.
15  *     * Neither the name of Google Inc. nor the names of its
16  * contributors may be used to endorse or promote products derived from
17  * this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 // Contains common inline helper functions used by the URL parsing routines.
33
34 #ifndef URLParseInternal_h
35 #define URLParseInternal_h
36
37 #include "URLParse.h"
38 #include <wtf/unicode/Unicode.h>
39
40 #if USE(WTFURL)
41
42 namespace WTF {
43
44 namespace URLParser {
45
46 // We treat slashes and backslashes the same for IE compatability.
47 inline bool isURLSlash(UChar ch)
48 {
49     return ch == '/' || ch == '\\';
50 }
51
52 // Returns true if we should trim this character from the URL because it is a
53 // space or a control character.
54 inline bool shouldTrimFromURL(UChar ch)
55 {
56     return ch <= ' ';
57 }
58
59 // Given an already-initialized begin index and length, this shrinks the range
60 // to eliminate "should-be-trimmed" characters. Note that the length does *not*
61 // indicate the length of untrimmed data from |*begin|, but rather the position
62 // in the input string (so the string starts at character |*begin| in the spec,
63 // and goes until |*len|).
64 template<typename CharacterType>
65 inline void trimURL(const CharacterType* spec, int& begin, int& length)
66 {
67     // Strip leading whitespace and control characters.
68     while (begin < length && shouldTrimFromURL(spec[begin]))
69         ++begin;
70
71     // Strip trailing whitespace and control characters. We need the >i test for
72     // when the input string is all blanks; we don't want to back past the input.
73     while (length > begin && shouldTrimFromURL(spec[length - 1]))
74         --length;
75 }
76
77 // Counts the number of consecutive slashes starting at the given offset
78 // in the given string of the given length.
79 template<typename CharacterType>
80 inline int countConsecutiveSlashes(const CharacterType *str, int begin_offset, int strLength)
81 {
82     int count = 0;
83     while (begin_offset + count < strLength && isURLSlash(str[begin_offset + count]))
84         ++count;
85     return count;
86 }
87
88 // Internal functions in URLParser.cc that parse the path, that is, everything
89 // following the authority section. The input is the range of everything
90 // following the authority section, and the output is the identified ranges.
91 //
92 // This is designed for the file URL parser or other consumers who may do
93 // special stuff at the beginning, but want regular path parsing, it just
94 // maps to the internal parsing function for paths.
95 void parsePathInternal(const char* spec,
96                        const URLComponent& path,
97                        URLComponent* filepath,
98                        URLComponent* query,
99                        URLComponent* fragment);
100 void parsePathInternal(const UChar* spec,
101                        const URLComponent& path,
102                        URLComponent* filepath,
103                        URLComponent* query,
104                        URLComponent* fragment);
105
106
107 // Given a spec and a pointer to the character after the colon following the
108 // scheme, this parses it and fills in the structure, Every item in the parsed
109 // structure is filled EXCEPT for the scheme, which is untouched.
110 void parseAfterScheme(const char* spec, int specLength, int afterScheme, URLSegments& parsed);
111 void parseAfterScheme(const UChar* spec, int specLength, int afterScheme, URLSegments& parsed);
112
113 } // namespace URLParser
114
115 } // namespace WTF
116
117 #endif // USE(WTFURL)
118
119 #endif // URLParseInternal_h