/*

 * Copyright (C) 2004, 2007 Apple Inc.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

#include "config.h"

#include "KURL.h"

#include "CString.h"

#include "PlatformString.h"

#include "RegularExpression.h"

#include "TextEncoding.h"

#include <wtf/Vector.h>

#if USE(ICU_UNICODE)

#include <unicode/uidna.h>

#elif USE(QT4_UNICODE)

#include <QUrl>

#endif

using namespace std;

namespace WebCore {

enum URLCharacterClasses {

    // alpha 

    SchemeFirstChar = 1 << 0,

    // ( alpha | digit | "+" | "-" | "." )

    SchemeChar = 1 << 1,

    // mark        = "-" | "_" | "." | "!" | "~" | "*" | "'" | "(" | ")"

    // unreserved  = alphanum | mark

    // ( unreserved | escaped | ";" | ":" | "&" | "=" | "+" | "$" | "," )

    UserInfoChar = 1 << 2,

    // alnum | "." | "-" | "%"

    // The above is what the specification says, but we are lenient to

    // match existing practice and also allow:

    // "_"

    HostnameChar = 1 << 3,

    // hexdigit | ":" | "%"

    IPv6Char = 1 << 4,

    // "#" | "?" | "/" | nul

    PathSegmentEndChar = 1 << 5,

    // digit | "A" | "B" | "C" | "D" | "E" | "F" | "a" | "b" | "c" | "d" | "e" | "f"

    HexDigitChar = 1 << 6,

    // not allowed in path

    BadChar = 1 << 7

};

static const char hexDigits[17] = "0123456789ABCDEF";

static const unsigned char characterClassTable[256] = {

    /* 0 nul */ PathSegmentEndChar,    /* 1 soh */ BadChar,

    /* 2 stx */ BadChar,    /* 3 etx */ BadChar,    

    /* 4 eot */ BadChar,    /* 5 enq */ BadChar,    /* 6 ack */ BadChar,    /* 7 bel */ BadChar,

    /* 8 bs */ BadChar,     /* 9 ht */ BadChar,    /* 10 nl */ BadChar,    /* 11 vt */ BadChar,

    /* 12 np */ BadChar,    /* 13 cr */ BadChar,    /* 14 so */ BadChar,    /* 15 si */ BadChar,

    /* 16 dle */ BadChar,   /* 17 dc1 */ BadChar,   /* 18 dc2 */ BadChar,   /* 19 dc3 */ BadChar,

    /* 20 dc4 */ BadChar,   /* 21 nak */ BadChar,   /* 22 syn */ BadChar,   /* 23 etb */ BadChar,

    /* 24 can */ BadChar,   /* 25 em */ BadChar,    /* 26 sub */ BadChar,   /* 27 esc */ BadChar,

    /* 28 fs */ BadChar,    /* 29 gs */ BadChar,    /* 30 rs */ BadChar,    /* 31 us */ BadChar,

    /* 32 sp */ BadChar,    /* 33  ! */ UserInfoChar,

    /* 34  " */ BadChar,    /* 35  # */ PathSegmentEndChar | BadChar,    

    /* 36  $ */ UserInfoChar,    /* 37  % */ UserInfoChar | HostnameChar | IPv6Char | BadChar,

    /* 38  & */ UserInfoChar,    /* 39  ' */ UserInfoChar,

    /* 40  ( */ UserInfoChar,    /* 41  ) */ UserInfoChar,    

    /* 42  * */ UserInfoChar,    /* 43  + */ SchemeChar | UserInfoChar,

    /* 44  , */ UserInfoChar,    

    /* 45  - */ SchemeChar | UserInfoChar | HostnameChar, 

    /* 46  . */ SchemeChar | UserInfoChar | HostnameChar,   

    /* 47  / */ PathSegmentEndChar,

    /* 48  0 */ SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char, 

    /* 49  1 */ SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,    

    /* 50  2 */ SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char, 

    /* 51  3 */ SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,

    /* 52  4 */ SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char, 

    /* 53  5 */ SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,

    /* 54  6 */ SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char, 

    /* 55  7 */ SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,

    /* 56  8 */ SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char, 

    /* 57  9 */ SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,

    /* 58  : */ UserInfoChar | IPv6Char,    /* 59  ; */ UserInfoChar,

    /* 60  < */ BadChar,    /* 61  = */ UserInfoChar,

    /* 62  > */ BadChar,    /* 63  ? */ PathSegmentEndChar | BadChar,

    /* 64  @ */ 0,

    /* 65  A */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,    

    /* 66  B */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,

    /* 67  C */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,

    /* 68  D */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,

    /* 69  E */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,

    /* 70  F */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,

    /* 71  G */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 72  H */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 73  I */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 74  J */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 75  K */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 76  L */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 77  M */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 78  N */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 79  O */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 80  P */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 81  Q */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 82  R */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 83  S */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 84  T */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 85  U */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 86  V */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 87  W */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 88  X */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 

    /* 89  Y */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 90  Z */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 91  [ */ 0,

    /* 92  \ */ 0,    /* 93  ] */ 0,

    /* 94  ^ */ 0,

    /* 95  _ */ UserInfoChar | HostnameChar,

    /* 96  ` */ 0,

    /* 97  a */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,

    /* 98  b */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char, 

    /* 99  c */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,

    /* 100  d */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char, 

    /* 101  e */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,

    /* 102  f */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char, 

    /* 103  g */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 104  h */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 

    /* 105  i */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 106  j */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 

    /* 107  k */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 108  l */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 

    /* 109  m */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 110  n */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 

    /* 111  o */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 112  p */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 

    /* 113  q */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 114  r */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 

    /* 115  s */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 116  t */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 

    /* 117  u */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 118  v */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 

    /* 119  w */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 120  x */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 

    /* 121  y */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,

    /* 122  z */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 

    /* 123  { */ 0,

    /* 124  | */ 0,   /* 125  } */ 0,   /* 126  ~ */ UserInfoChar,   /* 127 del */ BadChar,

    /* 128 */ BadChar, /* 129 */ BadChar, /* 130 */ BadChar, /* 131 */ BadChar,

    /* 132 */ BadChar, /* 133 */ BadChar, /* 134 */ BadChar, /* 135 */ BadChar,

    /* 136 */ BadChar, /* 137 */ BadChar, /* 138 */ BadChar, /* 139 */ BadChar,

    /* 140 */ BadChar, /* 141 */ BadChar, /* 142 */ BadChar, /* 143 */ BadChar,

    /* 144 */ BadChar, /* 145 */ BadChar, /* 146 */ BadChar, /* 147 */ BadChar,

    /* 148 */ BadChar, /* 149 */ BadChar, /* 150 */ BadChar, /* 151 */ BadChar,

    /* 152 */ BadChar, /* 153 */ BadChar, /* 154 */ BadChar, /* 155 */ BadChar,

    /* 156 */ BadChar, /* 157 */ BadChar, /* 158 */ BadChar, /* 159 */ BadChar,

    /* 160 */ BadChar, /* 161 */ BadChar, /* 162 */ BadChar, /* 163 */ BadChar,

    /* 164 */ BadChar, /* 165 */ BadChar, /* 166 */ BadChar, /* 167 */ BadChar,

    /* 168 */ BadChar, /* 169 */ BadChar, /* 170 */ BadChar, /* 171 */ BadChar,

    /* 172 */ BadChar, /* 173 */ BadChar, /* 174 */ BadChar, /* 175 */ BadChar,

    /* 176 */ BadChar, /* 177 */ BadChar, /* 178 */ BadChar, /* 179 */ BadChar,

    /* 180 */ BadChar, /* 181 */ BadChar, /* 182 */ BadChar, /* 183 */ BadChar,

    /* 184 */ BadChar, /* 185 */ BadChar, /* 186 */ BadChar, /* 187 */ BadChar,

    /* 188 */ BadChar, /* 189 */ BadChar, /* 190 */ BadChar, /* 191 */ BadChar,

    /* 192 */ BadChar, /* 193 */ BadChar, /* 194 */ BadChar, /* 195 */ BadChar,

    /* 196 */ BadChar, /* 197 */ BadChar, /* 198 */ BadChar, /* 199 */ BadChar,

    /* 200 */ BadChar, /* 201 */ BadChar, /* 202 */ BadChar, /* 203 */ BadChar,

    /* 204 */ BadChar, /* 205 */ BadChar, /* 206 */ BadChar, /* 207 */ BadChar,

    /* 208 */ BadChar, /* 209 */ BadChar, /* 210 */ BadChar, /* 211 */ BadChar,

    /* 212 */ BadChar, /* 213 */ BadChar, /* 214 */ BadChar, /* 215 */ BadChar,

    /* 216 */ BadChar, /* 217 */ BadChar, /* 218 */ BadChar, /* 219 */ BadChar,

    /* 220 */ BadChar, /* 221 */ BadChar, /* 222 */ BadChar, /* 223 */ BadChar,

    /* 224 */ BadChar, /* 225 */ BadChar, /* 226 */ BadChar, /* 227 */ BadChar,

    /* 228 */ BadChar, /* 229 */ BadChar, /* 230 */ BadChar, /* 231 */ BadChar,

    /* 232 */ BadChar, /* 233 */ BadChar, /* 234 */ BadChar, /* 235 */ BadChar,

    /* 236 */ BadChar, /* 237 */ BadChar, /* 238 */ BadChar, /* 239 */ BadChar,

    /* 240 */ BadChar, /* 241 */ BadChar, /* 242 */ BadChar, /* 243 */ BadChar,

    /* 244 */ BadChar, /* 245 */ BadChar, /* 246 */ BadChar, /* 247 */ BadChar,

    /* 248 */ BadChar, /* 249 */ BadChar, /* 250 */ BadChar, /* 251 */ BadChar,

    /* 252 */ BadChar, /* 253 */ BadChar, /* 254 */ BadChar, /* 255 */ BadChar

};

