/*

 * Copyright (C) 2004, 2007, 2008 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"

#if !USE(GOOGLEURL)

#include "KURL.h"

#include "StringHash.h"

#include "TextEncoding.h"

#include <wtf/text/CString.h>

#include <wtf/HashMap.h>

#include <wtf/StdLibExtras.h>

#if USE(ICU_UNICODE)

#include <unicode/uidna.h>

#elif USE(QT4_UNICODE)

#include <QUrl>

#elif USE(GLIB_UNICODE)

#include <glib.h>

#include "GOwnPtr.h"

#endif

#include <stdio.h>

using namespace std;

using namespace WTF;

namespace WebCore {

typedef Vector<char, 512> CharBuffer;

typedef Vector<UChar, 512> UCharBuffer;

// FIXME: This file makes too much use of the + operator on String.

// We either have to optimize that operator so it doesn't involve

// so many allocations, or change this to use Vector<UChar> instead.

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,

    // not allowed in path

    BadChar = 1 << 6

};

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 | IPv6Char,

    /* 47  / */ PathSegmentEndChar,

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

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

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

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

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

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

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

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

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

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

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

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

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

    /* 64  @ */ 0,

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

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

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

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

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

    /* 70  F */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | 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 | IPv6Char,

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

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

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

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

    /* 102  f */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | 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 const unsigned maximumValidPortNumber = 0xFFFE;

static const unsigned invalidPortNumber = 0xFFFF;

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

static void encodeRelativeString(const String& rel, const TextEncoding&, CharBuffer& ouput);

static String substituteBackslashes(const String&);

static bool isValidProtocol(const String&);

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

static inline bool isSchemeFirstChar(UChar c) { return c <= 0xff && (characterClassTable[c] & SchemeFirstChar); }

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

