Ignore:
Timestamp:
Sep 5, 2001, 3:54:53 PM (24 years ago)
Author:
bird
Message:

Added $Id:$ keyword.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/shlwapi/url.c

    r6608 r6650  
     1/* $Id: url.c,v 1.4 2001-09-05 13:48:39 bird Exp $ */
    12/*
    23 * Url functions
    … …  
    5354    if(dwFlags & URL_ESCAPE_SPACES_ONLY) {
    5455        if(ch == ' ')
    55             return TRUE;
    56         else
    57             return FALSE;
     56        return TRUE;
     57    else
     58        return FALSE;
    5859    }
    5960
    6061    if (ch <= 31 || ch >= 127)
    61         return TRUE;
     62    return TRUE;
    6263
    6364    else {
    6465        switch (ch) {
    65         case ' ':
    66         case '<':
    67         case '>':
    68         case '\"':
    69         case '{':
    70         case '}':
    71         case '|':
    72         case '\\':
    73         case '^':
    74         case ']':
    75         case '[':
    76         case '`':
    77         case '&':
    78             return TRUE;
    79 
    80         default:
    81             return FALSE;
    82         }
     66    case ' ':
     67    case '<':
     68    case '>':
     69    case '\"':
     70    case '{':
     71    case '}':
     72    case '|':
     73    case '\\':
     74    case '^':
     75    case ']':
     76    case '[':
     77    case '`':
     78    case '&':
     79        return TRUE;
     80
     81    default:
     82        return FALSE;
     83    }
    8384    }
    8485}
    … …  
    8889 */
    8990HRESULT WINAPI UrlCanonicalizeA(LPCSTR pszUrl, LPSTR pszCanonicalized,
    90         LPDWORD pcchCanonicalized, DWORD dwFlags)
     91    LPDWORD pcchCanonicalized, DWORD dwFlags)
    9192{
    9293    HRESULT hr = S_OK;
    … …  
    9697
    9798    TRACE("(%s %p %p 0x%08lx)\n", debugstr_a(pszUrl), pszCanonicalized,
    98           pcchCanonicalized, dwFlags);
     99      pcchCanonicalized, dwFlags);
    99100
    100101    nLen = strlen(pszUrl);
    … …  
    113114    if(dwFlags & (URL_ESCAPE_UNSAFE | URL_ESCAPE_SPACES_ONLY)) {
    114115        DWORD EscapeFlags = dwFlags & (URL_ESCAPE_SPACES_ONLY
    115                                        /* | URL_ESCAPE_PERCENT */);
    116         hr = UrlEscapeA(lpszUrlCpy, pszCanonicalized, pcchCanonicalized,
    117                         EscapeFlags);
     116                       /* | URL_ESCAPE_PERCENT */);
     117    hr = UrlEscapeA(lpszUrlCpy, pszCanonicalized, pcchCanonicalized,
     118            EscapeFlags);
    118119    } else { /* No escapping needed, just copy the string */
    119120        nLen = strlen(lpszUrlCpy);
    120         if(nLen < *pcchCanonicalized)
    121             memcpy(pszCanonicalized, lpszUrlCpy, nLen + 1);
    122         else {
    123             hr = E_POINTER;
    124             nLen++;
    125         }
    126         *pcchCanonicalized = nLen;
     121    if(nLen < *pcchCanonicalized)
     122        memcpy(pszCanonicalized, lpszUrlCpy, nLen + 1);
     123    else {
     124        hr = E_POINTER;
     125        nLen++;
     126    }
     127    *pcchCanonicalized = nLen;
    127128    }
    128129
    129130    HeapFree(GetProcessHeap(), 0, lpszUrlCpy);
    130  
     131
    131132    return hr;
    132133}
    … …  
    135136 *        UrlCanonicalizeW     [SHLWAPI]
    136137 */
    137 HRESULT WINAPI UrlCanonicalizeW(LPCWSTR pszUrl, LPWSTR pszCanonicalized, 
    138                                 LPDWORD pcchCanonicalized, DWORD dwFlags)
     138HRESULT WINAPI UrlCanonicalizeW(LPCWSTR pszUrl, LPWSTR pszCanonicalized,
     139                LPDWORD pcchCanonicalized, DWORD dwFlags)
    139140{
    140141    FIXME("(%s %p %p 0x%08lx): stub\n",debugstr_w(pszUrl),
    141           pszCanonicalized, pcchCanonicalized, dwFlags);
     142      pszCanonicalized, pcchCanonicalized, dwFlags);
    142143    return E_NOTIMPL;
    143144}
    144145
    145146/*************************************************************************
    146  *      UrlEscapeA      [SHLWAPI]
     147 *      UrlEscapeA  [SHLWAPI]
    147148 *
    148149 * Converts unsafe characters into their escape sequences.
    … …  
    172173 */
    173174HRESULT WINAPI UrlEscapeA(
    174         LPCSTR pszUrl,
    175         LPSTR pszEscaped,
    176         LPDWORD pcchEscaped,
    177         DWORD dwFlags)
     175    LPCSTR pszUrl,
     176    LPSTR pszEscaped,
     177    LPDWORD pcchEscaped,
     178    DWORD dwFlags)
    178179{
    179180    LPCSTR src;
    … …  
    185186
    186187    TRACE("(%s %p %p 0x%08lx)\n", debugstr_a(pszUrl), pszEscaped,
    187           pcchEscaped, dwFlags);
     188      pcchEscaped, dwFlags);
    188189
    189190    if(dwFlags & ~URL_ESCAPE_SPACES_ONLY)
    … …  
    192193    for(src = pszUrl; *src; src++) {
    193194        if(!(dwFlags & URL_ESCAPE_SPACES_ONLY) &&
    194            (*src == '#' || *src == '?'))
    195             stop_escapping = TRUE;
    196 
    197         if(URL_NeedEscape(*src, dwFlags) && stop_escapping == FALSE) {
    198             next[0] = '%';
    199             next[1] = hex[(*src >> 4) & 0xf];
    200             next[2] = hex[*src & 0xf];
    201             len = 3;
    202         } else {
    203             next[0] = *src;
    204             len = 1;
    205         }
    206 
    207         if(needed + len <= *pcchEscaped) {
    208             memcpy(dst, next, len);
    209             dst += len;
    210         }
    211         needed += len;
     195       (*src == '#' || *src == '?'))
     196        stop_escapping = TRUE;
     197
     198    if(URL_NeedEscape(*src, dwFlags) && stop_escapping == FALSE) {
     199        next[0] = '%';
     200        next[1] = hex[(*src >> 4) & 0xf];
     201        next[2] = hex[*src & 0xf];
     202        len = 3;
     203    } else {
     204        next[0] = *src;
     205        len = 1;
     206    }
     207
     208    if(needed + len <= *pcchEscaped) {
     209        memcpy(dst, next, len);
     210        dst += len;
     211    }
     212    needed += len;
    212213    }
    213214
    214215    if(needed < *pcchEscaped) {
    215216        *dst = '\0';
    216         ret = S_OK;
     217    ret = S_OK;
    217218    } else {
    218219        needed++; /* add one for the '\0' */
    219         ret = E_POINTER;
     220    ret = E_POINTER;
    220221    }
    221222    *pcchEscaped = needed;
    222223    return ret;
    223 }       
    224 
    225 /*************************************************************************
    226  *      UrlEscapeW      [SHLWAPI]
     224}
     225
     226/*************************************************************************
     227 *      UrlEscapeW  [SHLWAPI]
    227228 */
    228229HRESULT WINAPI UrlEscapeW(
    229         LPCWSTR pszUrl,
    230         LPWSTR pszEscaped,
    231         LPDWORD pcchEscaped,
    232         DWORD dwFlags)
     230    LPCWSTR pszUrl,
     231    LPWSTR pszEscaped,
     232    LPDWORD pcchEscaped,
     233    DWORD dwFlags)
    233234{
    234235    FIXME("(%s %p %p 0x%08lx): stub\n",debugstr_w(pszUrl),
    235           pszEscaped, pcchEscaped, dwFlags);
     236      pszEscaped, pcchEscaped, dwFlags);
    236237    return E_NOTIMPL;
    237238}
    … …  
    239240
    240241/*************************************************************************
    241  *      UrlUnescapeA    [SHLWAPI]
     242 *      UrlUnescapeA    [SHLWAPI]
    242243 *
    243244 * Converts escape sequences back to ordinary characters.
    244  * 
     245 *
    245246 * If URL_ESCAPE_INPLACE is set in dwFlags then pszUnescaped and
    246247 * pcchUnescaped are ignored and the converted string is returned in
    … …  
    256257 */
    257258HRESULT WINAPI UrlUnescapeA(
    258         LPCSTR pszUrl,
    259         LPSTR pszUnescaped,
    260         LPDWORD pcchUnescaped,
    261         DWORD dwFlags)
     259    LPCSTR pszUrl,
     260    LPSTR pszUnescaped,
     261    LPDWORD pcchUnescaped,
     262    DWORD dwFlags)
    262263{
    263264    char *dst, next;
    … …  
    268269
    269270    TRACE("(%s, %p, %p, %08lx): stub\n", debugstr_a(pszUrl), pszUnescaped,
    270           pcchUnescaped, dwFlags);
     271      pcchUnescaped, dwFlags);
    271272
    272273    if(dwFlags & URL_UNESCAPE_INPLACE)
    … …  
    277278    for(src = pszUrl, needed = 0; *src; src++, needed++) {
    278279        if(dwFlags & URL_DONT_UNESCAPE_EXTRA_INFO &&
    279            (*src == '#' || *src == '?')) {
    280             stop_unescapping = TRUE;
    281             next = *src;
    282         } else if(*src == '%' && isxdigit(*(src + 1)) && isxdigit(*(src + 2))
    283                   && stop_unescapping == FALSE) {
    284             INT ih;
    285             char buf[3];
    286             memcpy(buf, src + 1, 2);
    287             buf[2] = '\0';
    288             ih = strtol(buf, NULL, 16);
    289             next = (CHAR) ih;
    290             src += 2; /* Advance to end of escape */
    291         } else
    292             next = *src;
    293 
    294         if(dwFlags & URL_UNESCAPE_INPLACE || needed < *pcchUnescaped)
    295             *dst++ = next;
     280       (*src == '#' || *src == '?')) {
     281        stop_unescapping = TRUE;
     282        next = *src;
     283    } else if(*src == '%' && isxdigit(*(src + 1)) && isxdigit(*(src + 2))
     284          && stop_unescapping == FALSE) {
     285        INT ih;
     286        char buf[3];
     287        memcpy(buf, src + 1, 2);
     288        buf[2] = '\0';
     289        ih = strtol(buf, NULL, 16);
     290        next = (CHAR) ih;
     291        src += 2; /* Advance to end of escape */
     292    } else
     293        next = *src;
     294
     295    if(dwFlags & URL_UNESCAPE_INPLACE || needed < *pcchUnescaped)
     296        *dst++ = next;
    296297    }
    297298
    298299    if(dwFlags & URL_UNESCAPE_INPLACE || needed < *pcchUnescaped) {
    299300        *dst = '\0';
    300         ret = S_OK;
     301    ret = S_OK;
    301302    } else {
    302303        needed++; /* add one for the '\0' */
    303         ret = E_POINTER;
     304    ret = E_POINTER;
    304305    }
    305306    if(!(dwFlags & URL_UNESCAPE_INPLACE))
    … …  
    310311
    311312/*************************************************************************
    312  *      UrlUnescapeW    [SHLWAPI]
     313 *      UrlUnescapeW    [SHLWAPI]
    313314 */
    314315HRESULT WINAPI UrlUnescapeW(
    315         LPCWSTR pszUrl,
    316         LPWSTR pszUnescaped,
    317         LPDWORD pcchUnescaped,
    318         DWORD dwFlags)
     316    LPCWSTR pszUrl,
     317    LPWSTR pszUnescaped,
     318    LPDWORD pcchUnescaped,
     319    DWORD dwFlags)
    319320{
    320321    FIXME("(%s, %p, %p, %08lx): stub\n", debugstr_w(pszUrl), pszUnescaped,
    321           pcchUnescaped, dwFlags);
     322      pcchUnescaped, dwFlags);
    322323    return E_NOTIMPL;
    323324}
    324325
    325326/*************************************************************************
    326  *      HashData        [SHLWAPI]
     327 *      HashData    [SHLWAPI]
    327328 *
    328329 * Hash an input block into a variable sized digest.
    … …  
    357358
    358359/*************************************************************************
    359  *      UrlHashA        [SHLWAPI]
     360 *      UrlHashA    [SHLWAPI]
    360361 *
    361362 * Hash an ASCII URL.
    … …  
    371372
    372373/*************************************************************************
    373  *      UrlApplySchemeW [SHLWAPI.@]
     374 *      UrlApplySchemeW [SHLWAPI.@]
    374375 */
    375376HRESULT WINAPI UrlApplySchemeW(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut, DWORD dwFlags)
Note: See TracChangeset for help on using the changeset viewer.