static int copyPathRemovingDots(char* dst, const char* src, int srcStart, int srcEnd);

static char* encodeRelativeString(const KURL &base, const DeprecatedString& rel, const TextEncoding&);

static DeprecatedString substituteBackslashes(const DeprecatedString &string);

static inline bool isSchemeFirstChar(unsigned char c) { return characterClassTable[c] & SchemeFirstChar; }

static inline bool isSchemeChar(unsigned char c) { return characterClassTable[c] & SchemeChar; }

static inline bool isUserInfoChar(unsigned char c) { return characterClassTable[c] & UserInfoChar; }

static inline bool isHostnameChar(unsigned char c) { return characterClassTable[c] & HostnameChar; }

static inline bool isIPv6Char(unsigned char c) { return characterClassTable[c] & IPv6Char; }

static inline bool isPathSegmentEndChar(unsigned char c) { return characterClassTable[c] & PathSegmentEndChar; }

static inline bool isBadChar(unsigned char c) { return characterClassTable[c] & BadChar; }

static inline bool isHexDigit(unsigned char c) { return characterClassTable[c] & HexDigitChar; }

static inline int hexDigitValue(unsigned char c)

{

    ASSERT(isHexDigit(c));

    if (c < 'A')

        return c - '0';

    return (c - 'A' + 10) & 0xF; // handle both upper and lower case without a branch

}

