AuroraMiddleware/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

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

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@30153 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Ryan Norton 2004-10-28 22:22:40 +00:00
parent 5bb05e6dc6
commit ce321570b0
6 changed files with 242 additions and 181 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
docs/latex/wx/uri.tex
View File

@ -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}

44
docs/latex/wx/url.tex
View File

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

12
include/wx/uri.h
View File

@ -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; }

10
include/wx/url.h
View File

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

289
src/common/uri.cpp
View File

@ -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'); }
// ---------------------------------------------------------------------------

50
src/common/url.cpp
View File

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