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/string.c

    r6608 r6650  
     1/* $Id: string.c,v 1.5 2001-09-05 13:48:39 bird Exp $ */
    12//Note: Odin changes marked by #ifdef __WIN32OS2__!
    23#ifdef __WIN32OS2__
    … …  
    1516#endif
    1617#include <ctype.h>
    17 #include <stdlib.h> 
     18#include <stdlib.h>
    1819#include <stdio.h>
    1920#include <string.h>
    … …  
    4142
    4243/*************************************************************************
    43  * StrChrA                                      [SHLWAPI]
     44 * StrChrA                  [SHLWAPI]
    4445 */
    4546LPSTR WINAPI StrChrA (LPCSTR str, WORD c)
    4647{
    47         TRACE("%s %i\n", str,c);
    48         return strchr(str, c);
    49 }
    50 
    51 /*************************************************************************
    52  * StrChrW                                      [SHLWAPI]
     48    TRACE("%s %i\n", str,c);
     49    return strchr(str, c);
     50}
     51
     52/*************************************************************************
     53 * StrChrW                  [SHLWAPI]
    5354 *
    5455 */
    5556LPWSTR WINAPI StrChrW (LPCWSTR str, WCHAR x )
    5657{
    57         TRACE("%s 0x%04x\n",debugstr_w(str),x);
    58         return strchrW(str, x);
     58    TRACE("%s 0x%04x\n",debugstr_w(str),x);
     59    return strchrW(str, x);
    5960}
    6061#ifndef __WIN32OS2__
    6162/*************************************************************************
    62  * StrCmpIW                                     [SHLWAPI]
     63 * StrCmpIW                 [SHLWAPI]
    6364 */
    6465int WINAPI StrCmpIW ( LPCWSTR wstr1, LPCWSTR wstr2 )
    … …  
    7071
    7172/*************************************************************************
    72  * StrCmpNA                                     [SHLWAPI]
     73 * StrCmpNA                 [SHLWAPI]
    7374 */
    7475INT WINAPI StrCmpNA ( LPCSTR str1, LPCSTR str2, INT len)
    7576{
    76         TRACE("%s %s %i stub\n", str1,str2,len);
    77         return strncmp(str1, str2, len);
    78 }
    79 
    80 /*************************************************************************
    81  * StrCmpNW                                     [SHLWAPI]
     77    TRACE("%s %s %i stub\n", str1,str2,len);
     78    return strncmp(str1, str2, len);
     79}
     80
     81/*************************************************************************
     82 * StrCmpNW                 [SHLWAPI]
    8283 */
    8384INT WINAPI StrCmpNW ( LPCWSTR wstr1, LPCWSTR wstr2, INT len)
    8485{
    85         TRACE("%s %s %i stub\n", debugstr_w(wstr1),debugstr_w(wstr2),len);
    86         return strncmpW(wstr1, wstr2, len);
    87 }
    88 
    89 /*************************************************************************
    90  * StrCmpNIA                                    [SHLWAPI]
     86    TRACE("%s %s %i stub\n", debugstr_w(wstr1),debugstr_w(wstr2),len);
     87    return strncmpW(wstr1, wstr2, len);
     88}
     89
     90/*************************************************************************
     91 * StrCmpNIA                    [SHLWAPI]
    9192 */
    9293int WINAPI StrCmpNIA ( LPCSTR str1, LPCSTR str2, int len)
    9394{
    94         TRACE("%s %s %i stub\n", str1,str2,len);
    95         return strncasecmp(str1, str2, len);
    96 }
    97 
    98 /*************************************************************************
    99  * StrCmpNIW                                    [SHLWAPI]
     95    TRACE("%s %s %i stub\n", str1,str2,len);
     96    return strncasecmp(str1, str2, len);
     97}
     98
     99/*************************************************************************
     100 * StrCmpNIW                    [SHLWAPI]
    100101 */
    101102int WINAPI StrCmpNIW ( LPCWSTR wstr1, LPCWSTR wstr2, int len)
    102103{
    103         TRACE("%s %s %i stub\n", debugstr_w(wstr1),debugstr_w(wstr2),len);
    104         return strncmpiW(wstr1, wstr2, len);
    105 }
    106 
    107 /*************************************************************************
    108  * StrCmpW                                      [SHLWAPI]
     104    TRACE("%s %s %i stub\n", debugstr_w(wstr1),debugstr_w(wstr2),len);
     105    return strncmpiW(wstr1, wstr2, len);
     106}
     107
     108/*************************************************************************
     109 * StrCmpW                  [SHLWAPI]
    109110 */
    110111int WINAPI StrCmpW ( LPCWSTR wstr1, LPCWSTR wstr2 )
    … …  
    115116
    116117/*************************************************************************
    117  * StrCatW                                      [SHLWAPI]
     118 * StrCatW                  [SHLWAPI]
    118119 */
    119120LPWSTR WINAPI StrCatW( LPWSTR wstr1, LPCWSTR wstr2 )
    … …  
    124125
    125126/*************************************************************************
    126  * StrCpyW                                      [SHLWAPI]
     127 * StrCpyW                  [SHLWAPI]
    127128 */
    128129LPWSTR WINAPI StrCpyW( LPWSTR wstr1, LPCWSTR wstr2 )
    … …  
    133134
    134135/*************************************************************************
    135  * StrCpyNW                                     [SHLWAPI]
     136 * StrCpyNW                 [SHLWAPI]
    136137 */
    137138LPWSTR WINAPI StrCpyNW( LPWSTR wstr1, LPCWSTR wstr2, int n )
    … …  
    142143
    143144/*************************************************************************
    144  * StrStrA                                      [SHLWAPI]
     145 * StrStrA                  [SHLWAPI]
    145146 */
    146147LPSTR WINAPI StrStrA(LPCSTR lpFirst, LPCSTR lpSrch)
    … …  
    157158
    158159/*************************************************************************
    159  * StrStrW                                      [SHLWAPI]
     160 * StrStrW                  [SHLWAPI]
    160161 */
    161162LPWSTR WINAPI StrStrW(LPCWSTR lpFirst, LPCWSTR lpSrch)
    … …  
    172173
    173174/*************************************************************************
    174  * StrStrIA                                     [SHLWAPI]
     175 * StrStrIA                 [SHLWAPI]
    175176 */
    176177LPSTR WINAPI StrStrIA(LPCSTR lpFirst, LPCSTR lpSrch)
    … …  
    187188
    188189/*************************************************************************
    189  * StrStrIW                                     [SHLWAPI]
     190 * StrStrIW                 [SHLWAPI]
    190191 */
    191192LPWSTR WINAPI StrStrIW(LPCWSTR lpFirst, LPCWSTR lpSrch)
    … …  
    202203
    203204/*************************************************************************
    204  *      StrToIntA                       [SHLWAPI]
     205 *  StrToIntA           [SHLWAPI]
    205206 */
    206207int WINAPI StrToIntA(LPCSTR lpSrc)
    207208{
    208         TRACE("%s\n", lpSrc);
    209         return atol(lpSrc);
    210 }
    211 
    212 /*************************************************************************
    213  *      StrToIntW                       [SHLWAPI]
     209    TRACE("%s\n", lpSrc);
     210    return atol(lpSrc);
     211}
     212
     213/*************************************************************************
     214 *  StrToIntW           [SHLWAPI]
    214215 */
    215216int WINAPI StrToIntW(LPCWSTR lpSrc)
    … …  
    224225
    225226/*************************************************************************
    226  *      StrToIntExA                     [SHLWAPI]
     227 *  StrToIntExA         [SHLWAPI]
    227228 */
    228229BOOL WINAPI StrToIntExA( LPCSTR pszString, DWORD dwFlags, LPINT piRet)
    229230{
    230         TRACE("%s %ld stub !\n", debugstr_a(pszString), dwFlags);
    231         piRet = (LPINT) StrToIntA(pszString);
    232         return TRUE;
    233 }
    234 
    235 /*************************************************************************
    236  *      StrToIntExW                     [SHLWAPI]
     231    TRACE("%s %ld stub !\n", debugstr_a(pszString), dwFlags);
     232    piRet = (LPINT) StrToIntA(pszString);
     233    return TRUE;
     234}
     235
     236/*************************************************************************
     237 *  StrToIntExW         [SHLWAPI]
    237238 */
    238239BOOL WINAPI StrToIntExW( LPCWSTR pszString, DWORD dwFlags, LPINT piRet)
    239240{
    240         TRACE("%s %ld stub !\n", debugstr_w(pszString), dwFlags);
    241         piRet = (LPINT) StrToIntW(pszString);
    242         return TRUE;
    243 }
    244 
    245 /*************************************************************************
    246  *      StrDupA                 [SHLWAPI]
     241    TRACE("%s %ld stub !\n", debugstr_w(pszString), dwFlags);
     242    piRet = (LPINT) StrToIntW(pszString);
     243    return TRUE;
     244}
     245
     246/*************************************************************************
     247 *  StrDupA         [SHLWAPI]
    247248 */
    248249LPSTR WINAPI StrDupA (LPCSTR lpSrc)
    249250{
    250         int len = strlen(lpSrc);
    251         LPSTR lpDest = (LPSTR) LocalAlloc(LMEM_FIXED, len+1);
    252        
    253         TRACE("%s\n", lpSrc);
    254 
    255         if (lpDest) strcpy(lpDest, lpSrc);
    256         return lpDest;
    257 }
    258 
    259 /*************************************************************************
    260  *      StrDupW                 [SHLWAPI]
     251    int len = strlen(lpSrc);
     252    LPSTR lpDest = (LPSTR) LocalAlloc(LMEM_FIXED, len+1);
     253
     254    TRACE("%s\n", lpSrc);
     255
     256    if (lpDest) strcpy(lpDest, lpSrc);
     257    return lpDest;
     258}
     259
     260/*************************************************************************
     261 *  StrDupW         [SHLWAPI]
    261262 */
    262263LPWSTR WINAPI StrDupW (LPCWSTR lpSrc)
    263264{
    264         int len = strlenW(lpSrc);
    265         LPWSTR lpDest = (LPWSTR) LocalAlloc(LMEM_FIXED, sizeof(WCHAR) * (len+1));
    266        
    267         TRACE("%s\n", debugstr_w(lpSrc));
    268 
    269         if (lpDest) strcpyW(lpDest, lpSrc);
    270         return lpDest;
    271 }
    272 
    273 /*************************************************************************
    274  *      StrCSpnA                [SHLWAPI]
     265    int len = strlenW(lpSrc);
     266    LPWSTR lpDest = (LPWSTR) LocalAlloc(LMEM_FIXED, sizeof(WCHAR) * (len+1));
     267
     268    TRACE("%s\n", debugstr_w(lpSrc));
     269
     270    if (lpDest) strcpyW(lpDest, lpSrc);
     271    return lpDest;
     272}
     273
     274/*************************************************************************
     275 *  StrCSpnA        [SHLWAPI]
    275276 */
    276277int WINAPI StrCSpnA (LPCSTR lpStr, LPCSTR lpSet)
    277278{
    278         int i,j, pos = strlen(lpStr);
    279 
    280         TRACE("(%p %s  %p %s)\n",
    281            lpStr, debugstr_a(lpStr), lpSet, debugstr_a(lpSet));
    282 
    283         for (i=0; i < strlen(lpSet) ; i++ )
    284         {
    285           for (j = 0; j < pos;j++)
    286           {
    287             if (lpStr[j] == lpSet[i])
    288             {
    289               pos = j;
    290             }
    291           }
    292         }     
    293         TRACE("-- %u\n", pos);
    294         return pos;     
    295 }
    296 
    297 /*************************************************************************
    298  *      StrCSpnW                [SHLWAPI]
     279    int i,j, pos = strlen(lpStr);
     280
     281    TRACE("(%p %s  %p %s)\n",
     282       lpStr, debugstr_a(lpStr), lpSet, debugstr_a(lpSet));
     283
     284    for (i=0; i < strlen(lpSet) ; i++ )
     285    {
     286      for (j = 0; j < pos;j++)
     287      {
     288        if (lpStr[j] == lpSet[i])
     289        {
     290          pos = j;
     291        }
     292      }
     293    }
     294    TRACE("-- %u\n", pos);
     295    return pos;
     296}
     297
     298/*************************************************************************
     299 *  StrCSpnW        [SHLWAPI]
    299300 */
    300301int WINAPI StrCSpnW (LPCWSTR lpStr, LPCWSTR lpSet)
    301302{
    302         int i,j, pos = strlenW(lpStr);
    303 
    304         TRACE("(%p %s %p %s)\n",
    305            lpStr, debugstr_w(lpStr), lpSet, debugstr_w(lpSet));
    306 
    307         for (i=0; i < strlenW(lpSet) ; i++ )
    308         {
    309           for (j = 0; j < pos;j++)
    310           {
    311             if (lpStr[j] == lpSet[i])
    312             {
    313               pos = j;
    314             }
    315           }
    316         }     
    317         TRACE("-- %u\n", pos);
    318         return pos;     
     303    int i,j, pos = strlenW(lpStr);
     304
     305    TRACE("(%p %s %p %s)\n",
     306       lpStr, debugstr_w(lpStr), lpSet, debugstr_w(lpSet));
     307
     308    for (i=0; i < strlenW(lpSet) ; i++ )
     309    {
     310      for (j = 0; j < pos;j++)
     311      {
     312        if (lpStr[j] == lpSet[i])
     313        {
     314          pos = j;
     315        }
     316      }
     317    }
     318    TRACE("-- %u\n", pos);
     319    return pos;
    319320}
    320321
    … …  
    337338        if (dbcs && lpStart[1] != HIBYTE(wMatch)) continue;
    338339        lpGotIt = lpStart;
    339     }   
     340    }
    340341    return (LPSTR)lpGotIt;
    341342}
    … …  
    361362
    362363/*************************************************************************
    363  *      StrCatBuffA             [SHLWAPI]
     364 *  StrCatBuffA     [SHLWAPI]
    364365 *
    365366 * Appends back onto front, stopping when front is size-1 characters long.
    … …  
    379380
    380381/*************************************************************************
    381  *      StrCatBuffW             [SHLWAPI]
     382 *  StrCatBuffW     [SHLWAPI]
    382383 *
    383384 * Appends back onto front, stopping when front is size-1 characters long.
    … …  
    397398
    398399/*************************************************************************
    399  * StrRetToBufA                                 [SHLWAPI.@]
    400  * 
     400 * StrRetToBufA                 [SHLWAPI.@]
     401 *
    401402 * converts a STRRET to a normal string
    402403 *
    … …  
    406407HRESULT WINAPI StrRetToBufA (LPSTRRET src, const ITEMIDLIST *pidl, LPSTR dest, DWORD len)
    407408{
    408         TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
    409 
    410         switch (src->uType)
    411         {
    412           case STRRET_WSTR:
    413             WideCharToMultiByte(CP_ACP, 0, src->u.pOleStr, -1, (LPSTR)dest, len, NULL, NULL);
    414 /*          SHFree(src->u.pOleStr);  FIXME: is this right? */
    415             break;
    416 
    417           case STRRET_CSTRA:
    418             lstrcpynA((LPSTR)dest, src->u.cStr, len);
    419             break;
    420 
    421           case STRRET_OFFSETA:
    422             lstrcpynA((LPSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
    423             break;
    424 
    425           default:
    426             FIXME("unknown type!\n");
    427             if (len)
    428             {
    429               *(LPSTR)dest = '\0';
    430             }
    431             return(FALSE);
    432         }
    433         return S_OK;
    434 }
    435 
    436 /*************************************************************************
    437  * StrRetToBufW                                 [SHLWAPI.@]
    438  * 
     409    TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
     410
     411    switch (src->uType)
     412    {
     413      case STRRET_WSTR:
     414        WideCharToMultiByte(CP_ACP, 0, src->u.pOleStr, -1, (LPSTR)dest, len, NULL, NULL);
     415/*      SHFree(src->u.pOleStr);  FIXME: is this right? */
     416        break;
     417
     418      case STRRET_CSTRA:
     419        lstrcpynA((LPSTR)dest, src->u.cStr, len);
     420        break;
     421
     422      case STRRET_OFFSETA:
     423        lstrcpynA((LPSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
     424        break;
     425
     426      default:
     427        FIXME("unknown type!\n");
     428        if (len)
     429        {
     430          *(LPSTR)dest = '\0';
     431        }
     432        return(FALSE);
     433    }
     434    return S_OK;
     435}
     436
     437/*************************************************************************
     438 * StrRetToBufW                 [SHLWAPI.@]
     439 *
    439440 * converts a STRRET to a normal string
    440441 *
    … …  
    444445HRESULT WINAPI StrRetToBufW (LPSTRRET src, const ITEMIDLIST *pidl, LPWSTR dest, DWORD len)
    445446{
    446         TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
    447 
    448         switch (src->uType)
    449         {
    450           case STRRET_WSTR:
    451             lstrcpynW((LPWSTR)dest, src->u.pOleStr, len);
    452 /*          SHFree(src->u.pOleStr);  FIXME: is this right? */
    453             break;
    454 
    455           case STRRET_CSTRA:
     447    TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
     448
     449    switch (src->uType)
     450    {
     451      case STRRET_WSTR:
     452        lstrcpynW((LPWSTR)dest, src->u.pOleStr, len);
     453/*      SHFree(src->u.pOleStr);  FIXME: is this right? */
     454        break;
     455
     456      case STRRET_CSTRA:
    456457              if (!MultiByteToWideChar( CP_ACP, 0, src->u.cStr, -1, dest, len ) && len)
    457458                  dest[len-1] = 0;
    458             break;
    459 
    460           case STRRET_OFFSETA:
    461             if (pidl)
    462             {
     459        break;
     460
     461      case STRRET_OFFSETA:
     462        if (pidl)
     463        {
    463464              if (!MultiByteToWideChar( CP_ACP, 0, ((LPCSTR)&pidl->mkid)+src->u.uOffset, -1,
    464465                                        dest, len ) && len)
    465466                  dest[len-1] = 0;
    466             }
    467             break;
    468 
    469           default:
    470             FIXME("unknown type!\n");
    471             if (len)
    472             { *(LPSTR)dest = '\0';
    473             }
    474             return(FALSE);
    475         }
    476         return S_OK;
    477 }
    478 
    479 /*************************************************************************
    480  * StrFormatByteSizeA                           [SHLWAPI]
     467        }
     468        break;
     469
     470      default:
     471        FIXME("unknown type!\n");
     472        if (len)
     473        { *(LPSTR)dest = '\0';
     474        }
     475        return(FALSE);
     476    }
     477    return S_OK;
     478}
     479
     480/*************************************************************************
     481 * StrFormatByteSizeA               [SHLWAPI]
    481482 */
    482483LPSTR WINAPI StrFormatByteSizeA ( DWORD dw, LPSTR pszBuf, UINT cchBuf )
    483 {       char buf[64];
    484         TRACE("%lx %p %i\n", dw, pszBuf, cchBuf);
    485         if ( dw<1024L )
    486         { sprintf (buf,"%ld bytes", dw);
    487         }
    488         else if ( dw<1048576L)
    489         { sprintf (buf,"%3.1f KB", (FLOAT)dw/1024);
    490         }
    491         else if ( dw < 1073741824L)
    492         { sprintf (buf,"%3.1f MB", (FLOAT)dw/1048576L);
    493         }
    494         else
    495         { sprintf (buf,"%3.1f GB", (FLOAT)dw/1073741824L);
    496         }
    497         lstrcpynA (pszBuf, buf, cchBuf);
    498         return pszBuf; 
    499 }
    500 
    501 /*************************************************************************
    502  * StrFormatByteSizeW                           [SHLWAPI]
     484{   char buf[64];
     485    TRACE("%lx %p %i\n", dw, pszBuf, cchBuf);
     486    if ( dw<1024L )
     487    { sprintf (buf,"%ld bytes", dw);
     488    }
     489    else if ( dw<1048576L)
     490    { sprintf (buf,"%3.1f KB", (FLOAT)dw/1024);
     491    }
     492    else if ( dw < 1073741824L)
     493    { sprintf (buf,"%3.1f MB", (FLOAT)dw/1048576L);
     494    }
     495    else
     496    { sprintf (buf,"%3.1f GB", (FLOAT)dw/1073741824L);
     497    }
     498    lstrcpynA (pszBuf, buf, cchBuf);
     499    return pszBuf;
     500}
     501
     502/*************************************************************************
     503 * StrFormatByteSizeW               [SHLWAPI]
    503504 */
    504505LPWSTR WINAPI StrFormatByteSizeW ( DWORD dw, LPWSTR pszBuf, UINT cchBuf )
    … …  
    512513
    513514/*************************************************************************
    514  *      StrNCatA        [SHLWAPI]
     515 *      StrNCatA    [SHLWAPI]
    515516 */
    516517LPSTR WINAPI StrNCatA(LPSTR front, LPCSTR back, INT cchMax)
    517518{
    518         TRACE("%s %s %i stub\n", debugstr_a(front),debugstr_a(back),cchMax);
    519         return (front);
    520 }
    521 
    522 /*************************************************************************
    523  *      StrNCatW        [SHLWAPI]
     519    TRACE("%s %s %i stub\n", debugstr_a(front),debugstr_a(back),cchMax);
     520    return (front);
     521}
     522
     523/*************************************************************************
     524 *      StrNCatW    [SHLWAPI]
    524525 */
    525526LPWSTR WINAPI StrNCatW(LPWSTR front, LPCWSTR back, INT cchMax)
    526527{
    527         TRACE("%s %s %i stub\n", debugstr_w(front),debugstr_w(back),cchMax);
    528         return (front);
    529 }
    530 
    531 /*************************************************************************
    532  *      StrTrimA        [SHLWAPI.@]
     528    TRACE("%s %s %i stub\n", debugstr_w(front),debugstr_w(back),cchMax);
     529    return (front);
     530}
     531
     532/*************************************************************************
     533 *      StrTrimA    [SHLWAPI.@]
    533534 */
    534535BOOL WINAPI StrTrimA(LPSTR pszSource, LPCSTR pszTrimChars)
    … …  
    541542    for (pTrim = pszTrimChars; *pTrim; pTrim++)
    542543    {
    543         for (pSrc = pszSource; *pSrc; pSrc++)
    544              if (*pSrc == *pTrim)
    545              {
    546                 /* match -> remove this char.
    547                   * strlen(pSrc) equiv. to the correct strlen(pSrc+1)+1 */
    548                 memmove(pSrc, pSrc+1, strlen(pSrc));
    549                 trimmed = TRUE;
    550              }
     544    for (pSrc = pszSource; *pSrc; pSrc++)
     545         if (*pSrc == *pTrim)
     546         {
     547        /* match -> remove this char.
     548          * strlen(pSrc) equiv. to the correct strlen(pSrc+1)+1 */
     549        memmove(pSrc, pSrc+1, strlen(pSrc));
     550        trimmed = TRUE;
     551         }
    551552    }
    552553    TRACE("<- '%s'\n", pszSource);
    … …  
    555556
    556557/*************************************************************************
    557  *      wnsprintfA      [SHLWAPI]
     558 *      wnsprintfA  [SHLWAPI]
    558559 */
    559560int WINAPIV wnsprintfA(LPSTR lpOut, int cchLimitIn, LPCSTR lpFmt, ...)
    … …  
    569570
    570571/*************************************************************************
    571  *      wnsprintfW      [SHLWAPI]
     572 *      wnsprintfW  [SHLWAPI]
    572573 */
    573574int WINAPIV wnsprintfW(LPWSTR lpOut, int cchLimitIn, LPCWSTR lpFmt, ...)
Note: See TracChangeset for help on using the changeset viewer.