// KURL

KURL::KURL() : m_isValid(false)

{

}

KURL::KURL(const char *url)

{

    if (url && url[0] == '/') {

         // 5 for "file:", 1 for terminator

        size_t urlLength = strlen(url) + 1;

        Vector<char, 2048> buffer(urlLength + 5);

        buffer[0] = 'f';

        buffer[1] = 'i';

        buffer[2] = 'l';

        buffer[3] = 'e';

        buffer[4] = ':';

        memcpy(&buffer[5], url, urlLength);

        parse(buffer.data(), 0);

    } else

        parse(url, 0);

}

KURL::KURL(const DeprecatedString &url)

{

    if (!url.isEmpty() && url[0] == '/') {

        // 5 for "file:", 1 for terminator

        Vector<char, 2048> buffer(url.length() + 6);

        buffer[0] = 'f';

        buffer[1] = 'i';

        buffer[2] = 'l';

        buffer[3] = 'e';

        buffer[4] = ':';

        url.copyLatin1(&buffer[5]);

        parse(buffer.data(), 0);

    } else

        parse(url.ascii(), &url);

}

KURL::KURL(const KURL& base, const DeprecatedString& relative)

{

    init(base, relative, UTF8Encoding());

}

KURL::KURL(const KURL& base, const DeprecatedString& relative, const TextEncoding& encoding)

