ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

urlmon: Fix various typos/misspellings.

This commit is contained in:
Frédéric Delanoy 2011-07-23 09:14:25 +02:00 committed by Alexandre Julliard
parent 46a2ec0209
commit d1e15baca7
1 changed files with 60 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

118
dlls/urlmon/uri.c
View File

@ -233,7 +233,7 @@ static const struct {
{URL_SCHEME_HTTPS, 443}, {URL_SCHEME_HTTPS, 443},
}; };
/* List of 3 character top level domain names Windows seems to recognize. /* List of 3-character top level domain names Windows seems to recognize.
* There might be more, but, these are the only ones I've found so far. * There might be more, but, these are the only ones I've found so far.
*/ */
static const struct { static const struct {
@ -278,7 +278,7 @@ static inline BOOL is_forbidden_dos_path_char(WCHAR val) {
} }
/* A URI is implicitly a file path if it begins with /* A URI is implicitly a file path if it begins with
* a drive letter (eg X:) or starts with "\\" (UNC path). * a drive letter (e.g. X:) or starts with "\\" (UNC path).
*/ */
static inline BOOL is_implicit_file_path(const WCHAR *str) { static inline BOOL is_implicit_file_path(const WCHAR *str) {
return (is_unc_path(str) || (is_alpha(str[0]) && str[1] == ':')); return (is_unc_path(str) || (is_alpha(str[0]) && str[1] == ':'));
@ -328,7 +328,7 @@ static inline BOOL is_gendelim(WCHAR val) {
/* Characters that delimit the end of the authority /* Characters that delimit the end of the authority
* section of a URI. Sometimes a '\\' is considered * section of a URI. Sometimes a '\\' is considered
* an authority delimeter. * an authority delimiter.
*/ */
static inline BOOL is_auth_delim(WCHAR val, BOOL acceptSlash) { static inline BOOL is_auth_delim(WCHAR val, BOOL acceptSlash) {
return (val == '#' || val == '/' || val == '?' || return (val == '#' || val == '/' || val == '?' ||
@ -403,7 +403,7 @@ static void apply_default_flags(DWORD *flags) {
/* Determines if the URI is hierarchical using the information already parsed into /* Determines if the URI is hierarchical using the information already parsed into
* data and using the current location of parsing in the URI string. * data and using the current location of parsing in the URI string.
* *
* Windows considers a URI hierarchical if on of the following is true: * Windows considers a URI hierarchical if one of the following is true:
* A.) It's a wildcard scheme. * A.) It's a wildcard scheme.
* B.) It's an implicit file scheme. * B.) It's an implicit file scheme.
* C.) It's a known hierarchical scheme and it has two '\\' after the scheme name. * C.) It's a known hierarchical scheme and it has two '\\' after the scheme name.
@ -526,8 +526,8 @@ static BOOL are_equal_simple(const Uri *a, const Uri *b) {
} }
/* Computes the size of the given IPv6 address. /* Computes the size of the given IPv6 address.
* Each h16 component is 16bits, if there is an IPv4 address, it's * Each h16 component is 16 bits. If there is an IPv4 address, it's
* 32bits. If there's an elision it can be 16bits to 128bits, depending * 32 bits. If there's an elision it can be 16 to 128 bits, depending
* on the number of other components. * on the number of other components.
* *
* Modeled after google-url's CheckIPv6ComponentsSize function * Modeled after google-url's CheckIPv6ComponentsSize function
@ -541,7 +541,7 @@ static void compute_ipv6_comps_size(ipv6_address *address) {
if(address->elision) { if(address->elision) {
/* An elision can be anywhere from 2 bytes up to 16 bytes. /* An elision can be anywhere from 2 bytes up to 16 bytes.
* It size depends on the size of the h16 and IPv4 components. * Its size depends on the size of the h16 and IPv4 components.
*/ */
address->elision_size = 16 - address->components_size; address->elision_size = 16 - address->components_size;
if(address->elision_size < 2) if(address->elision_size < 2)
@ -567,7 +567,7 @@ static int hex_to_int(WCHAR val) {
* the two characters following the '%' aren't valid hex values then * the two characters following the '%' aren't valid hex values then
* this function returns the NULL character. * this function returns the NULL character.
* *
* Eg. * E.g.
* "%2E" will result in '.' being returned by this function. * "%2E" will result in '.' being returned by this function.
*/ */
static WCHAR decode_pct_val(const WCHAR *ptr) { static WCHAR decode_pct_val(const WCHAR *ptr) {
@ -616,7 +616,7 @@ void find_domain_name(const WCHAR *host, DWORD host_len,
*domain_start = -1; *domain_start = -1;
/* There has to be at least enough room for a '.' followed by a /* There has to be at least enough room for a '.' followed by a
* 3 character TLD for a domain to even exist in the host name. * 3-character TLD for a domain to even exist in the host name.
*/ */
if(host_len < 4) if(host_len < 4)
return; return;
@ -640,7 +640,7 @@ void find_domain_name(const WCHAR *host, DWORD host_len,
} else if(last_tld-host == 3) { } else if(last_tld-host == 3) {
DWORD i; DWORD i;
/* If there's three characters in front of last_tld and /* If there are three characters in front of last_tld and
* they are on the list of recognized TLDs, then this * they are on the list of recognized TLDs, then this
* host doesn't have a domain (since the host only contains * host doesn't have a domain (since the host only contains
* a TLD name. * a TLD name.
@ -789,12 +789,12 @@ static INT find_file_extension(const WCHAR *path, DWORD path_len) {
/* Computes the location where the elision should occur in the IPv6 /* Computes the location where the elision should occur in the IPv6
* address using the numerical values of each component stored in * address using the numerical values of each component stored in
* 'values'. If the address shouldn't contain an elision then 'index' * 'values'. If the address shouldn't contain an elision then 'index'
* is assigned -1 as it's value. Otherwise 'index' will contain the * is assigned -1 as its value. Otherwise 'index' will contain the
* starting index (into values) where the elision should be, and 'count' * starting index (into values) where the elision should be, and 'count'
* will contain the number of cells the elision covers. * will contain the number of cells the elision covers.
* *
* NOTES: * NOTES:
* Windows will expand an elision if the elision only represents 1 h16 * Windows will expand an elision if the elision only represents one h16
* component of the address. * component of the address.
* *
* Ex: [1::2:3:4:5:6:7] -> [1:0:2:3:4:5:6:7] * Ex: [1::2:3:4:5:6:7] -> [1:0:2:3:4:5:6:7]
@ -915,7 +915,7 @@ static UINT ipv4toui(const WCHAR *ip, DWORD len) {
return ret; return ret;
} }
/* Converts an IPv4 address in numerical form into it's fully qualified /* Converts an IPv4 address in numerical form into its fully qualified
* string form. This function returns the number of characters written * string form. This function returns the number of characters written
* to 'dest'. If 'dest' is NULL this function will return the number of * to 'dest'. If 'dest' is NULL this function will return the number of
* characters that would have been written. * characters that would have been written.
@ -956,7 +956,7 @@ static DWORD ui2str(WCHAR *dest, UINT value) {
return ret; return ret;
} }
/* Converts an h16 component (from an IPv6 address) into it's /* Converts a h16 component (from an IPv6 address) into its
* numerical value. * numerical value.
* *
* This function assumes that the h16 component has already been validated. * This function assumes that the h16 component has already been validated.
@ -1063,7 +1063,7 @@ static BOOL check_dec_octet(const WCHAR **ptr) {
++(*ptr); ++(*ptr);
c2 = *ptr; c2 = *ptr;
/* Since the 1 digit requirment was meet, it doesn't /* Since the 1-digit requirement was met, it doesn't
* matter if this is a DIGIT value, it's considered a * matter if this is a DIGIT value, it's considered a
* dec-octet. * dec-octet.
*/ */
@ -1270,7 +1270,7 @@ static BOOL parse_scheme(const WCHAR **ptr, parse_data *data, DWORD flags, DWORD
TRACE("(%p %p %x): URI is an implicit file path.\n", ptr, data, flags); TRACE("(%p %p %x): URI is an implicit file path.\n", ptr, data, flags);
} else { } else {
/* Window's does not consider anything that can implicitly be a file /* Windows does not consider anything that can implicitly be a file
* path to be a valid URI if the ALLOW_IMPLICIT_FILE_SCHEME flag is not set... * path to be a valid URI if the ALLOW_IMPLICIT_FILE_SCHEME flag is not set...
*/ */
TRACE("(%p %p %x): URI is implicitly a file path, but, the ALLOW_IMPLICIT_FILE_SCHEME flag wasn't set.\n", TRACE("(%p %p %x): URI is implicitly a file path, but, the ALLOW_IMPLICIT_FILE_SCHEME flag wasn't set.\n",
@ -1278,10 +1278,10 @@ static BOOL parse_scheme(const WCHAR **ptr, parse_data *data, DWORD flags, DWORD
return FALSE; return FALSE;
} }
} else if(!parse_scheme_name(ptr, data, extras)) { } else if(!parse_scheme_name(ptr, data, extras)) {
/* No Scheme was found, this means it could be: /* No scheme was found, this means it could be:
* a) an implicit Wildcard scheme * a) an implicit Wildcard scheme
* b) a relative URI * b) a relative URI
* c) a invalid URI. * c) an invalid URI.
*/ */
if(flags & Uri_CREATE_ALLOW_IMPLICIT_WILDCARD_SCHEME) { if(flags & Uri_CREATE_ALLOW_IMPLICIT_WILDCARD_SCHEME) {
data->scheme = wildcardW; data->scheme = wildcardW;
@ -1379,10 +1379,10 @@ static BOOL parse_password(const WCHAR **ptr, parse_data *data, DWORD flags, DWO
* ex: * ex:
* ftp://user:pass:word@winehq.org * ftp://user:pass:word@winehq.org
* *
* Would yield, "user" as the username and "pass:word" as the password. * would yield "user" as the username and "pass:word" as the password.
* *
* 2) Windows allows any character to appear in the "userinfo" part of * 2) Windows allows any character to appear in the "userinfo" part of
* a URI, as long as it's not an authority delimeter character set. * a URI, as long as it's not an authority delimiter character set.
*/ */
static void parse_userinfo(const WCHAR **ptr, parse_data *data, DWORD flags) { static void parse_userinfo(const WCHAR **ptr, parse_data *data, DWORD flags) {
const WCHAR *start = *ptr; const WCHAR *start = *ptr;
@ -1467,7 +1467,7 @@ static BOOL parse_port(const WCHAR **ptr, parse_data *data, DWORD flags) {
/* Attempts to parse a IPv4 address from the URI. /* Attempts to parse a IPv4 address from the URI.
* *
* NOTES: * NOTES:
* Window's normalizes IPv4 addresses, This means there's three * Windows normalizes IPv4 addresses, This means there are three
* possibilities for the URI to contain an IPv4 address. * possibilities for the URI to contain an IPv4 address.
* 1) A well formed address (ex. 192.2.2.2). * 1) A well formed address (ex. 192.2.2.2).
* 2) A partially formed address. For example "192.0" would * 2) A partially formed address. For example "192.0" would
@ -1504,7 +1504,7 @@ static BOOL parse_ipv4address(const WCHAR **ptr, parse_data *data, DWORD flags)
return FALSE; return FALSE;
} }
} else if(!is_auth_delim(**ptr, !is_unknown)) { } else if(!is_auth_delim(**ptr, !is_unknown)) {
/* Found more data which belongs the host, so this isn't an IPv4. */ /* Found more data which belongs to the host, so this isn't an IPv4. */
*ptr = data->host; *ptr = data->host;
data->host = NULL; data->host = NULL;
data->has_implicit_ip = FALSE; data->has_implicit_ip = FALSE;
@ -1535,8 +1535,8 @@ static BOOL parse_ipv4address(const WCHAR **ptr, parse_data *data, DWORD flags)
* Windows doesn't like host names which start with '[' and end with ']' * Windows doesn't like host names which start with '[' and end with ']'
* and don't contain a valid IP literal address in between them. * and don't contain a valid IP literal address in between them.
* *
* On Windows if an '[' is encountered in the host name the ':' no longer * On Windows if a '[' is encountered in the host name the ':' no longer
* counts as a delimiter until you reach the next ']' or an "authority delimeter". * counts as a delimiter until you reach the next ']' or an "authority delimiter".
* *
* A reg-name CAN be empty. * A reg-name CAN be empty.
*/ */
@ -1557,7 +1557,7 @@ static BOOL parse_reg_name(const WCHAR **ptr, parse_data *data, DWORD flags, DWO
* path can also have a '|' instead of a ':' after the drive letter. * path can also have a '|' instead of a ':' after the drive letter.
*/ */
if(is_drive_path(*ptr)) { if(is_drive_path(*ptr)) {
/* Regular old drive paths don't have a host type (or host name). */ /* Regular old drive paths have no host type (or host name). */
data->host_type = Uri_HOST_UNKNOWN; data->host_type = Uri_HOST_UNKNOWN;
data->host = *ptr; data->host = *ptr;
data->host_len = 0; data->host_len = 0;
@ -1589,7 +1589,7 @@ static BOOL parse_reg_name(const WCHAR **ptr, parse_data *data, DWORD flags, DWO
return FALSE; return FALSE;
} else } else
/* Windows gives up on trying to parse a port when it /* Windows gives up on trying to parse a port when it
* encounters 1 invalid port. * encounters an invalid port.
*/ */
ignore_col = TRUE; ignore_col = TRUE;
} else { } else {
@ -1781,7 +1781,7 @@ static BOOL parse_ipv6address(const WCHAR **ptr, parse_data *data, DWORD flags)
if(ip.elision_size == 2) { if(ip.elision_size == 2) {
/* For some reason on Windows if an elision that represents /* For some reason on Windows if an elision that represents
* only 1 h16 component is encountered at the very begin or * only one h16 component is encountered at the very begin or
* end of an IPv6 address, Windows does not consider it a * end of an IPv6 address, Windows does not consider it a
* valid IPv6 address. * valid IPv6 address.
* *
@ -2002,7 +2002,7 @@ static BOOL parse_path_hierarchical(const WCHAR **ptr, parse_data *data, DWORD f
return TRUE; return TRUE;
} }
/* Parses the path of a opaque URI (much less strict then the parser /* Parses the path of an opaque URI (much less strict then the parser
* for a hierarchical URI). * for a hierarchical URI).
* *
* NOTE: * NOTE:
@ -2044,7 +2044,7 @@ static BOOL parse_path_opaque(const WCHAR **ptr, parse_data *data, DWORD flags)
/* Determines how the URI should be parsed after the scheme information. /* Determines how the URI should be parsed after the scheme information.
* *
* If the scheme is followed, by "//" then, it is treated as an hierarchical URI * If the scheme is followed by "//", then it is treated as a hierarchical URI
* which then the authority and path information will be parsed out. Otherwise, the * which then the authority and path information will be parsed out. Otherwise, the
* URI will be treated as an opaque URI which the authority information is not parsed * URI will be treated as an opaque URI which the authority information is not parsed
* out. * out.
@ -2062,7 +2062,7 @@ static BOOL parse_path_opaque(const WCHAR **ptr, parse_data *data, DWORD flags)
* NOTES: * NOTES:
* If the URI is of an unknown scheme type and has a "//" following the scheme then it * If the URI is of an unknown scheme type and has a "//" following the scheme then it
* is treated as a hierarchical URI, but, if the CREATE_NO_CRACK_UNKNOWN_SCHEMES flag is * is treated as a hierarchical URI, but, if the CREATE_NO_CRACK_UNKNOWN_SCHEMES flag is
* set then it is considered an opaque URI reguardless of what follows the scheme information * set then it is considered an opaque URI regardless of what follows the scheme information
* (per MSDN documentation). * (per MSDN documentation).
*/ */
static BOOL parse_hierpart(const WCHAR **ptr, parse_data *data, DWORD flags) { static BOOL parse_hierpart(const WCHAR **ptr, parse_data *data, DWORD flags) {
@ -2093,7 +2093,7 @@ static BOOL parse_hierpart(const WCHAR **ptr, parse_data *data, DWORD flags) {
return parse_path_hierarchical(ptr, data, flags); return parse_path_hierarchical(ptr, data, flags);
} else } else
/* Reset ptr to it's starting position so opaque path parsing /* Reset ptr to its starting position so opaque path parsing
* begins at the correct location. * begins at the correct location.
*/ */
*ptr = start; *ptr = start;
@ -2116,8 +2116,8 @@ static BOOL parse_hierpart(const WCHAR **ptr, parse_data *data, DWORD flags) {
* *
* NOTES: * NOTES:
* If NO_DECODE_EXTRA_INFO flag is set, then invalid percent encoded * If NO_DECODE_EXTRA_INFO flag is set, then invalid percent encoded
* data is allowed appear in the query string. For unknown scheme types * data is allowed to appear in the query string. For unknown scheme types
* invalid percent encoded data is allowed to appear reguardless. * invalid percent encoded data is allowed to appear regardless.
*/ */
static BOOL parse_query(const WCHAR **ptr, parse_data *data, DWORD flags) { static BOOL parse_query(const WCHAR **ptr, parse_data *data, DWORD flags) {
const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN; const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN;
@ -2155,8 +2155,8 @@ static BOOL parse_query(const WCHAR **ptr, parse_data *data, DWORD flags) {
* *
* NOTES: * NOTES:
* If NO_DECODE_EXTRA_INFO flag is set, then invalid percent encoded * If NO_DECODE_EXTRA_INFO flag is set, then invalid percent encoded
* data is allowed appear in the query string. For unknown scheme types * data is allowed to appear in the query string. For unknown scheme types
* invalid percent encoded data is allowed to appear reguardless. * invalid percent encoded data is allowed to appear regardless.
*/ */
static BOOL parse_fragment(const WCHAR **ptr, parse_data *data, DWORD flags) { static BOOL parse_fragment(const WCHAR **ptr, parse_data *data, DWORD flags) {
const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN; const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN;
@ -2233,7 +2233,7 @@ static BOOL canonicalize_username(const parse_data *data, Uri *uri, DWORD flags,
if(*ptr == '%') { if(*ptr == '%') {
/* Only decode % encoded values for known scheme types. */ /* Only decode % encoded values for known scheme types. */
if(data->scheme_type != URL_SCHEME_UNKNOWN) { if(data->scheme_type != URL_SCHEME_UNKNOWN) {
/* See if the value really needs decoded. */ /* See if the value really needs decoding. */
WCHAR val = decode_pct_val(ptr); WCHAR val = decode_pct_val(ptr);
if(is_unreserved(val)) { if(is_unreserved(val)) {
if(!computeOnly) if(!computeOnly)
@ -2291,7 +2291,7 @@ static BOOL canonicalize_password(const parse_data *data, Uri *uri, DWORD flags,
if(*ptr == '%') { if(*ptr == '%') {
/* Only decode % encoded values for known scheme types. */ /* Only decode % encoded values for known scheme types. */
if(data->scheme_type != URL_SCHEME_UNKNOWN) { if(data->scheme_type != URL_SCHEME_UNKNOWN) {
/* See if the value really needs decoded. */ /* See if the value really needs decoding. */
WCHAR val = decode_pct_val(ptr); WCHAR val = decode_pct_val(ptr);
if(is_unreserved(val)) { if(is_unreserved(val)) {
if(!computeOnly) if(!computeOnly)
@ -2367,7 +2367,7 @@ static BOOL canonicalize_userinfo(const parse_data *data, Uri *uri, DWORD flags,
* Things that happen: * Things that happen:
* 1) If Uri_CREATE_NO_CANONICALIZE flag is not set, then the reg_name is * 1) If Uri_CREATE_NO_CANONICALIZE flag is not set, then the reg_name is
* lower cased. Unless it's an unknown scheme type, which case it's * lower cased. Unless it's an unknown scheme type, which case it's
* no lower cased reguardless. * no lower cased regardless.
* *
* 2) Unreserved % encoded characters are decoded for known * 2) Unreserved % encoded characters are decoded for known
* scheme types. * scheme types.
@ -2413,7 +2413,7 @@ static BOOL canonicalize_reg_name(const parse_data *data, Uri *uri,
if(*ptr == '%' && known_scheme) { if(*ptr == '%' && known_scheme) {
WCHAR val = decode_pct_val(ptr); WCHAR val = decode_pct_val(ptr);
if(is_unreserved(val)) { if(is_unreserved(val)) {
/* If NO_CANONICALZE is not set, then windows lower cases the /* If NO_CANONICALIZE is not set, then windows lower cases the
* decoded value. * decoded value.
*/ */
if(!(flags & Uri_CREATE_NO_CANONICALIZE) && isupperW(val)) { if(!(flags & Uri_CREATE_NO_CANONICALIZE) && isupperW(val)) {
@ -2483,8 +2483,8 @@ static BOOL canonicalize_implicit_ipv4address(const parse_data *data, Uri *uri,
uri->host_start = uri->canon_len; uri->host_start = uri->canon_len;
TRACE("%u\n", data->implicit_ipv4); TRACE("%u\n", data->implicit_ipv4);
/* For unknown scheme types Window's doesn't convert /* For unknown scheme types Windows doesn't convert
* the value into an IP address, but, it still considers * the value into an IP address, but it still considers
* it an IPv4 address. * it an IPv4 address.
*/ */
if(data->scheme_type == URL_SCHEME_UNKNOWN) { if(data->scheme_type == URL_SCHEME_UNKNOWN) {
@ -2515,7 +2515,7 @@ static BOOL canonicalize_implicit_ipv4address(const parse_data *data, Uri *uri,
* If the parse_data represents a URI that has an implicit IPv4 address * If the parse_data represents a URI that has an implicit IPv4 address
* (ex. http://256/, this function will convert 256 into 0.0.1.0). If * (ex. http://256/, this function will convert 256 into 0.0.1.0). If
* the implicit IP address exceeds the value of UINT_MAX (maximum value * the implicit IP address exceeds the value of UINT_MAX (maximum value
* for an IPv4 address) it's canonicalized as if were a reg-name. * for an IPv4 address) it's canonicalized as if it were a reg-name.
* *
* If the parse_data contains a partial or full IPv4 address it normalizes it. * If the parse_data contains a partial or full IPv4 address it normalizes it.
* A partial IPv4 address is something like "192.0" and would be normalized to * A partial IPv4 address is something like "192.0" and would be normalized to
@ -2523,7 +2523,7 @@ static BOOL canonicalize_implicit_ipv4address(const parse_data *data, Uri *uri,
* be normalized to "192.2.1.3". * be normalized to "192.2.1.3".
* *
* NOTES: * NOTES:
* Window's ONLY normalizes IPv4 address for known scheme types (one that isn't * Windows ONLY normalizes IPv4 address for known scheme types (one that isn't
* URL_SCHEME_UNKNOWN). For unknown scheme types, it simply copies the data from * URL_SCHEME_UNKNOWN). For unknown scheme types, it simply copies the data from
* the original URI into the canonicalized URI, but, it still recognizes URI's * the original URI into the canonicalized URI, but, it still recognizes URI's
* host type as HOST_IPV4. * host type as HOST_IPV4.
@ -2605,11 +2605,11 @@ static BOOL canonicalize_ipv4address(const parse_data *data, Uri *uri, DWORD fla
/* Attempts to canonicalize the IPv6 address of the URI. /* Attempts to canonicalize the IPv6 address of the URI.
* *
* Multiple things happen during the canonicalization of an IPv6 address: * Multiple things happen during the canonicalization of an IPv6 address:
* 1) Any leading zero's in an h16 component are removed. * 1) Any leading zero's in a h16 component are removed.
* Ex: [0001:0022::] -> [1:22::] * Ex: [0001:0022::] -> [1:22::]
* *
* 2) The longest sequence of zero h16 components are compressed * 2) The longest sequence of zero h16 components are compressed
* into a "::" (elision). If there's a tie, the first is choosen. * into a "::" (elision). If there's a tie, the first is chosen.
* *
* Ex: [0:0:0:0:1:6:7:8] -> [::1:6:7:8] * Ex: [0:0:0:0:1:6:7:8] -> [::1:6:7:8]
* [0:0:0:0:1:2::] -> [::1:2:0:0] * [0:0:0:0:1:2::] -> [::1:2:0:0]
@ -2619,7 +2619,7 @@ static BOOL canonicalize_ipv4address(const parse_data *data, Uri *uri, DWORD fla
* also normalized. * also normalized.
* Ex: [::001.002.022.000] -> [::1.2.22.0] * Ex: [::001.002.022.000] -> [::1.2.22.0]
* *
* 4) If an elision is present, but, only represents 1 h16 component * 4) If an elision is present, but, only represents one h16 component
* it's expanded. * it's expanded.
* *
* Ex: [1::2:3:4:5:6:7] -> [1:0:2:3:4:5:6:7] * Ex: [1::2:3:4:5:6:7] -> [1:0:2:3:4:5:6:7]
@ -2895,7 +2895,7 @@ static BOOL canonicalize_authority(const parse_data *data, Uri *uri, DWORD flags
* Things that happen: * Things that happen:
* 1). Forbidden characters are percent encoded, unless the NO_ENCODE_FORBIDDEN * 1). Forbidden characters are percent encoded, unless the NO_ENCODE_FORBIDDEN
* flag is set or it's a file URI. Forbidden characters are always encoded * flag is set or it's a file URI. Forbidden characters are always encoded
* for file schemes reguardless and forbidden characters are never encoded * for file schemes regardless and forbidden characters are never encoded
* for unknown scheme types. * for unknown scheme types.
* *
* 2). For known scheme types '\\' are changed to '/'. * 2). For known scheme types '\\' are changed to '/'.
@ -2957,7 +2957,7 @@ static BOOL canonicalize_path_hierarchical(const parse_data *data, Uri *uri,
if(is_drive_path(ptr)) { if(is_drive_path(ptr)) {
if(!computeOnly) { if(!computeOnly) {
uri->canon_uri[uri->canon_len] = *ptr; uri->canon_uri[uri->canon_len] = *ptr;
/* If theres a '|' after the drive letter, convert it to a ':'. */ /* If there's a '|' after the drive letter, convert it to a ':'. */
uri->canon_uri[uri->canon_len+1] = ':'; uri->canon_uri[uri->canon_len+1] = ':';
} }
ptr += 2; ptr += 2;
@ -2979,7 +2979,7 @@ static BOOL canonicalize_path_hierarchical(const parse_data *data, Uri *uri,
const WCHAR *tmp = ptr; const WCHAR *tmp = ptr;
WCHAR val; WCHAR val;
/* Check if the % represents a valid encoded char, or if it needs encoded. */ /* Check if the % represents a valid encoded char, or if it needs encoding. */
BOOL force_encode = !check_pct_encoded(&tmp) && is_file && !(flags&Uri_CREATE_FILE_USE_DOS_PATH); BOOL force_encode = !check_pct_encoded(&tmp) && is_file && !(flags&Uri_CREATE_FILE_USE_DOS_PATH);
val = decode_pct_val(ptr); val = decode_pct_val(ptr);
@ -3395,7 +3395,7 @@ static BOOL canonicalize_scheme(const parse_data *data, Uri *uri, DWORD flags, B
return TRUE; return TRUE;
} }
/* Compute's what the length of the URI specified by the parse_data will be /* Computes what the length of the URI specified by the parse_data will be
* after canonicalization occurs using the specified flags. * after canonicalization occurs using the specified flags.
* *
* This function will return a non-zero value indicating the length of the canonicalized * This function will return a non-zero value indicating the length of the canonicalized
@ -3435,11 +3435,11 @@ static int compute_canonicalized_length(const parse_data *data, DWORD flags) {
} }
/* Canonicalizes the URI data specified in the parse_data, using the given flags. If the /* Canonicalizes the URI data specified in the parse_data, using the given flags. If the
* canonicalization succeededs it will store all the canonicalization information * canonicalization succeeds it will store all the canonicalization information
* in the pointer to the Uri. * in the pointer to the Uri.
* *
* To canonicalize a URI this function first computes what the length of the URI * To canonicalize a URI this function first computes what the length of the URI
* specified by the parse_data will be. Once this is done it will then perfom the actual * specified by the parse_data will be. Once this is done it will then perform the actual
* canonicalization of the URI. * canonicalization of the URI.
*/ */
static HRESULT canonicalize_uri(const parse_data *data, Uri *uri, DWORD flags) { static HRESULT canonicalize_uri(const parse_data *data, Uri *uri, DWORD flags) {
@ -3491,7 +3491,7 @@ static HRESULT canonicalize_uri(const parse_data *data, Uri *uri, DWORD flags) {
*/ */
if(uri->canon_len < uri->canon_size) { if(uri->canon_len < uri->canon_size) {
/* This happens if the URI is hierarchical and dot /* This happens if the URI is hierarchical and dot
* segments were removed from it's path. * segments were removed from its path.
*/ */
WCHAR *tmp = heap_realloc(uri->canon_uri, (uri->canon_len+1)*sizeof(WCHAR)); WCHAR *tmp = heap_realloc(uri->canon_uri, (uri->canon_len+1)*sizeof(WCHAR));
if(!tmp) if(!tmp)
@ -5090,8 +5090,8 @@ static Uri* create_uri_obj(void) {
* *
* RETURNS * RETURNS
* Success: Returns S_OK. ppURI contains the pointer to the newly allocated IUri. * Success: Returns S_OK. ppURI contains the pointer to the newly allocated IUri.
* Failure: E_INVALIDARG if there's invalid flag combinations in dwFlags, or an * Failure: E_INVALIDARG if there are invalid flag combinations in dwFlags, or an
* invalid parameters, or pwzURI doesn't represnt a valid URI. * invalid parameter, or pwzURI doesn't represent a valid URI.
* E_OUTOFMEMORY if any memory allocation fails. * E_OUTOFMEMORY if any memory allocation fails.
* *
* NOTES * NOTES
@ -5183,7 +5183,7 @@ HRESULT WINAPI CreateUri(LPCWSTR pwzURI, DWORD dwFlags, DWORD_PTR dwReserved, IU
* *
* PARAMS * PARAMS
* pwzURI [I] The URI to parse and perform canonicalization on. * pwzURI [I] The URI to parse and perform canonicalization on.
* pwzFragment [I] The explict fragment string which should be added to pwzURI. * pwzFragment [I] The explicit fragment string which should be added to pwzURI.
* dwFlags [I] The flags which will be passed to CreateUri. * dwFlags [I] The flags which will be passed to CreateUri.
* dwReserved [I] Reserved (not used). * dwReserved [I] Reserved (not used).
* ppURI [O] The resulting IUri after parsing/canonicalization. * ppURI [O] The resulting IUri after parsing/canonicalization.
@ -5192,7 +5192,7 @@ HRESULT WINAPI CreateUri(LPCWSTR pwzURI, DWORD dwFlags, DWORD_PTR dwReserved, IU
* Success: S_OK. ppURI contains the pointer to the newly allocated IUri. * Success: S_OK. ppURI contains the pointer to the newly allocated IUri.
* Failure: E_INVALIDARG if pwzURI already contains a fragment and pwzFragment * Failure: E_INVALIDARG if pwzURI already contains a fragment and pwzFragment
* isn't NULL. Will also return E_INVALIDARG for the same reasons as * isn't NULL. Will also return E_INVALIDARG for the same reasons as
* CreateUri will. E_OUTOFMEMORY if any allocations fail. * CreateUri will. E_OUTOFMEMORY if any allocation fails.
*/ */
HRESULT WINAPI CreateUriWithFragment(LPCWSTR pwzURI, LPCWSTR pwzFragment, DWORD dwFlags, HRESULT WINAPI CreateUriWithFragment(LPCWSTR pwzURI, LPCWSTR pwzFragment, DWORD dwFlags,
DWORD_PTR dwReserved, IUri **ppURI) DWORD_PTR dwReserved, IUri **ppURI)
@ -5803,7 +5803,7 @@ static HRESULT merge_paths(parse_data *data, const WCHAR *base, DWORD base_len,
WCHAR *ptr; WCHAR *ptr;
if(base_len) { if(base_len) {
/* Find the characters the will be copied over from /* Find the characters that will be copied over from
* the base path. * the base path.
*/ */
end = memrchrW(base, '/', base_len); end = memrchrW(base, '/', base_len);
@ -6298,7 +6298,7 @@ static HRESULT parse_canonicalize(const Uri *uri, DWORD flags, LPWSTR output,
buffer[len++] = 0; buffer[len++] = 0;
/* The null terminator isn't included the length. */ /* The null terminator isn't included in the length. */
*result_len = len-1; *result_len = len-1;
if(len > output_len) if(len > output_len)
return STRSAFE_E_INSUFFICIENT_BUFFER; return STRSAFE_E_INSUFFICIENT_BUFFER;