git.oblomov.eu Git - wine/blob - dlls/shell32/shellstring.c

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