Ignore:
Timestamp:
Sep 15, 2001, 11:47:44 AM (24 years ago)
Author:
sandervl
Message:

restored old version

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/shlwapi/url.c

    r6650 r6712  
    1 /* $Id: url.c,v 1.4 2001-09-05 13:48:39 bird Exp $ */
    21/*
    32 * Url functions
    … …  
    5453    if(dwFlags & URL_ESCAPE_SPACES_ONLY) {
    5554        if(ch == ' ')
    56         return TRUE;
    57     else
    58         return FALSE;
     55            return TRUE;
     56        else
     57            return FALSE;
    5958    }
    6059
    6160    if (ch <= 31 || ch >= 127)
    62     return TRUE;
     61        return TRUE;
    6362
    6463    else {
    6564        switch (ch) {
    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     }
     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        }
    8483    }
    8584}
    … …  
    8988 */
    9089HRESULT WINAPI UrlCanonicalizeA(LPCSTR pszUrl, LPSTR pszCanonicalized,
    91     LPDWORD pcchCanonicalized, DWORD dwFlags)
     90        LPDWORD pcchCanonicalized, DWORD dwFlags)
    9291{
    9392    HRESULT hr = S_OK;
    … …  
    9796
    9897    TRACE("(%s %p %p 0x%08lx)\n", debugstr_a(pszUrl), pszCanonicalized,
    99       pcchCanonicalized, dwFlags);
     98          pcchCanonicalized, dwFlags);
    10099
    101100    nLen = strlen(pszUrl);
    … …  
    114113    if(dwFlags & (URL_ESCAPE_UNSAFE | URL_ESCAPE_SPACES_ONLY)) {
    115114        DWORD EscapeFlags = dwFlags & (URL_ESCAPE_SPACES_ONLY
    116                        /* | URL_ESCAPE_PERCENT */);
    117     hr = UrlEscapeA(lpszUrlCpy, pszCanonicalized, pcchCanonicalized,
    118             EscapeFlags);
     115                                       /* | URL_ESCAPE_PERCENT */);
     116        hr = UrlEscapeA(lpszUrlCpy, pszCanonicalized, pcchCanonicalized,
     117                        EscapeFlags);
    119118    } else { /* No escapping needed, just copy the string */
    120119        nLen = strlen(lpszUrlCpy);
    121     if(nLen < *pcchCanonicalized)
    122         memcpy(pszCanonicalized, lpszUrlCpy, nLen + 1);
    123     else {
    124         hr = E_POINTER;
    125         nLen++;
    126     }
    127     *pcchCanonicalized = nLen;
     120        if(nLen < *pcchCanonicalized)
     121            memcpy(pszCanonicalized, lpszUrlCpy, nLen + 1);
     122        else {
     123            hr = E_POINTER;
     124            nLen++;
     125        }
     126        *pcchCanonicalized = nLen;
    128127    }
    129128
    130129    HeapFree(GetProcessHeap(), 0, lpszUrlCpy);
    131 
     130 
    132131    return hr;
    133132}
    … …  
    136135 *        UrlCanonicalizeW     [SHLWAPI]
    137136 */
    138 HRESULT WINAPI UrlCanonicalizeW(LPCWSTR pszUrl, LPWSTR pszCanonicalized,
    139                 LPDWORD pcchCanonicalized, DWORD dwFlags)
     137HRESULT WINAPI UrlCanonicalizeW(LPCWSTR pszUrl, LPWSTR pszCanonicalized, 
     138                                LPDWORD pcchCanonicalized, DWORD dwFlags)
    140139{
    141140    FIXME("(%s %p %p 0x%08lx): stub\n",debugstr_w(pszUrl),
    142       pszCanonicalized, pcchCanonicalized, dwFlags);
     141          pszCanonicalized, pcchCanonicalized, dwFlags);
    143142    return E_NOTIMPL;
    144143}
    145144
    146145/*************************************************************************
    147  *      UrlEscapeA  [SHLWAPI]
     146 *      UrlEscapeA      [SHLWAPI]
    148147 *
    149148 * Converts unsafe characters into their escape sequences.
    … …  
    173172 */
    174173HRESULT WINAPI UrlEscapeA(
    175     LPCSTR pszUrl,
    176     LPSTR pszEscaped,
    177     LPDWORD pcchEscaped,
    178     DWORD dwFlags)
     174        LPCSTR pszUrl,
     175        LPSTR pszEscaped,
     176        LPDWORD pcchEscaped,
     177        DWORD dwFlags)
    179178{
    180179    LPCSTR src;
    … …  
    186185
    187186    TRACE("(%s %p %p 0x%08lx)\n", debugstr_a(pszUrl), pszEscaped,
    188       pcchEscaped, dwFlags);
     187          pcchEscaped, dwFlags);
    189188
    190189    if(dwFlags & ~URL_ESCAPE_SPACES_ONLY)
    … …  
    193192    for(src = pszUrl; *src; src++) {
    194193        if(!(dwFlags & URL_ESCAPE_SPACES_ONLY) &&
    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;
     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;
    213212    }
    214213
    215214    if(needed < *pcchEscaped) {
    216215        *dst = '\0';
    217     ret = S_OK;
     216        ret = S_OK;
    218217    } else {
    219218        needed++; /* add one for the '\0' */
    220     ret = E_POINTER;
     219        ret = E_POINTER;
    221220    }
    222221    *pcchEscaped = needed;
    223222    return ret;
    224 }
    225 
    226 /*************************************************************************
    227  *      UrlEscapeW  [SHLWAPI]
     223}       
     224
     225/*************************************************************************
     226 *      UrlEscapeW      [SHLWAPI]
    228227 */
    229228HRESULT WINAPI UrlEscapeW(
    230     LPCWSTR pszUrl,
    231     LPWSTR pszEscaped,
    232     LPDWORD pcchEscaped,
    233     DWORD dwFlags)
     229        LPCWSTR pszUrl,
     230        LPWSTR pszEscaped,
     231        LPDWORD pcchEscaped,
     232        DWORD dwFlags)
    234233{
    235234    FIXME("(%s %p %p 0x%08lx): stub\n",debugstr_w(pszUrl),
    236       pszEscaped, pcchEscaped, dwFlags);
     235          pszEscaped, pcchEscaped, dwFlags);
    237236    return E_NOTIMPL;
    238237}
    … …  
    240239
    241240/*************************************************************************
    242  *      UrlUnescapeA    [SHLWAPI]
     241 *      UrlUnescapeA    [SHLWAPI]
    243242 *
    244243 * Converts escape sequences back to ordinary characters.
    245  *
     244 * 
    246245 * If URL_ESCAPE_INPLACE is set in dwFlags then pszUnescaped and
    247246 * pcchUnescaped are ignored and the converted string is returned in
    … …  
    257256 */
    258257HRESULT WINAPI UrlUnescapeA(
    259     LPCSTR pszUrl,
    260     LPSTR pszUnescaped,
    261     LPDWORD pcchUnescaped,
    262     DWORD dwFlags)
     258        LPCSTR pszUrl,
     259        LPSTR pszUnescaped,
     260        LPDWORD pcchUnescaped,
     261        DWORD dwFlags)
    263262{
    264263    char *dst, next;
    … …  
    269268
    270269    TRACE("(%s, %p, %p, %08lx): stub\n", debugstr_a(pszUrl), pszUnescaped,
    271       pcchUnescaped, dwFlags);
     270          pcchUnescaped, dwFlags);
    272271
    273272    if(dwFlags & URL_UNESCAPE_INPLACE)
    … …  
    278277    for(src = pszUrl, needed = 0; *src; src++, needed++) {
    279278        if(dwFlags & URL_DONT_UNESCAPE_EXTRA_INFO &&
    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;
     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;
    297296    }
    298297
    299298    if(dwFlags & URL_UNESCAPE_INPLACE || needed < *pcchUnescaped) {
    300299        *dst = '\0';
    301     ret = S_OK;
     300        ret = S_OK;
    302301    } else {
    303302        needed++; /* add one for the '\0' */
    304     ret = E_POINTER;
     303        ret = E_POINTER;
    305304    }
    306305    if(!(dwFlags & URL_UNESCAPE_INPLACE))
    … …  
    311310
    312311/*************************************************************************
    313  *      UrlUnescapeW    [SHLWAPI]
     312 *      UrlUnescapeW    [SHLWAPI]
    314313 */
    315314HRESULT WINAPI UrlUnescapeW(
    316     LPCWSTR pszUrl,
    317     LPWSTR pszUnescaped,
    318     LPDWORD pcchUnescaped,
    319     DWORD dwFlags)
     315        LPCWSTR pszUrl,
     316        LPWSTR pszUnescaped,
     317        LPDWORD pcchUnescaped,
     318        DWORD dwFlags)
    320319{
    321320    FIXME("(%s, %p, %p, %08lx): stub\n", debugstr_w(pszUrl), pszUnescaped,
    322       pcchUnescaped, dwFlags);
     321          pcchUnescaped, dwFlags);
    323322    return E_NOTIMPL;
    324323}
    325324
    326325/*************************************************************************
    327  *      HashData    [SHLWAPI]
     326 *      HashData        [SHLWAPI]
    328327 *
    329328 * Hash an input block into a variable sized digest.
    … …  
    358357
    359358/*************************************************************************
    360  *      UrlHashA    [SHLWAPI]
     359 *      UrlHashA        [SHLWAPI]
    361360 *
    362361 * Hash an ASCII URL.
    … …  
    372371
    373372/*************************************************************************
    374  *      UrlApplySchemeW [SHLWAPI.@]
     373 *      UrlApplySchemeW [SHLWAPI.@]
    375374 */
    376375HRESULT WINAPI UrlApplySchemeW(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut, DWORD dwFlags)
Note: See TracChangeset for help on using the changeset viewer.