dlls/shlwapi/string.c

   1 #include <ctype.h>
   2 #include <stdlib.h>
   3 #include <stdio.h>
   4 #include <string.h>
   5
   6 #include "winerror.h"
   7 #include "wine/undocshell.h"
   8 #include "wine/unicode.h"
   9 #include "heap.h"
  10 #include "debugtools.h"
  11
  12 DEFAULT_DEBUG_CHANNEL(shell);
  13
  14 /*************************************************************************
  15  * StrChrA                                      [SHLWAPI]
  16  */
  17 LPSTR WINAPI StrChrA (LPCSTR str, INT c)
  18 {
  19         TRACE("%s %i\n", str,c);
  20         return strchr(str, c);
  21 }
  22
  23 /*************************************************************************
  24  * StrChrW                                      [SHLWAPI]
  25  *
  26  */
  27 LPWSTR WINAPI StrChrW (LPWSTR str, WCHAR x )
  28 {
  29         TRACE("%s 0x%04x\n",debugstr_w(str),x);
  30         return strchrW(str, x);
  31 }
  32
  33 /*************************************************************************
  34  * StrCmpNA                                     [SHLWAPI]
  35  */
  36 INT WINAPI StrCmpNA ( LPCSTR str1, LPCSTR str2, INT len)
  37 {
  38         TRACE("%s %s %i stub\n", str1,str2,len);
  39         return strncmp(str1, str2, len);
  40 }
  41
  42 /*************************************************************************
  43  * StrCmpNW                                     [SHLWAPI]
  44  */
  45 INT WINAPI StrCmpNW ( LPCWSTR wstr1, LPCWSTR wstr2, INT len)
  46 {
  47         TRACE("%s %s %i stub\n", debugstr_w(wstr1),debugstr_w(wstr2),len);
  48         return strncmpW(wstr1, wstr2, len);
  49 }
  50
  51 /*************************************************************************
  52  * StrCmpNIA                                    [SHLWAPI]
  53  */
  54 int WINAPI StrCmpNIA ( LPCSTR str1, LPCSTR str2, int len)
  55 {
  56         TRACE("%s %s %i stub\n", str1,str2,len);
  57         return strncasecmp(str1, str2, len);
  58 }
  59
  60 /*************************************************************************
  61  * StrCmpNIW                                    [SHLWAPI]
  62  */
  63 int WINAPI StrCmpNIW ( LPCWSTR wstr1, LPCWSTR wstr2, int len)
  64 {
  65         TRACE("%s %s %i stub\n", debugstr_w(wstr1),debugstr_w(wstr2),len);
  66         return strncmpiW(wstr1, wstr2, len);
  67 }
  68
  69 /*************************************************************************
  70  * StrCatW                                      [SHLWAPI]
  71  */
  72 LPWSTR WINAPI StrCatW( LPWSTR wstr1, LPCWSTR wstr2 )
  73 {
  74     return strcatW( wstr1, wstr2 );
  75 }
  76
  77
  78 /*************************************************************************
  79  * StrCpyW                                      [SHLWAPI]
  80  */
  81 LPWSTR WINAPI StrCpyW( LPWSTR wstr1, LPCWSTR wstr2 )
  82 {
  83     return strcpyW( wstr1, wstr2 );
  84 }
  85
  86
  87 /*************************************************************************
  88  * StrStrA                                      [SHLWAPI]
  89  */
  90 LPSTR WINAPI StrStrA(LPCSTR lpFirst, LPCSTR lpSrch)
  91 {
  92     while (*lpFirst)
  93     {
  94         LPCSTR p1 = lpFirst, p2 = lpSrch;
  95         while (*p1 && *p2 && *p1 == *p2) { p1++; p2++; }
  96         if (!*p2) return (LPSTR)lpFirst;
  97         lpFirst++;
  98     }
  99     return NULL;
 100 }
 101
 102 /*************************************************************************
 103  * StrStrW                                      [SHLWAPI]
 104  */
 105 LPWSTR WINAPI StrStrW(LPCWSTR lpFirst, LPCWSTR lpSrch)
 106 {
 107     while (*lpFirst)
 108     {
 109         LPCWSTR p1 = lpFirst, p2 = lpSrch;
 110         while (*p1 && *p2 && *p1 == *p2) { p1++; p2++; }
 111         if (!*p2) return (LPWSTR)lpFirst;
 112         lpFirst++;
 113     }
 114     return NULL;
 115 }
 116
 117 /*************************************************************************
 118  * StrStrIA                                     [SHLWAPI]
 119  */
 120 LPSTR WINAPI StrStrIA(LPCSTR lpFirst, LPCSTR lpSrch)
 121 {
 122     while (*lpFirst)
 123     {
 124         LPCSTR p1 = lpFirst, p2 = lpSrch;
 125         while (*p1 && *p2 && toupper(*p1) == toupper(*p2)) { p1++; p2++; }
 126         if (!*p2) return (LPSTR)lpFirst;
 127         lpFirst++;
 128     }
 129     return NULL;
 130 }
 131
 132 /*************************************************************************
 133  * StrStrIW                                     [SHLWAPI]
 134  */
 135 LPWSTR WINAPI StrStrIW(LPCWSTR lpFirst, LPCWSTR lpSrch)
 136 {
 137     while (*lpFirst)
 138     {
 139         LPCWSTR p1 = lpFirst, p2 = lpSrch;
 140         while (*p1 && *p2 && toupperW(*p1) == toupperW(*p2)) { p1++; p2++; }
 141         if (!*p2) return (LPWSTR)lpFirst;
 142         lpFirst++;
 143     }
 144     return NULL;
 145 }
 146
 147 /*************************************************************************
 148  *      StrToIntA                       [SHLWAPI]
 149  */
 150 int WINAPI StrToIntA(LPCSTR lpSrc)
 151 {
 152         TRACE("%s\n", lpSrc);
 153         return atol(lpSrc);
 154 }
 155
 156 /*************************************************************************
 157  *      StrToIntW                       [SHLWAPI]
 158  */
 159 int WINAPI StrToIntW(LPCWSTR lpSrc)
 160 {
 161         int ret;
 162         LPSTR lpStr =  HEAP_strdupWtoA(GetProcessHeap(),0,lpSrc);
 163
 164         TRACE("%s\n", debugstr_w(lpSrc));
 165
 166         ret = atol(lpStr);
 167         HeapFree(GetProcessHeap(),0,lpStr);
 168         return ret;
 169 }
 170
 171 /*************************************************************************
 172  *      StrDupA                 [SHLWAPI]
 173  */
 174 LPSTR WINAPI StrDupA (LPCSTR lpSrc)
 175 {
 176         int len = strlen(lpSrc);
 177         LPSTR lpDest = (LPSTR) LocalAlloc(LMEM_FIXED, len+1);
 178
 179         TRACE("%s\n", lpSrc);
 180
 181         if (lpDest) strcpy(lpDest, lpSrc);
 182         return lpDest;
 183 }
 184
 185 /*************************************************************************
 186  *      StrDupW                 [SHLWAPI]
 187  */
 188 LPWSTR WINAPI StrDupW (LPCWSTR lpSrc)
 189 {
 190         int len = strlenW(lpSrc);
 191         LPWSTR lpDest = (LPWSTR) LocalAlloc(LMEM_FIXED, sizeof(WCHAR) * (len+1));
 192
 193         TRACE("%s\n", debugstr_w(lpSrc));
 194
 195         if (lpDest) strcpyW(lpDest, lpSrc);
 196         return lpDest;
 197 }
 198
 199 /*************************************************************************
 200  *      StrCSpnA                [SHLWAPI]
 201  */
 202 int WINAPI StrCSpnA (LPCSTR lpStr, LPCSTR lpSet)
 203 {
 204         int i,j, pos = strlen(lpStr);
 205
 206         TRACE("(%p %s  %p %s)\n",
 207            lpStr, debugstr_a(lpStr), lpSet, debugstr_a(lpSet));
 208
 209         for (i=0; i < strlen(lpSet) ; i++ )
 210         {
 211           for (j = 0; j < pos;j++)
 212           {
 213             if (lpStr[j] == lpSet[i])
 214             {
 215               pos = j;
 216             }
 217           }
 218         }
 219         TRACE("-- %u\n", pos);
 220         return pos;
 221 }
 222
 223 /*************************************************************************
 224  *      StrCSpnW                [SHLWAPI]
 225  */
 226 int WINAPI StrCSpnW (LPCWSTR lpStr, LPCWSTR lpSet)
 227 {
 228         int i,j, pos = strlenW(lpStr);
 229
 230         TRACE("(%p %s %p %s)\n",
 231            lpStr, debugstr_w(lpStr), lpSet, debugstr_w(lpSet));
 232
 233         for (i=0; i < strlenW(lpSet) ; i++ )
 234         {
 235           for (j = 0; j < pos;j++)
 236           {
 237             if (lpStr[j] == lpSet[i])
 238             {
 239               pos = j;
 240             }
 241           }
 242         }
 243         TRACE("-- %u\n", pos);
 244         return pos;
 245 }
 246
 247 /**************************************************************************
 248  * StrRChrA [SHLWAPI.@]
 249  *
 250  */
 251 LPSTR WINAPI StrRChrA( LPCSTR lpStart, LPCSTR lpEnd, WORD wMatch )
 252 {
 253     LPCSTR lpGotIt = NULL;
 254     BOOL dbcs = IsDBCSLeadByte( LOBYTE(wMatch) );
 255
 256     TRACE("(%p, %p, %x)\n", lpStart, lpEnd, wMatch);
 257
 258     if (!lpEnd) lpEnd = lpStart + strlen(lpStart);
 259
 260     for(; lpStart < lpEnd; lpStart = CharNextA(lpStart))
 261     {
 262         if (*lpStart != LOBYTE(wMatch)) continue;
 263         if (dbcs && lpStart[1] != HIBYTE(wMatch)) continue;
 264         lpGotIt = lpStart;
 265     }
 266     return (LPSTR)lpGotIt;
 267 }
 268
 269
 270 /**************************************************************************
 271  * StrRChrW [SHLWAPI.@]
 272  *
 273  */
 274 LPWSTR WINAPI StrRChrW( LPCWSTR lpStart, LPCWSTR lpEnd, WORD wMatch)
 275 {
 276     LPCWSTR lpGotIt = NULL;
 277
 278     TRACE("(%p, %p, %x)\n", lpStart, lpEnd, wMatch);
 279     if (!lpEnd) lpEnd = lpStart + strlenW(lpStart);
 280
 281     for(; lpStart < lpEnd; lpStart = CharNextW(lpStart))
 282         if (*lpStart == wMatch) lpGotIt = lpStart;
 283
 284     return (LPWSTR)lpGotIt;
 285 }
 286
 287
 288 /*************************************************************************
 289  *      StrCatBuffA             [SHLWAPI]
 290  *
 291  * Appends back onto front, stopping when front is size-1 characters long.
 292  * Returns front.
 293  *
 294  */
 295 LPSTR WINAPI StrCatBuffA(LPSTR front, LPCSTR back, INT size)
 296 {
 297     LPSTR dst = front + strlen(front);
 298     LPCSTR src = back, end = front + size - 1;
 299
 300     while(dst < end && *src)
 301         *dst++ = *src++;
 302     *dst = '\0';
 303     return front;
 304 }
 305
 306 /*************************************************************************
 307  *      StrCatBuffW             [SHLWAPI]
 308  *
 309  * Appends back onto front, stopping when front is size-1 characters long.
 310  * Returns front.
 311  *
 312  */
 313 LPWSTR WINAPI StrCatBuffW(LPWSTR front, LPCWSTR back, INT size)
 314 {
 315     LPWSTR dst = front + strlenW(front);
 316     LPCWSTR src = back, end = front + size - 1;
 317
 318     while(dst < end && *src)
 319         *dst++ = *src++;
 320     *dst = '\0';
 321     return front;
 322 }
 323
 324 /*************************************************************************
 325  * StrRetToBufA                                 [SHLWAPI.@]
 326  *
 327  * converts a STRRET to a normal string
 328  *
 329  * NOTES
 330  *  the pidl is for STRRET OFFSET
 331  */
 332 HRESULT WINAPI StrRetToBufA (LPSTRRET src, LPITEMIDLIST pidl, LPSTR dest, DWORD len)
 333 {
 334         TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
 335
 336         switch (src->uType)
 337         {
 338           case STRRET_WSTR:
 339             WideCharToMultiByte(CP_ACP, 0, src->u.pOleStr, -1, (LPSTR)dest, len, NULL, NULL);
 340 /*          SHFree(src->u.pOleStr);  FIXME: is this right? */
 341             break;
 342
 343           case STRRET_CSTRA:
 344             lstrcpynA((LPSTR)dest, src->u.cStr, len);
 345             break;
 346
 347           case STRRET_OFFSETA:
 348             lstrcpynA((LPSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
 349             break;
 350
 351           default:
 352             FIXME("unknown type!\n");
 353             if (len)
 354             {
 355               *(LPSTR)dest = '\0';
 356             }
 357             return(FALSE);
 358         }
 359         return S_OK;
 360 }
 361
 362 /*************************************************************************
 363  * StrRetToBufW                                 [SHLWAPI.@]
 364  *
 365  * converts a STRRET to a normal string
 366  *
 367  * NOTES
 368  *  the pidl is for STRRET OFFSET
 369  */
 370 HRESULT WINAPI StrRetToBufW (LPSTRRET src, LPITEMIDLIST pidl, LPWSTR dest, DWORD len)
 371 {
 372         TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
 373
 374         switch (src->uType)
 375         {
 376           case STRRET_WSTR:
 377             lstrcpynW((LPWSTR)dest, src->u.pOleStr, len);
 378 /*          SHFree(src->u.pOleStr);  FIXME: is this right? */
 379             break;
 380
 381           case STRRET_CSTRA:
 382             lstrcpynAtoW((LPWSTR)dest, src->u.cStr, len);
 383             break;
 384
 385           case STRRET_OFFSETA:
 386             if (pidl)
 387             {
 388               lstrcpynAtoW((LPWSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
 389             }
 390             break;
 391
 392           default:
 393             FIXME("unknown type!\n");
 394             if (len)
 395             { *(LPSTR)dest = '\0';
 396             }
 397             return(FALSE);
 398         }
 399         return S_OK;
 400 }
 401
 402 /*************************************************************************
 403  * StrFormatByteSizeA                           [SHLWAPI]
 404  */
 405 LPSTR WINAPI StrFormatByteSizeA ( DWORD dw, LPSTR pszBuf, UINT cchBuf )
 406 {       char buf[64];
 407         TRACE("%lx %p %i\n", dw, pszBuf, cchBuf);
 408         if ( dw<1024L )
 409         { sprintf (buf,"%3.1f bytes", (FLOAT)dw);
 410         }
 411         else if ( dw<1048576L)
 412         { sprintf (buf,"%3.1f KB", (FLOAT)dw/1024);
 413         }
 414         else if ( dw < 1073741824L)
 415         { sprintf (buf,"%3.1f MB", (FLOAT)dw/1048576L);
 416         }
 417         else
 418         { sprintf (buf,"%3.1f GB", (FLOAT)dw/1073741824L);
 419         }
 420         lstrcpynA (pszBuf, buf, cchBuf);
 421         return pszBuf;
 422 }
 423
 424 /*************************************************************************
 425  * StrFormatByteSizeW                           [SHLWAPI]
 426  */
 427 LPWSTR WINAPI StrFormatByteSizeW ( DWORD dw, LPWSTR pszBuf, UINT cchBuf )
 428 {       char buf[64];
 429         TRACE("%lx %p %i\n", dw, pszBuf, cchBuf);
 430         if ( dw<1024L )
 431         { sprintf (buf,"%3.1f bytes", (FLOAT)dw);
 432         }
 433         else if ( dw<1048576L)
 434         { sprintf (buf,"%3.1f KB", (FLOAT)dw/1024);
 435         }
 436         else if ( dw < 1073741824L)
 437         { sprintf (buf,"%3.1f MB", (FLOAT)dw/1048576L);
 438         }
 439         else
 440         { sprintf (buf,"%3.1f GB", (FLOAT)dw/1073741824L);
 441         }
 442         lstrcpynAtoW (pszBuf, buf, cchBuf);
 443         return pszBuf;
 444 }
 445
 446 /*************************************************************************
 447  *      wnsprintfA      [SHLWAPI]
 448  */
 449 int WINAPIV wnsprintfA(LPSTR lpOut, int cchLimitIn, LPCSTR lpFmt, ...)
 450 {
 451     va_list valist;
 452     INT res;
 453
 454     va_start( valist, lpFmt );
 455     res = wvsnprintfA( lpOut, cchLimitIn, lpFmt, valist );
 456     va_end( valist );
 457     return res;
 458 }
 459
 460 /*************************************************************************
 461  *      wnsprintfW      [SHLWAPI]
 462  */
 463 int WINAPIV wnsprintfW(LPWSTR lpOut, int cchLimitIn, LPCWSTR lpFmt, ...)
 464 {
 465     va_list valist;
 466     INT res;
 467
 468     va_start( valist, lpFmt );
 469     res = wvsnprintfW( lpOut, cchLimitIn, lpFmt, valist );
 470     va_end( valist );
 471     return res;
 472 }