{

    init(base, relative, encoding);

}

void KURL::init(const KURL &base, const DeprecatedString &relative, const TextEncoding& encoding)

{

    // Allow at least absolute URLs to resolve against an empty URL.

    if (!base.m_isValid && !base.isEmpty()) {

        m_isValid = false;

        return;

    }

    bool absolute = false;

    // for compatibility with Win IE, we must treat backslashes as if they were slashes, as long as we're not dealing with the javascript: schema

    DeprecatedString substitutedRelative;

    bool shouldSubstituteBackslashes = relative.contains('\\') && !relative.startsWith("javascript:", false);

    if (shouldSubstituteBackslashes) {

        substitutedRelative = substituteBackslashes(relative);

    }

    const DeprecatedString &rel = shouldSubstituteBackslashes ? substitutedRelative : relative;

    bool allASCII = rel.isAllASCII();

    char *strBuffer;

    const char *str;

    if (allASCII) {

        strBuffer = 0;

        str = rel.ascii();

    } else {

        strBuffer = encodeRelativeString(base, rel, encoding);

        str = strBuffer;

    }

    // workaround for sites that put leading whitespace whitespace on

    // URL references

    bool strippedStart = false;

    while (*str == ' ') {

        str++;

        strippedStart = true;

    }

    // workaround for trailing whitespace - a bit more complicated cause we have to copy

    // it would be even better to replace null-termination with a length parameter

    int len = strlen(str);

    int charsToChopOffEnd = 0;

    for (int pos = len - 1; pos >= 0 && str[pos] == ' '; pos--) {

        charsToChopOffEnd++;

    }

    if (charsToChopOffEnd > 0) {

        char *newStrBuffer = (char *)fastMalloc((len + 1) - charsToChopOffEnd);

        strncpy(newStrBuffer, str, len - charsToChopOffEnd);

        newStrBuffer[len - charsToChopOffEnd] = '\0';

        fastFree(strBuffer);

        strBuffer = newStrBuffer;

        str = strBuffer;

    }

    // According to the RFC, the reference should be interpreted as an

    // absolute URI if possible, using the "leftmost, longest"

    // algorithm. If the URI reference is absolute it will have a

    // scheme, meaning that it will have a colon before the first

    // non-scheme element.

    const char *p = str;

    if (isSchemeFirstChar(*p)) {

        ++p;

        while (isSchemeChar(*p)) {

            ++p;

        }

        if (*p == ':') {

            if (p[1] != '/' && base.protocol().lower() == DeprecatedString(str, p - str).lower() && base.isHierarchical())

                str = p + 1;

            else

                absolute = true;

        }

    }

    if (absolute) {

        parse(str, (allASCII && !strippedStart && (charsToChopOffEnd == 0)) ? &rel : 0);

    } else {

        // If the base is empty or opaque (e.g. data: or javascript:), then the URL is invalid

        // unless the relative URL is a single fragment.

        if (!base.isHierarchical()) {

            if (str[0] == '#') {

                DeprecatedString newURL = base.urlString.left(base.queryEndPos) + str;

                parse(newURL.ascii(), &newURL);

            } else

                m_isValid = false;

            if (strBuffer)

                fastFree(strBuffer);

            return;

        }

        switch(str[0]) {

        case '\0':

            // the reference must be empty - the RFC says this is a

            // reference to the same document

            {

                *this = base;

                break;

            }

        case '#':

            // must be fragment-only reference

            {

                DeprecatedString newURL = base.urlString.left(base.queryEndPos) + str;

                parse(newURL.ascii(), &newURL);

                break;

            }

        case '?':

            // query-only reference, special case needed for non-URL results

            {

                DeprecatedString newURL = base.urlString.left(base.pathEndPos) + str;

                parse(newURL.ascii(), &newURL);

                break;

            }

        case '/':

            // must be net-path or absolute-path reference

            {

                if (str[1] == '/') {

                    // net-path

                    DeprecatedString newURL = base.urlString.left(base.schemeEndPos + 1) + str;

                    parse(newURL.ascii(), &newURL);

                } else {

                    // abs-path

                    DeprecatedString newURL = base.urlString.left(base.portEndPos) + str;

                    parse(newURL.ascii(), &newURL);

                }

                break;

            }

        default:

            {

                // must be relative-path reference

                // Base part plus relative part plus one possible slash added in between plus terminating \0 byte.

                Vector<char, 2048> buffer(base.pathEndPos + 1 + strlen(str) + 1);

                char *bufferPos = buffer.data();

                // first copy everything before the path from the base

                const char *baseString = base.urlString.ascii();

                const char *baseStringStart = baseString;

                const char *pathStart = baseStringStart + base.portEndPos;

                while (baseStringStart < pathStart) {

                    *bufferPos++ = *baseStringStart++;

                }

                char *bufferPathStart = bufferPos;

                // now copy the base path 

                const char *baseStringEnd = baseString + base.pathEndPos;

                // go back to the last slash

                while (baseStringEnd > baseStringStart && baseStringEnd[-1] != '/') {

                    baseStringEnd--;

                }

                if (baseStringEnd == baseStringStart) {

                    // no path in base, add a path separator if necessary

                    if (base.schemeEndPos + 1 != base.pathEndPos && *str != '\0' && *str != '?' && *str != '#') {

                        *bufferPos++ = '/';

                    }

                } else {

                    bufferPos += copyPathRemovingDots(bufferPos, baseStringStart, 0, baseStringEnd - baseStringStart);

                }

                const char *relStringStart = str;

                const char *relStringPos = relStringStart;

                while (*relStringPos != '\0' && *relStringPos != '?' && *relStringPos != '#') {

                    if (relStringPos[0] == '.' && bufferPos[-1] == '/') {

                        if (isPathSegmentEndChar(relStringPos[1])) {

                            // skip over "." segment

                            relStringPos += 1;

                            if (relStringPos[0] == '/') {

                                relStringPos++;

                            }

                            continue;

                        } else if (relStringPos[1] == '.' && isPathSegmentEndChar(relStringPos[2])) {

                            // skip over ".." segment and rewind the last segment

                            // the RFC leaves it up to the app to decide what to do with excess

                            // ".." segments - we choose to drop them since some web content

                            // relies on this.

                            relStringPos += 2;

                            if (relStringPos[0] == '/') {

                                relStringPos++;

                            }

                            if (bufferPos > bufferPathStart + 1) {

                                bufferPos--;

                            }

                            while (bufferPos > bufferPathStart + 1  && bufferPos[-1] != '/') {

                                bufferPos--;

                            }

                            continue;

                        }

                    }

                    *bufferPos = *relStringPos;

                    relStringPos++;

                    bufferPos++;

                }

                // all done with the path work, now copy any remainder

                // of the relative reference; this will also add a null terminator

                strcpy(bufferPos, relStringPos);

                parse(buffer.data(), 0);

                ASSERT(strlen(buffer.data()) + 1 <= buffer.size());

                break;

            }

        }

    }

    if (strBuffer) {

        fastFree(strBuffer);

    }

}

bool KURL::hasPath() const

{

    return m_isValid && pathEndPos != portEndPos;

}

DeprecatedString KURL::lastPathComponent() const

{

    if (!hasPath())

        return DeprecatedString();

    int end = pathEndPos - 1;

    if (urlString[end] == '/')

        --end;

    int start = urlString.findRev('/', end);

    if (start < portEndPos)

        return DeprecatedString();

    ++start;

    return urlString.mid(start, end - start + 1);

}

DeprecatedString KURL::protocol() const

{

    if (!m_isValid) {

        return DeprecatedString();

    }

    return urlString.left(schemeEndPos);

}

DeprecatedString KURL::host() const

{

    if (!m_isValid) {

        return DeprecatedString();

    }

    int start = (passwordEndPos == userStartPos) ? passwordEndPos : passwordEndPos + 1;

    return decode_string(urlString.mid(start, hostEndPos - start));

}