From d1e15baca7133e3b672443f3b2ff7b209d939f0e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20Delanoy?= Date: Sat, 23 Jul 2011 09:14:25 +0200 Subject: [PATCH] urlmon: Fix various typos/misspellings. --- dlls/urlmon/uri.c | 120 +++++++++++++++++++++++----------------------- 1 file changed, 60 insertions(+), 60 deletions(-) diff --git a/dlls/urlmon/uri.c b/dlls/urlmon/uri.c index 4586f9d0af1..9928070f548 100644 --- a/dlls/urlmon/uri.c +++ b/dlls/urlmon/uri.c @@ -233,7 +233,7 @@ static const struct { {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. */ 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 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) { 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 * section of a URI. Sometimes a '\\' is considered - * an authority delimeter. + * an authority delimiter. */ static inline BOOL is_auth_delim(WCHAR val, BOOL acceptSlash) { 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 * 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. * B.) It's an implicit file scheme. * 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. - * Each h16 component is 16bits, if there is an IPv4 address, it's - * 32bits. If there's an elision it can be 16bits to 128bits, depending + * Each h16 component is 16 bits. If there is an IPv4 address, it's + * 32 bits. If there's an elision it can be 16 to 128 bits, depending * on the number of other components. * * Modeled after google-url's CheckIPv6ComponentsSize function @@ -541,7 +541,7 @@ static void compute_ipv6_comps_size(ipv6_address *address) { if(address->elision) { /* 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; 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 * this function returns the NULL character. * - * Eg. + * E.g. * "%2E" will result in '.' being returned by this function. */ 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; /* 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) return; @@ -640,7 +640,7 @@ void find_domain_name(const WCHAR *host, DWORD host_len, } else if(last_tld-host == 3) { 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 * host doesn't have a domain (since the host only contains * 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 * address using the numerical values of each component stored in * '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' * will contain the number of cells the elision covers. * * 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. * * 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; } -/* 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 * to 'dest'. If 'dest' is NULL this function will return the number of * characters that would have been written. @@ -956,7 +956,7 @@ static DWORD ui2str(WCHAR *dest, UINT value) { 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. * * This function assumes that the h16 component has already been validated. @@ -1063,7 +1063,7 @@ static BOOL check_dec_octet(const WCHAR **ptr) { ++(*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 * 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); } 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... */ 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; } } 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 * b) a relative URI - * c) a invalid URI. + * c) an invalid URI. */ if(flags & Uri_CREATE_ALLOW_IMPLICIT_WILDCARD_SCHEME) { data->scheme = wildcardW; @@ -1379,10 +1379,10 @@ static BOOL parse_password(const WCHAR **ptr, parse_data *data, DWORD flags, DWO * ex: * 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 - * 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) { 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. * * 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. * 1) A well formed address (ex. 192.2.2.2). * 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; } } 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; data->host = NULL; 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 ']' * 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 - * counts as a delimiter until you reach the next ']' or an "authority delimeter". + * 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 delimiter". * * 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. */ 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 = *ptr; data->host_len = 0; @@ -1589,7 +1589,7 @@ static BOOL parse_reg_name(const WCHAR **ptr, parse_data *data, DWORD flags, DWO return FALSE; } else /* Windows gives up on trying to parse a port when it - * encounters 1 invalid port. + * encounters an invalid port. */ ignore_col = TRUE; } else { @@ -1781,7 +1781,7 @@ static BOOL parse_ipv6address(const WCHAR **ptr, parse_data *data, DWORD flags) if(ip.elision_size == 2) { /* 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 * valid IPv6 address. * @@ -2002,7 +2002,7 @@ static BOOL parse_path_hierarchical(const WCHAR **ptr, parse_data *data, DWORD f 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). * * 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. * - * 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 * URI will be treated as an opaque URI which the authority information is not parsed * out. @@ -2062,7 +2062,7 @@ static BOOL parse_path_opaque(const WCHAR **ptr, parse_data *data, DWORD flags) * NOTES: * 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 - * 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). */ 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); } 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. */ *ptr = start; @@ -2116,8 +2116,8 @@ static BOOL parse_hierpart(const WCHAR **ptr, parse_data *data, DWORD flags) { * * NOTES: * If NO_DECODE_EXTRA_INFO flag is set, then invalid percent encoded - * data is allowed appear in the query string. For unknown scheme types - * invalid percent encoded data is allowed to appear reguardless. + * data is allowed to appear in the query string. For unknown scheme types + * invalid percent encoded data is allowed to appear regardless. */ static BOOL parse_query(const WCHAR **ptr, parse_data *data, DWORD flags) { 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: * If NO_DECODE_EXTRA_INFO flag is set, then invalid percent encoded - * data is allowed appear in the query string. For unknown scheme types - * invalid percent encoded data is allowed to appear reguardless. + * data is allowed to appear in the query string. For unknown scheme types + * invalid percent encoded data is allowed to appear regardless. */ static BOOL parse_fragment(const WCHAR **ptr, parse_data *data, DWORD flags) { 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 == '%') { /* Only decode % encoded values for known scheme types. */ 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); if(is_unreserved(val)) { if(!computeOnly) @@ -2291,7 +2291,7 @@ static BOOL canonicalize_password(const parse_data *data, Uri *uri, DWORD flags, if(*ptr == '%') { /* Only decode % encoded values for known scheme types. */ 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); if(is_unreserved(val)) { if(!computeOnly) @@ -2367,7 +2367,7 @@ static BOOL canonicalize_userinfo(const parse_data *data, Uri *uri, DWORD flags, * Things that happen: * 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 - * no lower cased reguardless. + * no lower cased regardless. * * 2) Unreserved % encoded characters are decoded for known * scheme types. @@ -2413,7 +2413,7 @@ static BOOL canonicalize_reg_name(const parse_data *data, Uri *uri, if(*ptr == '%' && known_scheme) { WCHAR val = decode_pct_val(ptr); 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. */ 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; TRACE("%u\n", data->implicit_ipv4); - /* For unknown scheme types Window's doesn't convert - * the value into an IP address, but, it still considers + /* For unknown scheme types Windows doesn't convert + * the value into an IP address, but it still considers * it an IPv4 address. */ 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 * (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 - * 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. * 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". * * 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 * the original URI into the canonicalized URI, but, it still recognizes URI's * 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. * * 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::] * * 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] * [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. * 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. * * 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: * 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 - * for file schemes reguardless and forbidden characters are never encoded + * for file schemes regardless and forbidden characters are never encoded * for unknown scheme types. * * 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(!computeOnly) { 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] = ':'; } ptr += 2; @@ -2979,7 +2979,7 @@ static BOOL canonicalize_path_hierarchical(const parse_data *data, Uri *uri, const WCHAR *tmp = ptr; 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); val = decode_pct_val(ptr); @@ -3088,7 +3088,7 @@ static BOOL canonicalize_path_opaque(const parse_data *data, Uri *uri, DWORD fla uri->path_start = uri->canon_len; - /* For javascript: URIs, simply copy path part withoutany canonicalization */ + /* For javascript: URIs, simply copy path part without any canonicalization */ if(data->scheme_type == URL_SCHEME_JAVASCRIPT) { if(!computeOnly) memcpy(uri->canon_uri+uri->canon_len, data->path, data->path_len*sizeof(WCHAR)); @@ -3395,7 +3395,7 @@ static BOOL canonicalize_scheme(const parse_data *data, Uri *uri, DWORD flags, B 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. * * 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 - * canonicalization succeededs it will store all the canonicalization information + * canonicalization succeeds it will store all the canonicalization information * in the pointer to 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. */ 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) { /* 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)); if(!tmp) @@ -5090,8 +5090,8 @@ static Uri* create_uri_obj(void) { * * RETURNS * 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 - * invalid parameters, or pwzURI doesn't represnt a valid URI. + * Failure: E_INVALIDARG if there are invalid flag combinations in dwFlags, or an + * invalid parameter, or pwzURI doesn't represent a valid URI. * E_OUTOFMEMORY if any memory allocation fails. * * NOTES @@ -5183,7 +5183,7 @@ HRESULT WINAPI CreateUri(LPCWSTR pwzURI, DWORD dwFlags, DWORD_PTR dwReserved, IU * * PARAMS * 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. * dwReserved [I] Reserved (not used). * 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. * Failure: E_INVALIDARG if pwzURI already contains a fragment and pwzFragment * 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, DWORD_PTR dwReserved, IUri **ppURI) @@ -5803,7 +5803,7 @@ static HRESULT merge_paths(parse_data *data, const WCHAR *base, DWORD base_len, WCHAR *ptr; if(base_len) { - /* Find the characters the will be copied over from + /* Find the characters that will be copied over from * the base path. */ end = memrchrW(base, '/', base_len); @@ -6298,7 +6298,7 @@ static HRESULT parse_canonicalize(const Uri *uri, DWORD flags, LPWSTR output, buffer[len++] = 0; - /* The null terminator isn't included the length. */ + /* The null terminator isn't included in the length. */ *result_len = len-1; if(len > output_len) return STRSAFE_E_INSUFFICIENT_BUFFER;