dlls/combase/string.c

   1 /*
   2  * Copyright 2014 Martin Storsjo
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <string.h>
  20
  21 #include "windows.h"
  22 #include "winerror.h"
  23 #include "hstring.h"
  24 #include "wine/unicode.h"
  25 #include "wine/debug.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(winstring);
  28
  29 struct hstring_private
  30 {
  31     LPWSTR buffer;
  32     UINT32 length;
  33     BOOL   reference;
  34     LONG   refcount;
  35 };
  36
  37 static const WCHAR empty[1];
  38
  39 C_ASSERT(sizeof(struct hstring_private) <= sizeof(HSTRING_HEADER));
  40
  41 static inline struct hstring_private *impl_from_HSTRING(HSTRING string)
  42 {
  43    return (struct hstring_private *)string;
  44 }
  45
  46 static inline struct hstring_private *impl_from_HSTRING_HEADER(HSTRING_HEADER *header)
  47 {
  48    return (struct hstring_private *)header;
  49 }
  50
  51 static inline struct hstring_private *impl_from_HSTRING_BUFFER(HSTRING_BUFFER buffer)
  52 {
  53    return (struct hstring_private *)buffer;
  54 }
  55
  56 static BOOL alloc_string(UINT32 len, HSTRING *out)
  57 {
  58     struct hstring_private *priv;
  59     priv = HeapAlloc(GetProcessHeap(), 0, sizeof(*priv) + (len + 1) * sizeof(*priv->buffer));
  60     if (!priv)
  61         return FALSE;
  62     priv->buffer = (LPWSTR)(priv + 1);
  63     priv->length = len;
  64     priv->reference = FALSE;
  65     priv->refcount = 1;
  66     priv->buffer[len] = '\0';
  67     *out = (HSTRING)priv;
  68     return TRUE;
  69 }
  70
  71 /***********************************************************************
  72  *      WindowsCreateString (combase.@)
  73  */
  74 HRESULT WINAPI WindowsCreateString(LPCWSTR ptr, UINT32 len,
  75                                    HSTRING *out)
  76 {
  77     struct hstring_private *priv;
  78
  79     TRACE("(%s, %u, %p)\n", debugstr_wn(ptr, len), len, out);
  80
  81     if (out == NULL)
  82         return E_INVALIDARG;
  83     if (len == 0)
  84     {
  85         *out = NULL;
  86         return S_OK;
  87     }
  88     if (ptr == NULL)
  89         return E_POINTER;
  90     if (!alloc_string(len, out))
  91         return E_OUTOFMEMORY;
  92     priv = impl_from_HSTRING(*out);
  93     memcpy(priv->buffer, ptr, len * sizeof(*priv->buffer));
  94     return S_OK;
  95 }
  96
  97 /***********************************************************************
  98  *      WindowsCreateStringReference (combase.@)
  99  */
 100 HRESULT WINAPI WindowsCreateStringReference(LPCWSTR ptr, UINT32 len,
 101                                             HSTRING_HEADER *header, HSTRING *out)
 102 {
 103     struct hstring_private *priv = impl_from_HSTRING_HEADER(header);
 104
 105     TRACE("(%s, %u, %p, %p)\n", debugstr_wn(ptr, len), len, header, out);
 106
 107     if (out == NULL || header == NULL)
 108         return E_INVALIDARG;
 109     if (ptr != NULL && ptr[len] != '\0')
 110         return E_INVALIDARG;
 111     if (len == 0)
 112     {
 113         *out = NULL;
 114         return S_OK;
 115     }
 116     if (ptr == NULL)
 117         return E_POINTER;
 118     priv->buffer = (LPWSTR)ptr;
 119     priv->length = len;
 120     priv->reference = TRUE;
 121     *out = (HSTRING)header;
 122     return S_OK;
 123 }
 124
 125 /***********************************************************************
 126  *      WindowsDeleteString (combase.@)
 127  */
 128 HRESULT WINAPI WindowsDeleteString(HSTRING str)
 129 {
 130     struct hstring_private *priv = impl_from_HSTRING(str);
 131
 132     TRACE("(%p)\n", str);
 133
 134     if (str == NULL)
 135         return S_OK;
 136     if (priv->reference)
 137         return S_OK;
 138     if (InterlockedDecrement(&priv->refcount) == 0)
 139         HeapFree(GetProcessHeap(), 0, priv);
 140     return S_OK;
 141 }
 142
 143 /***********************************************************************
 144  *      WindowsDuplicateString (combase.@)
 145  */
 146 HRESULT WINAPI WindowsDuplicateString(HSTRING str, HSTRING *out)
 147 {
 148     struct hstring_private *priv = impl_from_HSTRING(str);
 149
 150     TRACE("(%p, %p)\n", str, out);
 151
 152     if (out == NULL)
 153         return E_INVALIDARG;
 154     if (str == NULL)
 155     {
 156         *out = NULL;
 157         return S_OK;
 158     }
 159     if (priv->reference)
 160         return WindowsCreateString(priv->buffer, priv->length, out);
 161     InterlockedIncrement(&priv->refcount);
 162     *out = str;
 163     return S_OK;
 164 }
 165
 166 /***********************************************************************
 167  *      WindowsPreallocateStringBuffer (combase.@)
 168  */
 169 HRESULT WINAPI WindowsPreallocateStringBuffer(UINT32 len, WCHAR **outptr,
 170                                               HSTRING_BUFFER *out)
 171 {
 172     struct hstring_private *priv;
 173     HSTRING str;
 174
 175     TRACE("(%u, %p, %p)\n", len, outptr, out);
 176
 177     if (outptr == NULL || out == NULL)
 178         return E_POINTER;
 179     if (len == 0)
 180     {
 181         *outptr = (LPWSTR)empty;
 182         *out = NULL;
 183         return S_OK;
 184     }
 185
 186     if (!alloc_string(len, &str))
 187         return E_OUTOFMEMORY;
 188     priv = impl_from_HSTRING(str);
 189     *outptr = priv->buffer;
 190     *out = (HSTRING_BUFFER)str;
 191     return S_OK;
 192 }
 193
 194 /***********************************************************************
 195  *      WindowsDeleteStringBuffer (combase.@)
 196  */
 197 HRESULT WINAPI WindowsDeleteStringBuffer(HSTRING_BUFFER buf)
 198 {
 199     TRACE("(%p)\n", buf);
 200
 201     return WindowsDeleteString((HSTRING)buf);
 202 }
 203
 204 /***********************************************************************
 205  *      WindowsPromoteStringBuffer (combase.@)
 206  */
 207 HRESULT WINAPI WindowsPromoteStringBuffer(HSTRING_BUFFER buf, HSTRING *out)
 208 {
 209     struct hstring_private *priv = impl_from_HSTRING_BUFFER(buf);
 210
 211     TRACE("(%p, %p)\n", buf, out);
 212
 213     if (out == NULL)
 214         return E_POINTER;
 215     if (buf == NULL)
 216     {
 217         *out = NULL;
 218         return S_OK;
 219     }
 220     if (priv->buffer[priv->length] != 0 || priv->reference || priv->refcount != 1)
 221         return E_INVALIDARG;
 222     *out = (HSTRING)buf;
 223     return S_OK;
 224 }
 225
 226 /***********************************************************************
 227  *      WindowsGetStringLen (combase.@)
 228  */
 229 UINT32 WINAPI WindowsGetStringLen(HSTRING str)
 230 {
 231     struct hstring_private *priv = impl_from_HSTRING(str);
 232
 233     TRACE("(%p)\n", str);
 234
 235     if (str == NULL)
 236         return 0;
 237     return priv->length;
 238 }
 239
 240 /***********************************************************************
 241  *      WindowsGetStringRawBuffer (combase.@)
 242  */
 243 LPCWSTR WINAPI WindowsGetStringRawBuffer(HSTRING str, UINT32 *len)
 244 {
 245     struct hstring_private *priv = impl_from_HSTRING(str);
 246
 247     TRACE("(%p, %p)\n", str, len);
 248
 249     if (str == NULL)
 250     {
 251         if (len)
 252             *len = 0;
 253         return empty;
 254     }
 255     if (len)
 256         *len = priv->length;
 257     return priv->buffer;
 258 }
 259
 260 /***********************************************************************
 261  *      WindowsStringHasEmbeddedNull (combase.@)
 262  */
 263 HRESULT WINAPI WindowsStringHasEmbeddedNull(HSTRING str, BOOL *out)
 264 {
 265     UINT32 i;
 266     struct hstring_private *priv = impl_from_HSTRING(str);
 267
 268     TRACE("(%p, %p)\n", str, out);
 269
 270     if (out == NULL)
 271         return E_INVALIDARG;
 272     if (str == NULL)
 273     {
 274         *out = FALSE;
 275         return S_OK;
 276     }
 277     for (i = 0; i < priv->length; i++)
 278     {
 279         if (priv->buffer[i] == '\0')
 280         {
 281             *out = TRUE;
 282             return S_OK;
 283         }
 284     }
 285     *out = FALSE;
 286     return S_OK;
 287 }
 288
 289 /***********************************************************************
 290  *      WindowsSubstring (combase.@)
 291  */
 292 HRESULT WINAPI WindowsSubstring(HSTRING str, UINT32 start, HSTRING *out)
 293 {
 294     struct hstring_private *priv = impl_from_HSTRING(str);
 295     UINT32 len = WindowsGetStringLen(str);
 296
 297     TRACE("(%p, %u, %p)\n", str, start, out);
 298
 299     if (out == NULL)
 300         return E_INVALIDARG;
 301     if (start > len)
 302         return E_BOUNDS;
 303     if (start == len)
 304     {
 305         *out = NULL;
 306         return S_OK;
 307     }
 308     return WindowsCreateString(&priv->buffer[start], len - start, out);
 309 }
 310
 311 /***********************************************************************
 312  *      WindowsSubstringWithSpecifiedLength (combase.@)
 313  */
 314 HRESULT WINAPI WindowsSubstringWithSpecifiedLength(HSTRING str, UINT32 start, UINT32 len, HSTRING *out)
 315 {
 316     struct hstring_private *priv = impl_from_HSTRING(str);
 317
 318     TRACE("(%p, %u, %u, %p)\n", str, start, len, out);
 319
 320     if (out == NULL)
 321         return E_INVALIDARG;
 322     if (start + len < start ||
 323         start + len > WindowsGetStringLen(str))
 324         return E_BOUNDS;
 325     if (len == 0)
 326     {
 327         *out = NULL;
 328         return S_OK;
 329     }
 330     return WindowsCreateString(&priv->buffer[start], len, out);
 331 }
 332
 333 /***********************************************************************
 334  *      WindowsConcatString (combase.@)
 335  */
 336 HRESULT WINAPI WindowsConcatString(HSTRING str1, HSTRING str2, HSTRING *out)
 337 {
 338     struct hstring_private *priv1 = impl_from_HSTRING(str1);
 339     struct hstring_private *priv2 = impl_from_HSTRING(str2);
 340     struct hstring_private *priv;
 341
 342     TRACE("(%p, %p, %p)\n", str1, str2, out);
 343
 344     if (out == NULL)
 345         return E_INVALIDARG;
 346     if (str1 == NULL)
 347         return WindowsDuplicateString(str2, out);
 348     if (str2 == NULL)
 349         return WindowsDuplicateString(str1, out);
 350     if (!priv1->length && !priv2->length)
 351     {
 352         *out = NULL;
 353         return S_OK;
 354     }
 355     if (!alloc_string(priv1->length + priv2->length, out))
 356         return E_OUTOFMEMORY;
 357     priv = impl_from_HSTRING(*out);
 358     memcpy(priv->buffer, priv1->buffer, priv1->length * sizeof(*priv1->buffer));
 359     memcpy(priv->buffer + priv1->length, priv2->buffer, priv2->length * sizeof(*priv2->buffer));
 360     return S_OK;
 361 }
 362
 363 /***********************************************************************
 364  *      WindowsIsStringEmpty (combase.@)
 365  */
 366 BOOL WINAPI WindowsIsStringEmpty(HSTRING str)
 367 {
 368     struct hstring_private *priv = impl_from_HSTRING(str);
 369
 370     TRACE("(%p)\n", str);
 371
 372     if (str == NULL)
 373         return TRUE;
 374     return priv->length == 0;
 375 }
 376
 377 /***********************************************************************
 378  *      WindowsCompareStringOrdinal (combase.@)
 379  */
 380 HRESULT WINAPI WindowsCompareStringOrdinal(HSTRING str1, HSTRING str2, INT32 *res)
 381 {
 382     struct hstring_private *priv1 = impl_from_HSTRING(str1);
 383     struct hstring_private *priv2 = impl_from_HSTRING(str2);
 384     const WCHAR *buf1 = empty, *buf2 = empty;
 385     UINT32 len1 = 0, len2 = 0;
 386
 387     TRACE("(%p, %p, %p)\n", str1, str2, res);
 388
 389     if (res == NULL)
 390         return E_INVALIDARG;
 391     if (str1 == str2)
 392     {
 393         *res = 0;
 394         return S_OK;
 395     }
 396     if (str1)
 397     {
 398         buf1 = priv1->buffer;
 399         len1 = priv1->length;
 400     }
 401     if (str2)
 402     {
 403         buf2 = priv2->buffer;
 404         len2 = priv2->length;
 405     }
 406     *res = CompareStringOrdinal(buf1, len1, buf2, len2, FALSE) - CSTR_EQUAL;
 407     return S_OK;
 408 }
 409
 410 /***********************************************************************
 411  *      WindowsTrimStringStart (combase.@)
 412  */
 413 HRESULT WINAPI WindowsTrimStringStart(HSTRING str1, HSTRING str2, HSTRING *out)
 414 {
 415     struct hstring_private *priv1 = impl_from_HSTRING(str1);
 416     struct hstring_private *priv2 = impl_from_HSTRING(str2);
 417     UINT32 start;
 418
 419     TRACE("(%p, %p, %p)\n", str1, str2, out);
 420
 421     if (!out || !str2 || !priv2->length)
 422         return E_INVALIDARG;
 423     if (!str1)
 424     {
 425         *out = NULL;
 426         return S_OK;
 427     }
 428     for (start = 0; start < priv1->length; start++)
 429     {
 430         if (!memchrW(priv2->buffer, priv1->buffer[start], priv2->length))
 431             break;
 432     }
 433     return start ? WindowsCreateString(&priv1->buffer[start], priv1->length - start, out) :
 434                    WindowsDuplicateString(str1, out);
 435 }
 436
 437 /***********************************************************************
 438  *      WindowsTrimStringEnd (combase.@)
 439  */
 440 HRESULT WINAPI WindowsTrimStringEnd(HSTRING str1, HSTRING str2, HSTRING *out)
 441 {
 442     struct hstring_private *priv1 = impl_from_HSTRING(str1);
 443     struct hstring_private *priv2 = impl_from_HSTRING(str2);
 444     UINT32 len;
 445
 446     TRACE("(%p, %p, %p)\n", str1, str2, out);
 447
 448     if (!out || !str2 || !priv2->length)
 449         return E_INVALIDARG;
 450     if (!str1)
 451     {
 452         *out = NULL;
 453         return S_OK;
 454     }
 455     for (len = priv1->length; len > 0; len--)
 456     {
 457         if (!memchrW(priv2->buffer, priv1->buffer[len - 1], priv2->length))
 458             break;
 459     }
 460     return (len < priv1->length) ? WindowsCreateString(priv1->buffer, len, out) :
 461                                    WindowsDuplicateString(str1, out);
 462 }