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

    r6650 r6712  
    1 /* $Id: string.c,v 1.5 2001-09-05 13:48:39 bird Exp $ */
    21//Note: Odin changes marked by #ifdef __WIN32OS2__!
    32#ifdef __WIN32OS2__
    … …  
    1615#endif
    1716#include <ctype.h>
    18 #include <stdlib.h>
     17#include <stdlib.h> 
    1918#include <stdio.h>
    2019#include <string.h>
    … …  
    4241
    4342/*************************************************************************
    44  * StrChrA                  [SHLWAPI]
     43 * StrChrA                                      [SHLWAPI]
    4544 */
    4645LPSTR WINAPI StrChrA (LPCSTR str, WORD c)
    4746{
    48     TRACE("%s %i\n", str,c);
    49     return strchr(str, c);
    50 }
    51 
    52 /*************************************************************************
    53  * StrChrW                  [SHLWAPI]
     47        TRACE("%s %i\n", str,c);
     48        return strchr(str, c);
     49}
     50
     51/*************************************************************************
     52 * StrChrW                                      [SHLWAPI]
    5453 *
    5554 */
    5655LPWSTR WINAPI StrChrW (LPCWSTR str, WCHAR x )
    5756{
    58     TRACE("%s 0x%04x\n",debugstr_w(str),x);
    59     return strchrW(str, x);
     57        TRACE("%s 0x%04x\n",debugstr_w(str),x);
     58        return strchrW(str, x);
    6059}
    6160#ifndef __WIN32OS2__
    6261/*************************************************************************
    63  * StrCmpIW                 [SHLWAPI]
     62 * StrCmpIW                                     [SHLWAPI]
    6463 */
    6564int WINAPI StrCmpIW ( LPCWSTR wstr1, LPCWSTR wstr2 )
    … …  
    7170
    7271/*************************************************************************
    73  * StrCmpNA                 [SHLWAPI]
     72 * StrCmpNA                                     [SHLWAPI]
    7473 */
    7574INT WINAPI StrCmpNA ( LPCSTR str1, LPCSTR str2, INT len)
    7675{
    77     TRACE("%s %s %i stub\n", str1,str2,len);
    78     return strncmp(str1, str2, len);
    79 }
    80 
    81 /*************************************************************************
    82  * StrCmpNW                 [SHLWAPI]
     76        TRACE("%s %s %i stub\n", str1,str2,len);
     77        return strncmp(str1, str2, len);
     78}
     79
     80/*************************************************************************
     81 * StrCmpNW                                     [SHLWAPI]
    8382 */
    8483INT WINAPI StrCmpNW ( LPCWSTR wstr1, LPCWSTR wstr2, INT len)
    8584{
    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]
     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]
    9291 */
    9392int WINAPI StrCmpNIA ( LPCSTR str1, LPCSTR str2, int len)
    9493{
    95     TRACE("%s %s %i stub\n", str1,str2,len);
    96     return strncasecmp(str1, str2, len);
    97 }
    98 
    99 /*************************************************************************
    100  * StrCmpNIW                    [SHLWAPI]
     94        TRACE("%s %s %i stub\n", str1,str2,len);
     95        return strncasecmp(str1, str2, len);
     96}
     97
     98/*************************************************************************
     99 * StrCmpNIW                                    [SHLWAPI]
    101100 */
    102101int WINAPI StrCmpNIW ( LPCWSTR wstr1, LPCWSTR wstr2, int len)
    103102{
    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]
     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]
    110109 */
    111110int WINAPI StrCmpW ( LPCWSTR wstr1, LPCWSTR wstr2 )
    … …  
    116115
    117116/*************************************************************************
    118  * StrCatW                  [SHLWAPI]
     117 * StrCatW                                      [SHLWAPI]
    119118 */
    120119LPWSTR WINAPI StrCatW( LPWSTR wstr1, LPCWSTR wstr2 )
    … …  
    125124
    126125/*************************************************************************
    127  * StrCpyW                  [SHLWAPI]
     126 * StrCpyW                                      [SHLWAPI]
    128127 */
    129128LPWSTR WINAPI StrCpyW( LPWSTR wstr1, LPCWSTR wstr2 )
    … …  
    134133
    135134/*************************************************************************
    136  * StrCpyNW                 [SHLWAPI]
     135 * StrCpyNW                                     [SHLWAPI]
    137136 */
    138137LPWSTR WINAPI StrCpyNW( LPWSTR wstr1, LPCWSTR wstr2, int n )
    … …  
    143142
    144143/*************************************************************************
    145  * StrStrA                  [SHLWAPI]
     144 * StrStrA                                      [SHLWAPI]
    146145 */
    147146LPSTR WINAPI StrStrA(LPCSTR lpFirst, LPCSTR lpSrch)
    … …  
    158157
    159158/*************************************************************************
    160  * StrStrW                  [SHLWAPI]
     159 * StrStrW                                      [SHLWAPI]
    161160 */
    162161LPWSTR WINAPI StrStrW(LPCWSTR lpFirst, LPCWSTR lpSrch)
    … …  
    173172
    174173/*************************************************************************
    175  * StrStrIA                 [SHLWAPI]
     174 * StrStrIA                                     [SHLWAPI]
    176175 */
    177176LPSTR WINAPI StrStrIA(LPCSTR lpFirst, LPCSTR lpSrch)
    … …  
    188187
    189188/*************************************************************************
    190  * StrStrIW                 [SHLWAPI]
     189 * StrStrIW                                     [SHLWAPI]
    191190 */
    192191LPWSTR WINAPI StrStrIW(LPCWSTR lpFirst, LPCWSTR lpSrch)
    … …  
    203202
    204203/*************************************************************************
    205  *  StrToIntA           [SHLWAPI]
     204 *      StrToIntA                       [SHLWAPI]
    206205 */
    207206int WINAPI StrToIntA(LPCSTR lpSrc)
    208207{
    209     TRACE("%s\n", lpSrc);
    210     return atol(lpSrc);
    211 }
    212 
    213 /*************************************************************************
    214  *  StrToIntW           [SHLWAPI]
     208        TRACE("%s\n", lpSrc);
     209        return atol(lpSrc);
     210}
     211
     212/*************************************************************************
     213 *      StrToIntW                       [SHLWAPI]
    215214 */
    216215int WINAPI StrToIntW(LPCWSTR lpSrc)
    … …  
    225224
    226225/*************************************************************************
    227  *  StrToIntExA         [SHLWAPI]
     226 *      StrToIntExA                     [SHLWAPI]
    228227 */
    229228BOOL WINAPI StrToIntExA( LPCSTR pszString, DWORD dwFlags, LPINT piRet)
    230229{
    231     TRACE("%s %ld stub !\n", debugstr_a(pszString), dwFlags);
    232     piRet = (LPINT) StrToIntA(pszString);
    233     return TRUE;
    234 }
    235 
    236 /*************************************************************************
    237  *  StrToIntExW         [SHLWAPI]
     230        TRACE("%s %ld stub !\n", debugstr_a(pszString), dwFlags);
     231        piRet = (LPINT) StrToIntA(pszString);
     232        return TRUE;
     233}
     234
     235/*************************************************************************
     236 *      StrToIntExW                     [SHLWAPI]
    238237 */
    239238BOOL WINAPI StrToIntExW( LPCWSTR pszString, DWORD dwFlags, LPINT piRet)
    240239{
    241     TRACE("%s %ld stub !\n", debugstr_w(pszString), dwFlags);
    242     piRet = (LPINT) StrToIntW(pszString);
    243     return TRUE;
    244 }
    245 
    246 /*************************************************************************
    247  *  StrDupA         [SHLWAPI]
     240        TRACE("%s %ld stub !\n", debugstr_w(pszString), dwFlags);
     241        piRet = (LPINT) StrToIntW(pszString);
     242        return TRUE;
     243}
     244
     245/*************************************************************************
     246 *      StrDupA                 [SHLWAPI]
    248247 */
    249248LPSTR WINAPI StrDupA (LPCSTR lpSrc)
    250249{
    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]
     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]
    262261 */
    263262LPWSTR WINAPI StrDupW (LPCWSTR lpSrc)
    264263{
    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]
     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]
    276275 */
    277276int WINAPI StrCSpnA (LPCSTR lpStr, LPCSTR lpSet)
    278277{
    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]
     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]
    300299 */
    301300int WINAPI StrCSpnW (LPCWSTR lpStr, LPCWSTR lpSet)
    302301{
    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;
     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;     
    320319}
    321320
    … …  
    338337        if (dbcs && lpStart[1] != HIBYTE(wMatch)) continue;
    339338        lpGotIt = lpStart;
    340     }
     339    }   
    341340    return (LPSTR)lpGotIt;
    342341}
    … …  
    362361
    363362/*************************************************************************
    364  *  StrCatBuffA     [SHLWAPI]
     363 *      StrCatBuffA             [SHLWAPI]
    365364 *
    366365 * Appends back onto front, stopping when front is size-1 characters long.
    … …  
    380379
    381380/*************************************************************************
    382  *  StrCatBuffW     [SHLWAPI]
     381 *      StrCatBuffW             [SHLWAPI]
    383382 *
    384383 * Appends back onto front, stopping when front is size-1 characters long.
    … …  
    398397
    399398/*************************************************************************
    400  * StrRetToBufA                 [SHLWAPI.@]
    401  *
     399 * StrRetToBufA                                 [SHLWAPI.@]
     400 * 
    402401 * converts a STRRET to a normal string
    403402 *
    … …  
    407406HRESULT WINAPI StrRetToBufA (LPSTRRET src, const ITEMIDLIST *pidl, LPSTR dest, DWORD len)
    408407{
    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  *
     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 * 
    440439 * converts a STRRET to a normal string
    441440 *
    … …  
    445444HRESULT WINAPI StrRetToBufW (LPSTRRET src, const ITEMIDLIST *pidl, LPWSTR dest, DWORD len)
    446445{
    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:
     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:
    457456              if (!MultiByteToWideChar( CP_ACP, 0, src->u.cStr, -1, dest, len ) && len)
    458457                  dest[len-1] = 0;
    459         break;
    460 
    461       case STRRET_OFFSETA:
    462         if (pidl)
    463         {
     458            break;
     459
     460          case STRRET_OFFSETA:
     461            if (pidl)
     462            {
    464463              if (!MultiByteToWideChar( CP_ACP, 0, ((LPCSTR)&pidl->mkid)+src->u.uOffset, -1,
    465464                                        dest, len ) && len)
    466465                  dest[len-1] = 0;
    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]
     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]
    482481 */
    483482LPSTR WINAPI StrFormatByteSizeA ( DWORD dw, LPSTR pszBuf, UINT cchBuf )
    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]
     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]
    504503 */
    505504LPWSTR WINAPI StrFormatByteSizeW ( DWORD dw, LPWSTR pszBuf, UINT cchBuf )
    … …  
    513512
    514513/*************************************************************************
    515  *      StrNCatA    [SHLWAPI]
     514 *      StrNCatA        [SHLWAPI]
    516515 */
    517516LPSTR WINAPI StrNCatA(LPSTR front, LPCSTR back, INT cchMax)
    518517{
    519     TRACE("%s %s %i stub\n", debugstr_a(front),debugstr_a(back),cchMax);
    520     return (front);
    521 }
    522 
    523 /*************************************************************************
    524  *      StrNCatW    [SHLWAPI]
     518        TRACE("%s %s %i stub\n", debugstr_a(front),debugstr_a(back),cchMax);
     519        return (front);
     520}
     521
     522/*************************************************************************
     523 *      StrNCatW        [SHLWAPI]
    525524 */
    526525LPWSTR WINAPI StrNCatW(LPWSTR front, LPCWSTR back, INT cchMax)
    527526{
    528     TRACE("%s %s %i stub\n", debugstr_w(front),debugstr_w(back),cchMax);
    529     return (front);
    530 }
    531 
    532 /*************************************************************************
    533  *      StrTrimA    [SHLWAPI.@]
     527        TRACE("%s %s %i stub\n", debugstr_w(front),debugstr_w(back),cchMax);
     528        return (front);
     529}
     530
     531/*************************************************************************
     532 *      StrTrimA        [SHLWAPI.@]
    534533 */
    535534BOOL WINAPI StrTrimA(LPSTR pszSource, LPCSTR pszTrimChars)
    … …  
    542541    for (pTrim = pszTrimChars; *pTrim; pTrim++)
    543542    {
    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          }
     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             }
    552551    }
    553552    TRACE("<- '%s'\n", pszSource);
    … …  
    556555
    557556/*************************************************************************
    558  *      wnsprintfA  [SHLWAPI]
     557 *      wnsprintfA      [SHLWAPI]
    559558 */
    560559int WINAPIV wnsprintfA(LPSTR lpOut, int cchLimitIn, LPCSTR lpFmt, ...)
    … …  
    570569
    571570/*************************************************************************
    572  *      wnsprintfW  [SHLWAPI]
     571 *      wnsprintfW      [SHLWAPI]
    573572 */
    574573int WINAPIV wnsprintfW(LPWSTR lpOut, int cchLimitIn, LPCWSTR lpFmt, ...)
Note: See TracChangeset for help on using the changeset viewer.