static inline bool isSchemeChar(UChar c) { return c <= 0xff && (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(char c) { return characterClassTable[static_cast<unsigned char>(c)] & PathSegmentEndChar; }

static inline bool isPathSegmentEndChar(UChar c) { return c <= 0xff && (characterClassTable[c] & PathSegmentEndChar); }

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

static inline int hexDigitValue(UChar c)

{

    ASSERT(isASCIIHexDigit(c));

    if (c < 'A')

        return c - '0';

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

}

// Copies the source to the destination, assuming all the source characters are

// ASCII. The destination buffer must be large enough. Null characters are allowed

// in the source string, and no attempt is made to null-terminate the result.

static void copyASCII(const UChar* src, int length, char* dest)

{

    for (int i = 0; i < length; i++)

        dest[i] = static_cast<char>(src[i]);

}

static void appendASCII(const String& base, const char* rel, size_t len, CharBuffer& buffer)

{

    buffer.resize(base.length() + len + 1);

    copyASCII(base.characters(), base.length(), buffer.data());

    memcpy(buffer.data() + base.length(), rel, len);

    buffer[buffer.size() - 1] = '\0';

}

// FIXME: Move to PlatformString.h eventually.

// Returns the index of the first index in string |s| of any of the characters

// in |toFind|. |toFind| should be a null-terminated string, all characters up

// to the null will be searched. Returns int if not found.

static int findFirstOf(const UChar* s, int sLen, int startPos, const char* toFind)

{

    for (int i = startPos; i < sLen; i++) {

        const char* cur = toFind;

        while (*cur) {

            if (s[i] == *(cur++))

                return i;

        }

    }

    return -1;

}

#ifndef NDEBUG

static void checkEncodedString(const String& url)

{

    for (unsigned i = 0; i < url.length(); ++i)

        ASSERT(!(url[i] & ~0x7F));

    ASSERT(!url.length() || isSchemeFirstChar(url[0]));

}

#else

static inline void checkEncodedString(const String&)

{

}

#endif

inline bool KURL::protocolIs(const String& string, const char* protocol)

{

    return WebCore::protocolIs(string, protocol);

}

void KURL::invalidate()

{

    m_isValid = false;

    m_protocolInHTTPFamily = false;

    m_schemeEnd = 0;

    m_userStart = 0;

    m_userEnd = 0;

    m_passwordEnd = 0;

    m_hostEnd = 0;

    m_portEnd = 0;

    m_pathEnd = 0;

    m_pathAfterLastSlash = 0;

    m_queryEnd = 0;

    m_fragmentEnd = 0;

}

KURL::KURL(ParsedURLStringTag, const char* url)

{

    parse(url, 0);

    ASSERT(url == m_string);

}

KURL::KURL(ParsedURLStringTag, const String& url)

{

    parse(url);

    ASSERT(url == m_string);

}

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

{

    init(base, relative, UTF8Encoding());

}

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

{

    // For UTF-{7,16,32}, we want to use UTF-8 for the query part as 

    // we do when submitting a form. A form with GET method

    // has its contents added to a URL as query params and it makes sense

    // to be consistent.

    init(base, relative, encoding.encodingForFormSubmission());

}

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

{

    // Allow resolutions with a null or empty base URL, but not with any other invalid one.

    // FIXME: Is this a good rule?

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

        m_string = relative;

        invalidate();

        return;

    }

    // For compatibility with Win IE, treat backslashes as if they were slashes,

    // as long as we're not dealing with javascript: or data: URLs.

    String rel = relative;

    if (rel.contains('\\') && !(protocolIsJavaScript(rel) || protocolIs(rel, "data")))

        rel = substituteBackslashes(rel);

    String* originalString = &rel;

    bool allASCII = charactersAreAllASCII(rel.characters(), rel.length());

    CharBuffer strBuffer;

    char* str;

    size_t len;

    if (allASCII) {

        len = rel.length();

        strBuffer.resize(len + 1);

        copyASCII(rel.characters(), len, strBuffer.data());

        strBuffer[len] = 0;

        str = strBuffer.data();

    } else {

        originalString = 0;

        encodeRelativeString(rel, encoding, strBuffer);

        str = strBuffer.data();

        len = strlen(str);

    }

    // Get rid of leading whitespace.

    while (*str == ' ') {

        originalString = 0;

        str++;

        --len;

    }

    // Get rid of trailing whitespace.

    while (len && str[len - 1] == ' ') {

        originalString = 0;

        str[--len] = '\0';

    }

    // 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.

    bool absolute = false;

    char* p = str;

    if (isSchemeFirstChar(*p)) {

        ++p;

        while (isSchemeChar(*p)) {

            ++p;

        }

        if (*p == ':') {

            if (p[1] != '/' && equalIgnoringCase(base.protocol(), String(str, p - str)) && base.isHierarchical()) {

                str = p + 1;

                originalString = 0;

            } else

                absolute = true;

        }

    }

    CharBuffer parseBuffer;

    if (absolute) {

        parse(str, originalString);

    } 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] == '#') {

                appendASCII(base.m_string.left(base.m_queryEnd), str, len, parseBuffer);

                parse(parseBuffer.data(), 0);

            } else {

                m_string = relative;

                invalidate();

            }

            return;

        }

        switch (str[0]) {

        case '\0':

            // The reference is empty, so this is a reference to the same document with any fragment identifier removed.

            *this = base;

            removeFragmentIdentifier();

            break;

        case '#': {

            // must be fragment-only reference

            appendASCII(base.m_string.left(base.m_queryEnd), str, len, parseBuffer);

            parse(parseBuffer.data(), 0);

            break;

        }

        case '?': {

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

            appendASCII(base.m_string.left(base.m_pathEnd), str, len, parseBuffer);

            parse(parseBuffer.data(), 0);

            break;

        }

        case '/':

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

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

                // net-path

                appendASCII(base.m_string.left(base.m_schemeEnd + 1), str, len, parseBuffer);

                parse(parseBuffer.data(), 0);

            } else {

                // abs-path

                appendASCII(base.m_string.left(base.m_portEnd), str, len, parseBuffer);

                parse(parseBuffer.data(), 0);

            }

            break;

        default:

            {

                // must be relative-path reference

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

                parseBuffer.resize(base.m_pathEnd + 1 + len + 1);

                char* bufferPos = parseBuffer.data();

                // first copy everything before the path from the base

                unsigned baseLength = base.m_string.length();

                const UChar* baseCharacters = base.m_string.characters();

                CharBuffer baseStringBuffer(baseLength);

                copyASCII(baseCharacters, baseLength, baseStringBuffer.data());

                const char* baseString = baseStringBuffer.data();

                const char* baseStringStart = baseString;

                const char* pathStart = baseStringStart + base.m_portEnd;

                while (baseStringStart < pathStart)

                    *bufferPos++ = *baseStringStart++;

                char* bufferPathStart = bufferPos;

                // now copy the base path

                const char* baseStringEnd = baseString + base.m_pathEnd;

                // 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.m_schemeEnd + 1 != base.m_pathEnd && *str && *str != '?' && *str != '#')

                        *bufferPos++ = '/';

                } else {

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

                }

                const char* relStringStart = str;

                const char* relStringPos = relStringStart;

                while (*relStringPos && *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(parseBuffer.data(), 0);