From ce321570b08e1a2937415ef6388a1a98fd1c4b83 Mon Sep 17 00:00:00 2001 From: Ryan Norton Date: Thu, 28 Oct 2004 22:22:40 +0000 Subject: [PATCH] wxURL - doc cleanups, depreciated more methods, more source comments. wxURI - enclosed literal characters with wxT, more source comments, doc cleanups, changed StartsWith(x) to [ou] == x git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@30153 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775 --- docs/latex/wx/uri.tex | 18 ++- docs/latex/wx/url.tex | 44 +++---- include/wx/uri.h | 12 +- include/wx/url.h | 10 +- src/common/uri.cpp | 289 ++++++++++++++++++++++++------------------ src/common/url.cpp | 50 +++++--- 6 files changed, 242 insertions(+), 181 deletions(-) diff --git a/docs/latex/wx/uri.tex b/docs/latex/wx/uri.tex index 3792241a2b..95109a8b64 100644 --- a/docs/latex/wx/uri.tex +++ b/docs/latex/wx/uri.tex @@ -22,6 +22,9 @@ In short, a URL \em{is} a URI. In other words, URL is a subset of a URI - all acceptable URLs are also acceptable URIs. +wxURI automatically escapes invalid characters in a string, +so there is no chance of wxURI "failing" on construction/creation. + wxURI supports copy construction and standard assignment operators. wxURI can also be inherited from to provide furthur functionality. @@ -39,7 +42,7 @@ furthur functionality. \membersection{Obtaining individual components}\label{obtainingwxuricomponents} To obtain individual components you can use -one of the following methods: +one of the following methods \helpref{GetScheme}{wxurigetscheme}\\ \helpref{GetUser}{wxurigetuser}\\ @@ -50,8 +53,12 @@ one of the following methods: \helpref{GetFragment}{wxurigetfragment} However, you should check HasXXX before -calling a get method:\\ - +calling a get method, which determines whether or not the component referred +to by the method is defined according to RFC 2396. + +Consider an undefined component equivilent to a +NULL C string.\\ +\\ \helpref{HasScheme}{wxurihasscheme}\\ \helpref{HasUser}{wxurihasuser}\\ \helpref{HasServer}{wxurihasserver}\\ @@ -112,10 +119,13 @@ BuildUnescapedURI performs some optimizations over the plain method. \membersection{wxURI::Create}\label{wxuricreate} -\func{void}{Create}{\param{const wxChar* }{uri}} +\func{const wxChar*}{Create}{\param{const wxChar* }{uri}} Creates this URI from the string \arg{uri}. +Returns the position at which parsing stopped (there +is no such thing as an "invalid" wxURI). + \docparam{uri}{string to initialize from} diff --git a/docs/latex/wx/url.tex b/docs/latex/wx/url.tex index 04b4bfb742..7452671911 100644 --- a/docs/latex/wx/url.tex +++ b/docs/latex/wx/url.tex @@ -17,16 +17,6 @@ and comparison operators. \helpref{wxSocketBase}{wxsocketbase}, \helpref{wxProtocol}{wxprotocol} -\wxheading{Example} - -\begin{verbatim} - wxURL url("http://a.host/a.dir/a.file"); - wxInputStream *in_stream; - - in_stream = url.GetInputStream(); - // Then, you can use all IO calls of in_stream (See wxStream) -\end{verbatim} - % ---------------------------------------------------------------------------- % Members % ---------------------------------------------------------------------------- @@ -53,15 +43,6 @@ contain three consecutive slashes. Destroys the URL object. -% -% GetProtocolName -% -\membersection{wxURL::GetProtocolName}\label{wxurlgetprotocolname} - -\constfunc{wxString}{GetProtocolName}{\void} - -Returns the name of the protocol which will be used to get the URL. - % % GetProtocol % @@ -71,15 +52,6 @@ Returns the name of the protocol which will be used to get the URL. Returns a reference to the protocol which will be used to get the URL. -% -% GetPath -% -\membersection{wxURL::GetPath}\label{wxurlgetpath} - -\func{wxString}{GetPath}{\void} - -Returns the path of the file to fetch. This path was encoded in the URL. - % % GetError % @@ -112,6 +84,22 @@ Creates a new input stream on the the specified URL. You can use all but seek functionality of wxStream. Seek isn't available on all stream. For example, http or ftp streams doesn't deal with it. +Note that this method is somewhat depreciated, all future wxWidgets applications +should really use \helpref{wxFileSystem}{wxfilesystem} instead. + +Example: + +\begin{verbatim} + wxURL url("http://a.host/a.dir/a.file"); + if (url.GetError() == wxURL_NOERR) + { + wxInputStream *in_stream; + + in_stream = url.GetInputStream(); + // Then, you can use all IO calls of in_stream (See wxStream) + } +\end{verbatim} + \wxheading{Return value} Returns the initialized stream. You will have to delete it yourself. diff --git a/include/wx/uri.h b/include/wx/uri.h index 852c0bd987..a92b836929 100644 --- a/include/wx/uri.h +++ b/include/wx/uri.h @@ -19,13 +19,13 @@ #include "wx/object.h" #include "wx/string.h" -// Host Type that the server can be +// Host Type that the server component can be enum wxURIHostType { - wxURI_REGNAME, - wxURI_IPV4ADDRESS, - wxURI_IPV6ADDRESS, - wxURI_IPVFUTURE + wxURI_REGNAME, // Host is a normal register name (www.mysite.com etc.) + wxURI_IPV4ADDRESS, // Host is a version 4 ip address (192.168.1.100) + wxURI_IPV6ADDRESS, // Host is a version 6 ip address [aa:aa:aa:aa::aa:aa]:5050 + wxURI_IPVFUTURE // Host is a future ip address (wxURI is unsure what kind) }; // Component Flags @@ -70,7 +70,7 @@ public: bool HasPath() const { return (m_fields & wxURI_PATH) == wxURI_PATH; } bool HasQuery() const { return (m_fields & wxURI_QUERY) == wxURI_QUERY; } bool HasFragment() const { return (m_fields & wxURI_FRAGMENT) == wxURI_FRAGMENT; } - + const wxString& GetScheme() const { return m_scheme; } const wxString& GetPath() const { return m_path; } const wxString& GetQuery() const { return m_query; } diff --git a/include/wx/url.h b/include/wx/url.h index 36af3f2a59..984a87fffc 100644 --- a/include/wx/url.h +++ b/include/wx/url.h @@ -58,12 +58,9 @@ public: wxURL& operator = (const wxString& url); wxURL& operator = (const wxURI& url); - wxString GetProtocolName() const { return m_scheme; } - wxString GetHostName() const { return m_server; } - wxString GetURL() const { return m_url; } wxProtocol& GetProtocol() { return *m_protocol; } wxURLError GetError() const { return m_error; } - wxString GetPath() const { return m_path; } + wxString GetURL() const { return m_url; } wxInputStream *GetInputStream(); @@ -73,6 +70,11 @@ public: #endif // wxUSE_SOCKETS #if WXWIN_COMPATIBILITY_2_4 + //Use the proper wxURI accessors instead + wxString GetProtocolName() const { return m_scheme; } + wxString GetHostName() const { return m_server; } + wxString GetPath() const { return m_path; } + //Use wxURI instead - delims is ignored static wxString ConvertToValidURI( const wxString& uri, diff --git a/src/common/uri.cpp b/src/common/uri.cpp index 3bbdccb3a7..73b6b1d39d 100644 --- a/src/common/uri.cpp +++ b/src/common/uri.cpp @@ -8,11 +8,6 @@ // Licence: wxWindows ///////////////////////////////////////////////////////////////////////////// -// -//TODO: RN: I had some massive doxygen docs, I need to move these -//in a presentable form in these sources -// - // =========================================================================== // declarations // =========================================================================== @@ -106,12 +101,16 @@ const wxChar* wxURI::Create(const wxString& uri) } // --------------------------------------------------------------------------- -// Escape/TranslateEscape/IsEscape +// Escape Methods // // TranslateEscape unencodes a 3 character URL escape sequence +// // Escape encodes an invalid URI character into a 3 character sequence +// // IsEscape determines if the input string contains an escape sequence, // if it does, then it moves the input string past the escape sequence +// +// Unescape unencodes all 3 character URL escape sequences in a wxString // --------------------------------------------------------------------------- wxChar wxURI::TranslateEscape(const wxChar* s) @@ -140,14 +139,15 @@ wxString wxURI::Unescape(const wxString& uri) void wxURI::Escape(wxString& s, const wxChar& c) { const wxChar* hdig = wxT("0123456789abcdef"); - s += '%'; + s += wxT('%'); s += hdig[(c >> 4) & 15]; s += hdig[c & 15]; } bool wxURI::IsEscape(const wxChar*& uri) { - if(*uri == '%' && IsHex(*(uri+1)) && IsHex(*(uri+2))) + // pct-encoded = "%" HEXDIG HEXDIG + if(*uri == wxT('%') && IsHex(*(uri+1)) && IsHex(*(uri+2))) { uri += 3; return true; @@ -161,6 +161,9 @@ bool wxURI::IsEscape(const wxChar*& uri) // // 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 +// the components that accept escape sequences // --------------------------------------------------------------------------- wxString wxURI::BuildURI() const @@ -229,14 +232,9 @@ wxString wxURI::BuildUnescapedURI() const } // --------------------------------------------------------------------------- -// operator = and == +// Assignment // --------------------------------------------------------------------------- -wxURI& wxURI::operator = (const wxURI& uri) -{ - return Assign(uri); -} - wxURI& wxURI::Assign(const wxURI& uri) { //assign fields @@ -255,12 +253,21 @@ wxURI& wxURI::Assign(const wxURI& uri) return *this; } +wxURI& wxURI::operator = (const wxURI& uri) +{ + return Assign(uri); +} + wxURI& wxURI::operator = (const wxString& string) { Create(string); return *this; } +// --------------------------------------------------------------------------- +// Comparison +// --------------------------------------------------------------------------- + bool wxURI::operator == (const wxURI& uri) const { if (HasScheme()) @@ -372,17 +379,16 @@ const wxChar* wxURI::ParseScheme(const wxChar* uri) m_scheme += *uri++; //scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) - //RN: Scheme can not be escaped while (IsAlpha(*uri) || IsDigit(*uri) || - *uri == '+' || - *uri == '-' || - *uri == '.') + *uri == wxT('+') || + *uri == wxT('-') || + *uri == wxT('.')) { m_scheme += *uri++; } //valid scheme? - if (*uri == ':') + if (*uri == wxT(':')) { //mark the scheme as valid m_fields |= wxURI_SCHEME; @@ -403,7 +409,7 @@ const wxChar* wxURI::ParseScheme(const wxChar* uri) const wxChar* wxURI::ParseAuthority(const wxChar* uri) { // authority = [ userinfo "@" ] host [ ":" port ] - if (*uri == '/' && *(uri+1) == '/') + if (*uri == wxT('/') && *(uri+1) == wxT('/')) { uri += 2; @@ -424,16 +430,16 @@ const wxChar* wxURI::ParseUser(const wxChar* uri) const wxChar* uricopy = uri; // userinfo = *( unreserved / pct-encoded / sub-delims / ":" ) - while(*uri && *uri != '@' && *uri != '/' && *uri != '#' && *uri != '?') + while(*uri && *uri != wxT('@') && *uri != wxT('/') && *uri != wxT('#') && *uri != wxT('?')) { if(IsUnreserved(*uri) || IsEscape(uri) || - IsSubDelim(*uri) || *uri == ':') + IsSubDelim(*uri) || *uri == wxT(':')) m_user += *uri++; else Escape(m_user, *uri++); } - if(*uri == '@') + if(*uri == wxT('@')) { //valid userinfo m_fields |= wxURI_USER; @@ -456,9 +462,9 @@ const wxChar* wxURI::ParseServer(const wxChar* uri) // host = IP-literal / IPv4address / reg-name // IP-literal = "[" ( IPv6address / IPvFuture ) "]" - if (*uri == '[') + if (*uri == wxT('[')) { - if (ParseIPv6address(++uri) && *uri == ']') + if (ParseIPv6address(++uri) && *uri == wxT(']')) { ++uri; m_hostType = wxURI_IPV6ADDRESS; @@ -471,7 +477,7 @@ const wxChar* wxURI::ParseServer(const wxChar* uri) { uri = uricopy; - if (ParseIPvFuture(++uri) && *uri == ']') + if (ParseIPvFuture(++uri) && *uri == wxT(']')) { ++uri; m_hostType = wxURI_IPVFUTURE; @@ -502,7 +508,7 @@ const wxChar* wxURI::ParseServer(const wxChar* uri) { uri = uricopy; // reg-name = *( unreserved / pct-encoded / sub-delims ) - while(*uri && *uri != '/' && *uri != ':' && *uri != '#' && *uri != '?') + while(*uri && *uri != wxT('/') && *uri != wxT(':') && *uri != wxT('#') && *uri != wxT('?')) { if(IsUnreserved(*uri) || IsEscape(uri) || IsSubDelim(*uri)) m_server += *uri++; @@ -523,7 +529,7 @@ const wxChar* wxURI::ParsePort(const wxChar* uri) wxASSERT(uri != NULL); // port = *DIGIT - if(*uri == ':') + if(*uri == wxT(':')) { ++uri; while(IsDigit(*uri)) @@ -568,14 +574,14 @@ const wxChar* wxURI::ParsePath(const wxChar* uri, bool bReference, bool bNormali /// ; non-zero-length segment without any colon ":" /// /// pchar = unreserved / pct-encoded / sub-delims / ":" / "@" - if (*uri == '/') + if (*uri == wxT('/')) { m_path += *uri++; - while(*uri && *uri != '#' && *uri != '?') + while(*uri && *uri != wxT('#') && *uri != wxT('?')) { if( IsUnreserved(*uri) || IsSubDelim(*uri) || IsEscape(uri) || - *uri == ':' || *uri == '@' || *uri == '/') + *uri == wxT(':') || *uri == wxT('@') || *uri == wxT('/')) m_path += *uri++; else Escape(m_path, *uri++); @@ -595,10 +601,10 @@ const wxChar* wxURI::ParsePath(const wxChar* uri, bool bReference, bool bNormali if (bReference) { //no colon allowed - while(*uri && *uri != '#' && *uri != '?') + while(*uri && *uri != wxT('#') && *uri != wxT('?')) { if(IsUnreserved(*uri) || IsSubDelim(*uri) || IsEscape(uri) || - *uri == '@' || *uri == '/') + *uri == wxT('@') || *uri == wxT('/')) m_path += *uri++; else Escape(m_path, *uri++); @@ -606,10 +612,10 @@ const wxChar* wxURI::ParsePath(const wxChar* uri, bool bReference, bool bNormali } else { - while(*uri && *uri != '#' && *uri != '?') + while(*uri && *uri != wxT('#') && *uri != wxT('?')) { if(IsUnreserved(*uri) || IsSubDelim(*uri) || IsEscape(uri) || - *uri == ':' || *uri == '@' || *uri == '/') + *uri == wxT(':') || *uri == wxT('@') || *uri == wxT('/')) m_path += *uri++; else Escape(m_path, *uri++); @@ -639,13 +645,13 @@ const wxChar* wxURI::ParseQuery(const wxChar* uri) wxASSERT(uri != NULL); // query = *( pchar / "/" / "?" ) - if (*uri == '?') + if (*uri == wxT('?')) { ++uri; - while(*uri && *uri != '#') + while(*uri && *uri != wxT('#')) { if (IsUnreserved(*uri) || IsSubDelim(*uri) || IsEscape(uri) || - *uri == ':' || *uri == '@' || *uri == '/' || *uri == '?') + *uri == wxT(':') || *uri == wxT('@') || *uri == wxT('/') || *uri == wxT('?')) m_query += *uri++; else Escape(m_query, *uri++); @@ -664,13 +670,13 @@ const wxChar* wxURI::ParseFragment(const wxChar* uri) wxASSERT(uri != NULL); // fragment = *( pchar / "/" / "?" ) - if (*uri == '#') + if (*uri == wxT('#')) { ++uri; while(*uri) { if (IsUnreserved(*uri) || IsSubDelim(*uri) || IsEscape(uri) || - *uri == ':' || *uri == '@' || *uri == '/' || *uri == '?') + *uri == wxT(':') || *uri == wxT('@') || *uri == wxT('/') || *uri == wxT('?')) m_fragment += *uri++; else Escape(m_fragment, *uri++); @@ -684,12 +690,14 @@ const wxChar* wxURI::ParseFragment(const wxChar* uri) } // --------------------------------------------------------------------------- -// Resolve URI +// Resolve // -// Builds missing components of this uri from a base uri +// Builds missing components of this uri from a base uri // -// A version of the algorithm outlined in the RFC is used here -// (it is shown in comments) +// 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 // --------------------------------------------------------------------------- void wxURI::Resolve(const wxURI& base, int flags) @@ -697,7 +705,7 @@ void wxURI::Resolve(const wxURI& base, int flags) wxASSERT_MSG(!base.IsReference(), wxT("wxURI to inherit from must not be a reference!")); - // If we arn't being strict, enable the older + // If we arn't being strict, enable the older (pre-RFC2396) // loophole that allows this uri to inherit other // properties from the base uri - even if the scheme // is defined @@ -781,19 +789,19 @@ void wxURI::Resolve(const wxURI& base, int flags) // T.path = remove_dot_segments(T.path); // endif; // T.query = R.query; - if (!m_path.StartsWith(wxT("/"))) + 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(); //not a ending directory? move up - if (base.m_path[0] && *(bp-1) != '/') + if (base.m_path[0] && *(bp-1) != wxT('/')) UpTree(base.m_path, bp); //normalize directories - while(*op == '.' && *(op+1) == '.' && - (*(op+2) == '\0' || *(op+2) == '/') ) + while(*op == wxT('.') && *(op+1) == wxT('.') && + (*(op+2) == '\0' || *(op+2) == wxT('/')) ) { UpTree(base.m_path, bp); @@ -807,27 +815,27 @@ void wxURI::Resolve(const wxURI& base, int flags) m_path.Mid((op - m_path.c_str()), m_path.Length()); } } + + //T.fragment = R.fragment; } // --------------------------------------------------------------------------- -// Directory Normalization (static) +// UpTree // -// UpTree goes up a directory in a string and moves the pointer as such, -// while Normalize gets rid of duplicate/erronues directories in a URI -// according to RFC 2396 and modified quite a bit to meet the unit tests -// in it. +// Moves a URI path up a directory // --------------------------------------------------------------------------- +//static void wxURI::UpTree(const wxChar* uristart, const wxChar*& uri) { - if (uri != uristart && *(uri-1) == '/') + if (uri != uristart && *(uri-1) == wxT('/')) { uri -= 2; } for(;uri != uristart; --uri) { - if (*uri == '/') + if (*uri == wxT('/')) { ++uri; break; @@ -835,23 +843,35 @@ void wxURI::UpTree(const wxChar* uristart, const wxChar*& uri) } //!!!TODO:HACK!!!// - if (uri == uristart && *uri == '/') + if (uri == uristart && *uri == wxT('/')) ++uri; //!!!// } +// --------------------------------------------------------------------------- +// Normalize +// +// Normalizes directories in-place +// +// I.E. ./ and . are ignored +// +// ../ and .. are removed if a directory is before it, along +// with that directory (leading .. and ../ are kept) +// --------------------------------------------------------------------------- + +//static void wxURI::Normalize(wxChar* s, bool bIgnoreLeads) { wxChar* cp = s; wxChar* bp = s; - if(s[0] == '/') + if(s[0] == wxT('/')) ++bp; while(*cp) { - if (*cp == '.' && (*(cp+1) == '/' || *(cp+1) == '\0') - && (bp == cp || *(cp-1) == '/')) + if (*cp == wxT('.') && (*(cp+1) == wxT('/') || *(cp+1) == '\0') + && (bp == cp || *(cp-1) == wxT('/'))) { //. _or_ ./ - ignore if (*(cp+1) == '\0') @@ -859,9 +879,9 @@ void wxURI::Normalize(wxChar* s, bool bIgnoreLeads) else cp += 2; } - else if (*cp == '.' && *(cp+1) == '.' && - (*(cp+2) == '/' || *(cp+2) == '\0') - && (bp == cp || *(cp-1) == '/')) + else if (*cp == wxT('.') && *(cp+1) == wxT('.') && + (*(cp+2) == wxT('/') || *(cp+2) == '\0') + && (bp == cp || *(cp-1) == wxT('/'))) { //.. _or_ ../ - go up the tree if (s != bp) @@ -899,7 +919,32 @@ void wxURI::Normalize(wxChar* s, bool bIgnoreLeads) } // --------------------------------------------------------------------------- -// Misc. Parsing Methods +// 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 +// the input string back to its original position on failure. +// --------------------------------------------------------------------------- + +bool wxURI::ParseH16(const wxChar*& uri) +{ + // h16 = 1*4HEXDIG + if(!IsHex(*++uri)) + return false; + + if(IsHex(*++uri) && IsHex(*++uri) && IsHex(*++uri)) + ++uri; + + return true; +} + +// --------------------------------------------------------------------------- +// 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 +// to its original position on failure. // --------------------------------------------------------------------------- bool wxURI::ParseIPv4address(const wxChar*& uri) @@ -920,10 +965,10 @@ bool wxURI::ParseIPv4address(const wxChar*& uri) //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) < '2') || + !( (*(uri-2) < wxT('2')) || //240 or less - (*(uri-2) == '2' && - (*(uri-1) < '5' || (*(uri-1) == '5' && *uri <= '5')) + (*(uri-2) == wxT('2') && + (*(uri-1) < wxT('5') || (*(uri-1) == wxT('5') && *uri <= wxT('5'))) ) ) ) @@ -936,16 +981,16 @@ bool wxURI::ParseIPv4address(const wxChar*& uri) //compilers should unroll this loop for(; iIPv4 < 4; ++iIPv4) { - if (*uri != '.' || !IsDigit(*++uri)) + if (*uri != wxT('.') || !IsDigit(*++uri)) break; //each ip part must be between 0-255 if( IsDigit(*++uri) && IsDigit(*++uri) && //100 or less (note !) - !( (*(uri-2) < '2') || + !( (*(uri-2) < wxT('2')) || //240 or less - (*(uri-2) == '2' && - (*(uri-1) < '5' || (*(uri-1) == '5' && *uri <= '5')) + (*(uri-2) == wxT('2') && + (*(uri-1) < wxT('5') || (*(uri-1) == wxT('5') && *uri <= wxT('5'))) ) ) ) @@ -958,18 +1003,6 @@ bool wxURI::ParseIPv4address(const wxChar*& uri) return iIPv4 == 4; } -bool wxURI::ParseH16(const wxChar*& uri) -{ - // h16 = 1*4HEXDIG - if(!IsHex(*++uri)) - return false; - - if(IsHex(*++uri) && IsHex(*++uri) && IsHex(*++uri)) - ++uri; - - return true; -} - bool wxURI::ParseIPv6address(const wxChar*& uri) { // IPv6address = 6( h16 ":" ) ls32 @@ -996,7 +1029,7 @@ bool wxURI::ParseIPv6address(const wxChar*& uri) break; } - if(*uri != ':') + if(*uri != wxT(':')) { break; } @@ -1009,9 +1042,9 @@ bool wxURI::ParseIPv6address(const wxChar*& uri) if (numPrefix) return false; - if (*uri == ':') + if (*uri == wxT(':')) { - if (*++uri != ':') + if (*++uri != wxT(':')) return false; maxPostfix = 5; @@ -1021,18 +1054,18 @@ bool wxURI::ParseIPv6address(const wxChar*& uri) } else { - if (*uri != ':' || *(uri+1) != ':') + if (*uri != wxT(':') || *(uri+1) != wxT(':')) { if (numPrefix != 6) return false; - while (*--uri != ':') {} + while (*--uri != wxT(':')) {} ++uri; const wxChar* uristart = uri; //parse ls32 // ls32 = ( h16 ":" h16 ) / IPv4address - if (ParseH16(uri) && *uri == ':' && ParseH16(uri)) + if (ParseH16(uri) && *uri == wxT(':') && ParseH16(uri)) return true; uri = uristart; @@ -1057,7 +1090,7 @@ bool wxURI::ParseIPv6address(const wxChar*& uri) for(; maxPostfix != 0; --maxPostfix) { - if(!ParseH16(uri) || *uri != ':') + if(!ParseH16(uri) || *uri != wxT(':')) return false; } @@ -1066,7 +1099,7 @@ bool wxURI::ParseIPv6address(const wxChar*& uri) const wxChar* uristart = uri; //parse ls32 // ls32 = ( h16 ":" h16 ) / IPv4address - if (ParseH16(uri) && *uri == ':' && ParseH16(uri)) + if (ParseH16(uri) && *uri == wxT(':') && ParseH16(uri)) return true; uri = uristart; @@ -1089,40 +1122,50 @@ bool wxURI::ParseIPv6address(const wxChar*& uri) bool wxURI::ParseIPvFuture(const wxChar*& uri) { // IPvFuture = "v" 1*HEXDIG "." 1*( unreserved / sub-delims / ":" ) - if (*++uri != 'v' || !IsHex(*++uri)) + if (*++uri != wxT('v') || !IsHex(*++uri)) return false; while (IsHex(*++uri)) {} - if (*uri != '.' || !(IsUnreserved(*++uri) || IsSubDelim(*uri) || *uri == ':')) + if (*uri != wxT('.') || !(IsUnreserved(*++uri) || IsSubDelim(*uri) || *uri == wxT(':'))) return false; - while(IsUnreserved(*++uri) || IsSubDelim(*uri) || *uri == ':') {} + while(IsUnreserved(*++uri) || IsSubDelim(*uri) || *uri == wxT(':')) {} return true; } // --------------------------------------------------------------------------- -// Misc methods - IsXXX and CharToHex +// CharToHex +// +// 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) { - if ((c >= 'A') && (c <= 'Z')) return c - 'A' + 0x0A; - if ((c >= 'a') && (c <= 'z')) return c - 'a' + 0x0a; - if ((c >= '0') && (c <= '9')) return c - '0' + 0x00; + 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; return 0; } +// --------------------------------------------------------------------------- +// IsXXX +// +// Returns true if the passed in character meets the criteria of the method +// --------------------------------------------------------------------------- + //! unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~" bool wxURI::IsUnreserved (const wxChar& c) { return IsAlpha(c) || IsDigit(c) || - c == '-' || - c == '.' || - c == '_' || - c == '~' //tilde + c == wxT('-') || + c == wxT('.') || + c == wxT('_') || + c == wxT('~') //tilde ; } @@ -1134,41 +1177,41 @@ bool wxURI::IsReserved (const wxChar& c) //! gen-delims = ":" / "/" / "?" / "#" / "[" / "]" / "@" bool wxURI::IsGenDelim (const wxChar& c) { - return c == ':' || - c == '/' || - c == '?' || - c == '#' || - c == '[' || - c == ']' || - c == '@'; + return c == wxT(':') || + c == wxT('/') || + c == wxT('?') || + c == wxT('#') || + c == wxT('[') || + c == wxT(']') || + c == wxT('@'); } //! sub-delims = "!" / "$" / "&" / "'" / "(" / ")" //! / "*" / "+" / "," / ";" / "=" bool wxURI::IsSubDelim (const wxChar& c) { - return c == '!' || - c == '$' || - c == '&' || - c == '\'' || - c == '(' || - c == ')' || - c == '*' || - c == '+' || - c == ',' || - c == ';' || - c == '=' + return c == wxT('!') || + c == wxT('$') || + c == wxT('&') || + c == wxT('\'') || + c == wxT('(') || + c == wxT(')') || + c == wxT('*') || + c == wxT('+') || + c == wxT(',') || + c == wxT(';') || + c == wxT('=') ; } bool wxURI::IsHex(const wxChar& c) -{ return IsDigit(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'); } +{ return IsDigit(c) || (c >= wxT('a') && c <= wxT('f')) || (c >= wxT('A') && c <= wxT('F')); } bool wxURI::IsAlpha(const wxChar& c) -{ return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); } +{ return (c >= wxT('a') && c <= wxT('z')) || (c >= wxT('A') && c <= wxT('Z')); } bool wxURI::IsDigit(const wxChar& c) -{ return c >= '0' && c <= '9'; } +{ return c >= wxT('0') && c <= wxT('9'); } // --------------------------------------------------------------------------- diff --git a/src/common/url.cpp b/src/common/url.cpp index b6b91694b1..fc8187bd3c 100644 --- a/src/common/url.cpp +++ b/src/common/url.cpp @@ -54,6 +54,10 @@ USE_PROTOCOL(wxFTP) // // -------------------------------------------------------------- +// -------------------------------------------------------------- +// Construction +// -------------------------------------------------------------- + wxURL::wxURL(const wxString& url) : wxURI(url) { Init(url); @@ -66,21 +70,6 @@ wxURL::wxURL(const wxURI& url) : wxURI(url) ParseURL(); } -wxURL& wxURL::operator = (const wxURI& url) -{ - wxURI::operator = (url); - Init(url.BuildURI()); - ParseURL(); - return *this; -} -wxURL& wxURL::operator = (const wxString& url) -{ - wxURI::operator = (url); - Init(url); - ParseURL(); - return *this; -} - void wxURL::Init(const wxString& url) { m_protocol = NULL; @@ -107,6 +96,26 @@ void wxURL::Init(const wxString& url) #endif // wxUSE_SOCKETS } + +// -------------------------------------------------------------- +// Assignment +// -------------------------------------------------------------- + +wxURL& wxURL::operator = (const wxURI& url) +{ + wxURI::operator = (url); + Init(url.BuildURI()); + ParseURL(); + return *this; +} +wxURL& wxURL::operator = (const wxString& url) +{ + wxURI::operator = (url); + Init(url); + ParseURL(); + return *this; +} + // -------------------------------------------------------------- // ParseURL // @@ -167,6 +176,10 @@ bool wxURL::ParseURL() return true; } +// -------------------------------------------------------------- +// Destruction/Cleanup +// -------------------------------------------------------------- + void wxURL::CleanData() { #if wxUSE_SOCKETS @@ -187,6 +200,9 @@ wxURL::~wxURL() #endif } +// -------------------------------------------------------------- +// FetchProtocol +// -------------------------------------------------------------- bool wxURL::FetchProtocol() { @@ -208,7 +224,7 @@ bool wxURL::FetchProtocol() } // -------------------------------------------------------------- -// --------- wxURL get ------------------------------------------ +// GetInputStream // -------------------------------------------------------------- wxInputStream *wxURL::GetInputStream() @@ -365,6 +381,8 @@ void wxURL::SetProxy(const wxString& url_proxy) #endif // wxUSE_SOCKETS // ---------------------------------------------------------------------- +// wxURLModule +// // A module which deletes the default proxy if we created it // ---------------------------------------------------------------------- -- 2.45.2