X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/ba5a47aed8025996fa5c103a151cc19fe1119ac6..9534d0dfdc3c6fad8ea5d5fd31bbb6f20650929b:/src/common/uri.cpp diff --git a/src/common/uri.cpp b/src/common/uri.cpp index 0608b4c82f..bcdd7eae66 100644 --- a/src/common/uri.cpp +++ b/src/common/uri.cpp @@ -16,10 +16,6 @@ // headers // --------------------------------------------------------------------------- -#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) - #pragma implementation "uri.h" -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -27,13 +23,17 @@ #pragma hdrstop #endif +#ifndef WX_PRECOMP + #include "wx/crt.h" +#endif + #include "wx/uri.h" // --------------------------------------------------------------------------- // definitions // --------------------------------------------------------------------------- -IMPLEMENT_CLASS(wxURI, wxObject); +IMPLEMENT_CLASS(wxURI, wxObject) // =========================================================================== // implementation @@ -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,24 @@ 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); -} + // FIXME-UTF8: rewrite ParseXXX() methods using iterators + // NB: using wxWxCharBuffer instead of just c_str() avoids keeping + // converted string in memory for longer than needed + return Parse(wxWxCharBuffer(uri.c_str())); +} // --------------------------------------------------------------------------- // 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 // @@ -113,24 +116,29 @@ const wxChar* wxURI::Create(const wxString& uri) // Unescape unencodes all 3 character URL escape sequences in a wxString // --------------------------------------------------------------------------- -wxChar wxURI::TranslateEscape(const wxChar* s) +wxUniChar wxURI::TranslateEscape(const wxString::const_iterator& s) { - wxASSERT_MSG(IsHex(*s) && IsHex(*(s+1)), wxT("Invalid escape!")); + wxChar c1(*s); + wxChar c2(*(s + 1)); + + wxASSERT_MSG( IsHex(c1) && IsHex(c2), wxT("Invalid escape sequence!")); - return CharToHex(*s) * 0x10 + CharToHex(*++s); + return wx_truncate_cast(wxChar, (CharToHex(c1) << 4 ) | CharToHex(c2)); } wxString wxURI::Unescape(const wxString& uri) { wxString new_uri; - for(size_t i = 0; i < uri.length(); ++i) + for (wxString::const_iterator i = uri.begin(); i != uri.end(); ++i) { - if (uri[i] == wxT('%')) + if ( *i == wxT('%') ) { - new_uri += wxURI::TranslateEscape( &(uri.c_str()[i+1]) ); + new_uri += wxURI::TranslateEscape(i + 1); i += 2; } + else + new_uri += *i; } return new_uri; @@ -141,25 +149,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 +198,7 @@ bool wxURI::IsEscape(const wxChar*& uri) // --------------------------------------------------------------------------- wxString wxURI::BuildURI() const -{ +{ wxString ret; if (HasScheme()) @@ -177,8 +208,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 +239,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 +273,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 +290,7 @@ wxURI& wxURI::operator = (const wxURI& uri) } wxURI& wxURI::operator = (const wxString& string) -{ +{ Create(string); return *this; } @@ -269,7 +300,7 @@ wxURI& wxURI::operator = (const wxString& string) // --------------------------------------------------------------------------- bool wxURI::operator == (const wxURI& uri) const -{ +{ if (HasScheme()) { if(m_scheme != uri.m_scheme) @@ -281,12 +312,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,10 +378,10 @@ 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) +const wxChar* wxURI::Parse(const wxChar *uri) { uri = ParseScheme(uri); uri = ParseAuthority(uri); @@ -365,7 +396,7 @@ const wxChar* wxURI::Parse(const wxChar* uri) // Individual parsers for each URI component // --------------------------------------------------------------------------- -const wxChar* wxURI::ParseScheme(const wxChar* uri) +const wxChar* wxURI::ParseScheme(const wxChar *uri) { wxASSERT(uri != NULL); @@ -379,28 +410,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,19 +440,26 @@ 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('/')) { + //skip past the two slashes uri += 2; - uri = ParseUser(uri); + // ############# DEVIATION FROM RFC ######################### + // Don't parse the server component for file URIs + if(m_scheme != wxT("file")) + { + //normal way + uri = ParseUserInfo(uri); uri = ParseServer(uri); return ParsePort(uri); + } } return uri; } -const wxChar* wxURI::ParseUser(const wxChar* uri) +const wxChar* wxURI::ParseUserInfo(const wxChar* uri) { wxASSERT(uri != NULL); @@ -430,24 +468,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 +508,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 +554,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 +575,7 @@ const wxChar* wxURI::ParseServer(const wxChar* uri) return uri; } - + const wxChar* wxURI::ParsePort(const wxChar* uri) { wxASSERT(uri != NULL); @@ -532,10 +584,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 +630,28 @@ 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 || wxUSE_UNICODE_UTF8 + // FIXME-UTF8: have some wxReadWriteStringBuffer instead? + wxTmemcpy(theBuffer, m_path.c_str(), m_path.length()+1); +#endif Normalize(theBuffer, true); theBuffer.SetLength(wxStrlen(theBuffer)); } @@ -601,32 +663,48 @@ 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 || wxUSE_UNICODE_UTF8 + // FIXME-UTF8: have some wxReadWriteStringBuffer instead? + wxTmemcpy(theBuffer, m_path.c_str(), m_path.length()+1); +#endif Normalize(theBuffer); theBuffer.SetLength(wxStrlen(theBuffer)); } @@ -650,11 +728,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 +759,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 +787,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 +802,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 +818,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 +834,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 +857,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,19 +881,19 @@ void wxURI::Resolve(const wxURI& base, int flags) // T.query = R.query; if (m_path[0u] != wxT('/')) { - //Marge paths - const wxChar* op = m_path.c_str(); - const wxChar* bp = base.m_path.c_str() + base.m_path.Length(); + //Merge paths + wxString::const_iterator op = m_path.begin(); + wxString::const_iterator bp = base.m_path.begin() + base.m_path.length(); //not a ending directory? move up if (base.m_path[0] && *(bp-1) != wxT('/')) - UpTree(base.m_path, bp); + UpTree(base.m_path.begin(), 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); + UpTree(base.m_path.begin(), bp); if (*(op+2) == '\0') op += 2; @@ -811,28 +901,52 @@ 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.substr((op - m_path.c_str()), m_path.Length()); + m_path = base.m_path.substr(0, bp - base.m_path.begin()) + + m_path.substr((op - m_path.begin()), m_path.length()); } } - //T.fragment = R.fragment; + //T.fragment = R.fragment; } // --------------------------------------------------------------------------- -// UpTree +// UpTree // // Moves a URI path up a directory // --------------------------------------------------------------------------- //static -void wxURI::UpTree(const wxChar* uristart, const wxChar*& uri) +void wxURI::UpTree(wxString::const_iterator uristart, + wxString::const_iterator& uri) +{ + if (uri != uristart && *(uri-1) == wxT('/')) + { + uri -= 2; + } + + for(;uri != uristart; --uri) + { + if (*uri == wxT('/')) + { + ++uri; + break; + } + } + + //!!!TODO:HACK!!!// + if (uri == uristart && *uri == wxT('/')) + ++uri; + //!!!// +} + +// FIXME-UTF8: fix Normalize() to use iterators instead of having this method! +/*static*/ void wxURI::UpTree(const wxChar* uristart, const wxChar*& uri) { if (uri != uristart && *(uri-1) == wxT('/')) { uri -= 2; } - + for(;uri != uristart; --uri) { if (*uri == wxT('/')) @@ -847,6 +961,7 @@ void wxURI::UpTree(const wxChar* uristart, const wxChar*& uri) ++uri; //!!!// } +// end of FIXME-UTF8 // --------------------------------------------------------------------------- // Normalize @@ -879,7 +994,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 +1027,7 @@ void wxURI::Normalize(wxChar* s, bool bIgnoreLeads) } } else - *s++ = *cp++; + *s++ = *cp++; } *s = '\0'; @@ -922,7 +1037,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 +1056,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 +1076,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 +1102,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 +1143,7 @@ bool wxURI::ParseIPv6address(const wxChar*& uri) bEndHex = true; break; } - + if(*uri != wxT(':')) { break; @@ -1065,7 +1180,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 +1193,7 @@ bool wxURI::ParseIPv6address(const wxChar*& uri) else { uri += 2; - + if (numPrefix > 3) maxPostfix = 0; else @@ -1099,7 +1214,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 +1223,7 @@ bool wxURI::ParseIPv6address(const wxChar*& uri) return true; uri = uristart; - + if (!bAllowAltEnding) return false; } @@ -1139,18 +1254,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 +1276,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 +1315,7 @@ bool wxURI::IsSubDelim (const wxChar& c) c == wxT('+') || c == wxT(',') || c == wxT(';') || - c == wxT('=') + c == wxT('=') ; } @@ -1214,75 +1329,6 @@ bool wxURI::IsDigit(const wxChar& c) { return c >= wxT('0') && c <= wxT('9'); } -// --------------------------------------------------------------------------- -// -// wxURL Compatability -// -// --------------------------------------------------------------------------- - -#if wxUSE_URL - -#if WXWIN_COMPATIBILITY_2_4 - -#include "wx/url.h" - -//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) -{ - 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) -{ - return wxURI::Unescape(uri); -} - -#endif //WXWIN_COMPATIBILITY_2_4 - -#endif //wxUSE_URL - //end of uri.cpp