X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/ce321570b08e1a2937415ef6388a1a98fd1c4b83..b9efe021b554fa3967d1442cf758435c5cd5ae8f:/src/common/uri.cpp?ds=sidebyside diff --git a/src/common/uri.cpp b/src/common/uri.cpp index 73b6b1d39d..5c5a643ba1 100644 --- a/src/common/uri.cpp +++ b/src/common/uri.cpp @@ -56,13 +56,13 @@ IMPLEMENT_CLASS(wxURI, wxObject); wxURI::wxURI() : m_hostType(wxURI_REGNAME), m_fields(0) { } - + wxURI::wxURI(const wxString& uri) : m_hostType(wxURI_REGNAME), m_fields(0) { Create(uri); } -wxURI::wxURI(const wxURI& uri) : m_hostType(wxURI_REGNAME), m_fields(0) +wxURI::wxURI(const wxURI& uri) : wxObject(), m_hostType(wxURI_REGNAME), m_fields(0) { Assign(uri); } @@ -78,8 +78,8 @@ wxURI::~wxURI() void wxURI::Clear() { - m_scheme = m_user = m_server = m_port = m_path = - m_query = m_fragment = wxT(""); + m_scheme = m_userinfo = m_server = m_port = m_path = + m_query = m_fragment = wxEmptyString; m_hostType = wxURI_REGNAME; @@ -89,21 +89,21 @@ void wxURI::Clear() // --------------------------------------------------------------------------- // Create // -// This creates the URI - all we do here is call the main parsing method +// This creates the URI - all we do here is call the main parsing method // --------------------------------------------------------------------------- const wxChar* wxURI::Create(const wxString& uri) -{ +{ if (m_fields) Clear(); - return Parse(uri); -} + return Parse(uri); +} // --------------------------------------------------------------------------- // Escape Methods // -// TranslateEscape unencodes a 3 character URL escape sequence +// TranslateEscape unencodes a 3 character URL escape sequence // // Escape encodes an invalid URI character into a 3 character sequence // @@ -115,9 +115,9 @@ const wxChar* wxURI::Create(const wxString& uri) wxChar wxURI::TranslateEscape(const wxChar* s) { - wxASSERT_MSG(IsHex(*s) && IsHex(*(s+1)), wxT("Invalid escape!")); + wxASSERT_MSG( IsHex(s[0]) && IsHex(s[1]), wxT("Invalid escape sequence!")); - return CharToHex(*s) * 0x10 + CharToHex(*++s); + return (wxChar)( CharToHex(s[0]) << 4 ) | CharToHex(s[1]); } wxString wxURI::Unescape(const wxString& uri) @@ -131,6 +131,8 @@ wxString wxURI::Unescape(const wxString& uri) new_uri += wxURI::TranslateEscape( &(uri.c_str()[i+1]) ); i += 2; } + else + new_uri += uri[i]; } return new_uri; @@ -141,25 +143,48 @@ void wxURI::Escape(wxString& s, const wxChar& c) const wxChar* hdig = wxT("0123456789abcdef"); s += wxT('%'); s += hdig[(c >> 4) & 15]; - s += hdig[c & 15]; + s += hdig[c & 15]; } bool wxURI::IsEscape(const wxChar*& uri) { // pct-encoded = "%" HEXDIG HEXDIG if(*uri == wxT('%') && IsHex(*(uri+1)) && IsHex(*(uri+2))) - { - uri += 3; return true; - } else return false; } +// --------------------------------------------------------------------------- +// GetUser +// GetPassword +// +// Gets the username and password via the old URL method. +// --------------------------------------------------------------------------- +wxString wxURI::GetUser() const +{ + size_t dwPasswordPos = m_userinfo.find(':'); + + if (dwPasswordPos == wxString::npos) + dwPasswordPos = 0; + + return m_userinfo(0, dwPasswordPos); +} + +wxString wxURI::GetPassword() const +{ + size_t dwPasswordPos = m_userinfo.find(':'); + + if (dwPasswordPos == wxString::npos) + return wxT(""); + else + return m_userinfo(dwPasswordPos+1, m_userinfo.length() + 1); +} + // --------------------------------------------------------------------------- // BuildURI // -// BuildURI() builds the entire URI into a useable +// BuildURI() builds the entire URI into a useable // representation, including proper identification characters such as slashes // // BuildUnescapedURI() does the same thing as BuildURI(), only it unescapes @@ -167,7 +192,7 @@ bool wxURI::IsEscape(const wxChar*& uri) // --------------------------------------------------------------------------- wxString wxURI::BuildURI() const -{ +{ wxString ret; if (HasScheme()) @@ -177,8 +202,8 @@ wxString wxURI::BuildURI() const { ret += wxT("//"); - if (HasUser()) - ret = ret + m_user + wxT("@"); + if (HasUserInfo()) + ret = ret + m_userinfo + wxT("@"); ret += m_server; @@ -208,8 +233,8 @@ wxString wxURI::BuildUnescapedURI() const { ret += wxT("//"); - if (HasUser()) - ret = ret + wxURI::Unescape(m_user) + wxT("@"); + if (HasUserInfo()) + ret = ret + wxURI::Unescape(m_userinfo) + wxT("@"); if (m_hostType == wxURI_REGNAME) ret += wxURI::Unescape(m_server); @@ -242,7 +267,7 @@ wxURI& wxURI::Assign(const wxURI& uri) //ref over components m_scheme = uri.m_scheme; - m_user = uri.m_user; + m_userinfo = uri.m_userinfo; m_server = uri.m_server; m_hostType = uri.m_hostType; m_port = uri.m_port; @@ -259,7 +284,7 @@ wxURI& wxURI::operator = (const wxURI& uri) } wxURI& wxURI::operator = (const wxString& string) -{ +{ Create(string); return *this; } @@ -269,7 +294,7 @@ wxURI& wxURI::operator = (const wxString& string) // --------------------------------------------------------------------------- bool wxURI::operator == (const wxURI& uri) const -{ +{ if (HasScheme()) { if(m_scheme != uri.m_scheme) @@ -281,12 +306,12 @@ bool wxURI::operator == (const wxURI& uri) const if (HasServer()) { - if (HasUser()) + if (HasUserInfo()) { - if (m_user != uri.m_user) + if (m_userinfo != uri.m_userinfo) return false; } - else if (uri.HasUser()) + else if (uri.HasUserInfo()) return false; if (m_server != uri.m_server || @@ -347,7 +372,7 @@ bool wxURI::IsReference() const // Master URI parsing method. Just calls the individual parsing methods // // URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ] -// URI-reference = URI / relative-URITestCase +// URI-reference = URI / relative // --------------------------------------------------------------------------- const wxChar* wxURI::Parse(const wxChar* uri) @@ -379,28 +404,28 @@ const wxChar* wxURI::ParseScheme(const wxChar* uri) m_scheme += *uri++; //scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) - while (IsAlpha(*uri) || IsDigit(*uri) || + while (IsAlpha(*uri) || IsDigit(*uri) || *uri == wxT('+') || *uri == wxT('-') || - *uri == wxT('.')) - { - m_scheme += *uri++; + *uri == wxT('.')) + { + m_scheme += *uri++; } //valid scheme? if (*uri == wxT(':')) - { + { //mark the scheme as valid m_fields |= wxURI_SCHEME; //move reference point up to input buffer uricopy = ++uri; } - else + else //relative uri with relative path reference - m_scheme = wxT(""); + m_scheme = wxEmptyString; } -// else +// else //relative uri with _possible_ relative path reference return uricopy; @@ -409,11 +434,11 @@ const wxChar* wxURI::ParseScheme(const wxChar* uri) const wxChar* wxURI::ParseAuthority(const wxChar* uri) { // authority = [ userinfo "@" ] host [ ":" port ] - if (*uri == wxT('/') && *(uri+1) == wxT('/')) + if (*uri == wxT('/') && *(uri+1) == wxT('/')) { uri += 2; - uri = ParseUser(uri); + uri = ParseUserInfo(uri); uri = ParseServer(uri); return ParsePort(uri); } @@ -421,7 +446,7 @@ const wxChar* wxURI::ParseAuthority(const wxChar* uri) return uri; } -const wxChar* wxURI::ParseUser(const wxChar* uri) +const wxChar* wxURI::ParseUserInfo(const wxChar* uri) { wxASSERT(uri != NULL); @@ -430,24 +455,30 @@ const wxChar* wxURI::ParseUser(const wxChar* uri) const wxChar* uricopy = uri; // userinfo = *( unreserved / pct-encoded / sub-delims / ":" ) - while(*uri && *uri != wxT('@') && *uri != wxT('/') && *uri != wxT('#') && *uri != wxT('?')) + while(*uri && *uri != wxT('@') && *uri != wxT('/') && *uri != wxT('#') && *uri != wxT('?')) { - if(IsUnreserved(*uri) || IsEscape(uri) || + if(IsUnreserved(*uri) || IsSubDelim(*uri) || *uri == wxT(':')) - m_user += *uri++; + m_userinfo += *uri++; + else if (IsEscape(uri)) + { + m_userinfo += *uri++; + m_userinfo += *uri++; + m_userinfo += *uri++; + } else - Escape(m_user, *uri++); + Escape(m_userinfo, *uri++); } if(*uri == wxT('@')) { //valid userinfo - m_fields |= wxURI_USER; + m_fields |= wxURI_USERINFO; uricopy = ++uri; } else - m_user = wxT(""); + m_userinfo = wxEmptyString; return uricopy; } @@ -464,43 +495,45 @@ const wxChar* wxURI::ParseServer(const wxChar* uri) // IP-literal = "[" ( IPv6address / IPvFuture ) "]" if (*uri == wxT('[')) { - if (ParseIPv6address(++uri) && *uri == wxT(']')) + ++uri; //some compilers don't support *&ing a ++* + if (ParseIPv6address(uri) && *uri == wxT(']')) { ++uri; m_hostType = wxURI_IPV6ADDRESS; - + wxStringBufferLength theBuffer(m_server, uri - uricopy); - wxMemcpy(theBuffer, uricopy, uri-uricopy); + wxTmemcpy(theBuffer, uricopy, uri-uricopy); theBuffer.SetLength(uri-uricopy); } else { uri = uricopy; - if (ParseIPvFuture(++uri) && *uri == wxT(']')) + ++uri; //some compilers don't support *&ing a ++* + if (ParseIPvFuture(uri) && *uri == wxT(']')) { ++uri; - m_hostType = wxURI_IPVFUTURE; - + m_hostType = wxURI_IPVFUTURE; + wxStringBufferLength theBuffer(m_server, uri - uricopy); - wxMemcpy(theBuffer, uricopy, uri-uricopy); + wxTmemcpy(theBuffer, uricopy, uri-uricopy); theBuffer.SetLength(uri-uricopy); } - else + else uri = uricopy; } } - else + else { if (ParseIPv4address(uri)) { m_hostType = wxURI_IPV4ADDRESS; wxStringBufferLength theBuffer(m_server, uri - uricopy); - wxMemcpy(theBuffer, uricopy, uri-uricopy); + wxTmemcpy(theBuffer, uricopy, uri-uricopy); theBuffer.SetLength(uri-uricopy); } - else + else uri = uricopy; } @@ -508,13 +541,19 @@ const wxChar* wxURI::ParseServer(const wxChar* uri) { uri = uricopy; // reg-name = *( unreserved / pct-encoded / sub-delims ) - while(*uri && *uri != wxT('/') && *uri != wxT(':') && *uri != wxT('#') && *uri != wxT('?')) + while(*uri && *uri != wxT('/') && *uri != wxT(':') && *uri != wxT('#') && *uri != wxT('?')) { - if(IsUnreserved(*uri) || IsEscape(uri) || IsSubDelim(*uri)) + if(IsUnreserved(*uri) || IsSubDelim(*uri)) + m_server += *uri++; + else if (IsEscape(uri)) + { m_server += *uri++; + m_server += *uri++; + m_server += *uri++; + } else Escape(m_server, *uri++); - } + } } //mark the server as valid @@ -523,7 +562,7 @@ const wxChar* wxURI::ParseServer(const wxChar* uri) return uri; } - + const wxChar* wxURI::ParsePort(const wxChar* uri) { wxASSERT(uri != NULL); @@ -532,10 +571,10 @@ const wxChar* wxURI::ParsePort(const wxChar* uri) if(*uri == wxT(':')) { ++uri; - while(IsDigit(*uri)) + while(IsDigit(*uri)) { m_port += *uri++; - } + } //mark the port as valid m_fields |= wxURI_PORT; @@ -578,18 +617,27 @@ const wxChar* wxURI::ParsePath(const wxChar* uri, bool bReference, bool bNormali { m_path += *uri++; - while(*uri && *uri != wxT('#') && *uri != wxT('?')) - { - if( IsUnreserved(*uri) || IsSubDelim(*uri) || IsEscape(uri) || + while(*uri && *uri != wxT('#') && *uri != wxT('?')) + { + if( IsUnreserved(*uri) || IsSubDelim(*uri) || *uri == wxT(':') || *uri == wxT('@') || *uri == wxT('/')) - m_path += *uri++; - else - Escape(m_path, *uri++); + m_path += *uri++; + else if (IsEscape(uri)) + { + m_path += *uri++; + m_path += *uri++; + m_path += *uri++; + } + else + Escape(m_path, *uri++); } if (bNormalize) { wxStringBufferLength theBuffer(m_path, m_path.length() + 1); +#if wxUSE_STL + wxTmemcpy(theBuffer, m_path.c_str(), m_path.length()+1); +#endif Normalize(theBuffer, true); theBuffer.SetLength(wxStrlen(theBuffer)); } @@ -601,32 +649,47 @@ const wxChar* wxURI::ParsePath(const wxChar* uri, bool bReference, bool bNormali if (bReference) { //no colon allowed - while(*uri && *uri != wxT('#') && *uri != wxT('?')) + while(*uri && *uri != wxT('#') && *uri != wxT('?')) { - if(IsUnreserved(*uri) || IsSubDelim(*uri) || IsEscape(uri) || + if(IsUnreserved(*uri) || IsSubDelim(*uri) || *uri == wxT('@') || *uri == wxT('/')) - m_path += *uri++; - else - Escape(m_path, *uri++); + m_path += *uri++; + else if (IsEscape(uri)) + { + m_path += *uri++; + m_path += *uri++; + m_path += *uri++; + } + else + Escape(m_path, *uri++); } - } + } else { - while(*uri && *uri != wxT('#') && *uri != wxT('?')) + while(*uri && *uri != wxT('#') && *uri != wxT('?')) { - if(IsUnreserved(*uri) || IsSubDelim(*uri) || IsEscape(uri) || + if(IsUnreserved(*uri) || IsSubDelim(*uri) || *uri == wxT(':') || *uri == wxT('@') || *uri == wxT('/')) - m_path += *uri++; - else - Escape(m_path, *uri++); + m_path += *uri++; + else if (IsEscape(uri)) + { + m_path += *uri++; + m_path += *uri++; + m_path += *uri++; + } + else + Escape(m_path, *uri++); } } if (uri != uricopy) - { + { if (bNormalize) { wxStringBufferLength theBuffer(m_path, m_path.length() + 1); +#if wxUSE_STL + wxTmemcpy(theBuffer, m_path.c_str(), m_path.length()+1); +#endif Normalize(theBuffer); theBuffer.SetLength(wxStrlen(theBuffer)); } @@ -650,11 +713,17 @@ const wxChar* wxURI::ParseQuery(const wxChar* uri) ++uri; while(*uri && *uri != wxT('#')) { - if (IsUnreserved(*uri) || IsSubDelim(*uri) || IsEscape(uri) || + if (IsUnreserved(*uri) || IsSubDelim(*uri) || *uri == wxT(':') || *uri == wxT('@') || *uri == wxT('/') || *uri == wxT('?')) - m_query += *uri++; + m_query += *uri++; + else if (IsEscape(uri)) + { + m_query += *uri++; + m_query += *uri++; + m_query += *uri++; + } else - Escape(m_query, *uri++); + Escape(m_query, *uri++); } //mark the server as valid @@ -675,11 +744,17 @@ const wxChar* wxURI::ParseFragment(const wxChar* uri) ++uri; while(*uri) { - if (IsUnreserved(*uri) || IsSubDelim(*uri) || IsEscape(uri) || + if (IsUnreserved(*uri) || IsSubDelim(*uri) || *uri == wxT(':') || *uri == wxT('@') || *uri == wxT('/') || *uri == wxT('?')) - m_fragment += *uri++; + m_fragment += *uri++; + else if (IsEscape(uri)) + { + m_fragment += *uri++; + m_fragment += *uri++; + m_fragment += *uri++; + } else - Escape(m_fragment, *uri++); + Escape(m_fragment, *uri++); } //mark the server as valid @@ -697,12 +772,12 @@ const wxChar* wxURI::ParseFragment(const wxChar* uri) // A version of the algorithm outlined in the RFC is used here // (it is shown in comments) // -// Note that an empty URI inherits all components +// Note that an empty URI inherits all components // --------------------------------------------------------------------------- void wxURI::Resolve(const wxURI& base, int flags) { - wxASSERT_MSG(!base.IsReference(), + wxASSERT_MSG(!base.IsReference(), wxT("wxURI to inherit from must not be a reference!")); // If we arn't being strict, enable the older (pre-RFC2396) @@ -712,7 +787,7 @@ void wxURI::Resolve(const wxURI& base, int flags) if ( !(flags & wxURI_STRICT) && HasScheme() && base.HasScheme() && m_scheme == base.m_scheme ) - { + { m_fields -= wxURI_SCHEME; } @@ -728,7 +803,7 @@ void wxURI::Resolve(const wxURI& base, int flags) return; } - //No sheme - inherit + //No scheme - inherit m_scheme = base.m_scheme; m_fields |= wxURI_SCHEME; @@ -744,22 +819,22 @@ void wxURI::Resolve(const wxURI& base, int flags) } //No authority - inherit - if (base.HasUser()) + if (base.HasUserInfo()) { - m_user = base.m_user; - m_fields |= wxURI_USER; + m_userinfo = base.m_userinfo; + m_fields |= wxURI_USERINFO; } - + m_server = base.m_server; m_hostType = base.m_hostType; m_fields |= wxURI_SERVER; - + if (base.HasPort()) { m_port = base.m_port; m_fields |= wxURI_PORT; } - + // Simple path inheritance from base if (!HasPath()) @@ -767,7 +842,7 @@ void wxURI::Resolve(const wxURI& base, int flags) // T.path = Base.path; m_path = base.m_path; m_fields |= wxURI_PATH; - + // if defined(R.query) then // T.query = R.query; @@ -791,7 +866,7 @@ void wxURI::Resolve(const wxURI& base, int flags) // T.query = R.query; if (m_path[0u] != wxT('/')) { - //Marge paths + //Merge paths const wxChar* op = m_path.c_str(); const wxChar* bp = base.m_path.c_str() + base.m_path.Length(); @@ -800,7 +875,7 @@ void wxURI::Resolve(const wxURI& base, int flags) UpTree(base.m_path, bp); //normalize directories - while(*op == wxT('.') && *(op+1) == wxT('.') && + while(*op == wxT('.') && *(op+1) == wxT('.') && (*(op+2) == '\0' || *(op+2) == wxT('/')) ) { UpTree(base.m_path, bp); @@ -811,16 +886,16 @@ void wxURI::Resolve(const wxURI& base, int flags) op += 3; } - m_path = base.m_path.substr(0, bp - base.m_path.c_str()) + - m_path.Mid((op - m_path.c_str()), m_path.Length()); + m_path = base.m_path.substr(0, bp - base.m_path.c_str()) + + m_path.substr((op - m_path.c_str()), m_path.Length()); } } - //T.fragment = R.fragment; + //T.fragment = R.fragment; } // --------------------------------------------------------------------------- -// UpTree +// UpTree // // Moves a URI path up a directory // --------------------------------------------------------------------------- @@ -832,7 +907,7 @@ void wxURI::UpTree(const wxChar* uristart, const wxChar*& uri) { uri -= 2; } - + for(;uri != uristart; --uri) { if (*uri == wxT('/')) @@ -879,7 +954,7 @@ void wxURI::Normalize(wxChar* s, bool bIgnoreLeads) else cp += 2; } - else if (*cp == wxT('.') && *(cp+1) == wxT('.') && + else if (*cp == wxT('.') && *(cp+1) == wxT('.') && (*(cp+2) == wxT('/') || *(cp+2) == '\0') && (bp == cp || *(cp-1) == wxT('/'))) { @@ -912,7 +987,7 @@ void wxURI::Normalize(wxChar* s, bool bIgnoreLeads) } } else - *s++ = *cp++; + *s++ = *cp++; } *s = '\0'; @@ -922,7 +997,7 @@ void wxURI::Normalize(wxChar* s, bool bIgnoreLeads) // ParseH16 // // Parses 1 to 4 hex values. Returns true if the first character of the input -// string is a valid hex character. It is the caller's responsability to move +// string is a valid hex character. It is the caller's responsability to move // the input string back to its original position on failure. // --------------------------------------------------------------------------- @@ -941,9 +1016,9 @@ bool wxURI::ParseH16(const wxChar*& uri) // --------------------------------------------------------------------------- // ParseIPXXX // -// Parses a certain version of an IP address and moves the input string past -// it. Returns true if the input string contains the proper version of an ip -// address. It is the caller's responsability to move the input string back +// Parses a certain version of an IP address and moves the input string past +// it. Returns true if the input string contains the proper version of an ip +// address. It is the caller's responsability to move the input string back // to its original position on failure. // --------------------------------------------------------------------------- @@ -961,13 +1036,13 @@ bool wxURI::ParseIPv4address(const wxChar*& uri) { ++iIPv4; - + //each ip part must be between 0-255 (dupe of version in for loop) if( IsDigit(*++uri) && IsDigit(*++uri) && //100 or less (note !) - !( (*(uri-2) < wxT('2')) || - //240 or less - (*(uri-2) == wxT('2') && + !( (*(uri-2) < wxT('2')) || + //240 or less + (*(uri-2) == wxT('2') && (*(uri-1) < wxT('5') || (*(uri-1) == wxT('5') && *uri <= wxT('5'))) ) ) @@ -987,9 +1062,9 @@ bool wxURI::ParseIPv4address(const wxChar*& uri) //each ip part must be between 0-255 if( IsDigit(*++uri) && IsDigit(*++uri) && //100 or less (note !) - !( (*(uri-2) < wxT('2')) || - //240 or less - (*(uri-2) == wxT('2') && + !( (*(uri-2) < wxT('2')) || + //240 or less + (*(uri-2) == wxT('2') && (*(uri-1) < wxT('5') || (*(uri-1) == wxT('5') && *uri <= wxT('5'))) ) ) @@ -1028,7 +1103,7 @@ bool wxURI::ParseIPv6address(const wxChar*& uri) bEndHex = true; break; } - + if(*uri != wxT(':')) { break; @@ -1065,7 +1140,7 @@ bool wxURI::ParseIPv6address(const wxChar*& uri) const wxChar* uristart = uri; //parse ls32 // ls32 = ( h16 ":" h16 ) / IPv4address - if (ParseH16(uri) && *uri == wxT(':') && ParseH16(uri)) + if (ParseH16(uri) && *uri == wxT(':') && ParseH16(uri)) return true; uri = uristart; @@ -1078,7 +1153,7 @@ bool wxURI::ParseIPv6address(const wxChar*& uri) else { uri += 2; - + if (numPrefix > 3) maxPostfix = 0; else @@ -1099,7 +1174,7 @@ bool wxURI::ParseIPv6address(const wxChar*& uri) const wxChar* uristart = uri; //parse ls32 // ls32 = ( h16 ":" h16 ) / IPv4address - if (ParseH16(uri) && *uri == wxT(':') && ParseH16(uri)) + if (ParseH16(uri) && *uri == wxT(':') && ParseH16(uri)) return true; uri = uristart; @@ -1108,7 +1183,7 @@ bool wxURI::ParseIPv6address(const wxChar*& uri) return true; uri = uristart; - + if (!bAllowAltEnding) return false; } @@ -1139,18 +1214,18 @@ bool wxURI::ParseIPvFuture(const wxChar*& uri) // --------------------------------------------------------------------------- // CharToHex // -// Converts a character into a numeric hexidecimal value, or 0 if the +// Converts a character into a numeric hexidecimal value, or 0 if the // passed in character is not a valid hex character // --------------------------------------------------------------------------- //static -wxInt32 wxURI::CharToHex(const wxChar& c) +wxChar wxURI::CharToHex(const wxChar& c) { - if ((c >= wxT('A')) && (c <= wxT('Z'))) return c - wxT('A') + 0x0A; - if ((c >= wxT('a')) && (c <= wxT('z'))) return c - wxT('a') + 0x0a; - if ((c >= wxT('0')) && (c <= wxT('9'))) return c - wxT('0') + 0x00; + if ((c >= wxT('A')) && (c <= wxT('Z'))) return wxChar(c - wxT('A') + 0x0A); + if ((c >= wxT('a')) && (c <= wxT('z'))) return wxChar(c - wxT('a') + 0x0a); + if ((c >= wxT('0')) && (c <= wxT('9'))) return wxChar(c - wxT('0') + 0x00); - return 0; + return 0; } // --------------------------------------------------------------------------- @@ -1161,16 +1236,16 @@ wxInt32 wxURI::CharToHex(const wxChar& c) //! unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~" bool wxURI::IsUnreserved (const wxChar& c) -{ return IsAlpha(c) || IsDigit(c) || +{ return IsAlpha(c) || IsDigit(c) || c == wxT('-') || c == wxT('.') || c == wxT('_') || c == wxT('~') //tilde - ; + ; } bool wxURI::IsReserved (const wxChar& c) -{ +{ return IsGenDelim(c) || IsSubDelim(c); } @@ -1200,7 +1275,7 @@ bool wxURI::IsSubDelim (const wxChar& c) c == wxT('+') || c == wxT(',') || c == wxT(';') || - c == wxT('=') + c == wxT('=') ; } @@ -1216,7 +1291,7 @@ bool wxURI::IsDigit(const wxChar& c) // --------------------------------------------------------------------------- // -// wxURL Compatability +// wxURL Compatibility // // --------------------------------------------------------------------------- @@ -1226,9 +1301,67 @@ bool wxURI::IsDigit(const wxChar& c) #include "wx/url.h" -wxString wxURL::ConvertToValidURI(const wxString& uri, const wxChar* WXUNUSED(delims)) +wxString wxURL::GetProtocolName() const +{ + return m_scheme; +} + +wxString wxURL::GetHostName() const +{ + return m_server; +} + +wxString wxURL::GetPath() const +{ + return m_path; +} + +//Note that this old code really doesn't convert to a URI that well and looks +//more like a dirty hack than anything else... + +wxString wxURL::ConvertToValidURI(const wxString& uri, const wxChar* delims) { - return wxURI(uri).BuildURI(); + wxString out_str; + wxString hexa_code; + size_t i; + + for (i = 0; i < uri.Len(); i++) + { + wxChar c = uri.GetChar(i); + + if (c == wxT(' ')) + { + // GRG, Apr/2000: changed to "%20" instead of '+' + + out_str += wxT("%20"); + } + else + { + // GRG, Apr/2000: modified according to the URI definition (RFC 2396) + // + // - Alphanumeric characters are never escaped + // - Unreserved marks are never escaped + // - Delimiters must be escaped if they appear within a component + // but not if they are used to separate components. Here we have + // no clear way to distinguish between these two cases, so they + // are escaped unless they are passed in the 'delims' parameter + // (allowed delimiters). + + static const wxChar marks[] = wxT("-_.!~*()'"); + + if ( !wxIsalnum(c) && !wxStrchr(marks, c) && !wxStrchr(delims, c) ) + { + hexa_code.Printf(wxT("%%%02X"), c); + out_str += hexa_code; + } + else + { + out_str += c; + } + } + } + + return out_str; } wxString wxURL::ConvertFromURI(const wxString& uri)