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/debug.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(combase);
  27
  28 struct hstring_private
  29 {
  30     LPWSTR buffer;
  31     UINT32 length;
  32     BOOL   reference;
  33     LONG   refcount;
  34 };
  35
  36 static const WCHAR empty[1];
  37
  38 C_ASSERT(sizeof(struct hstring_private) <= sizeof(HSTRING_HEADER));
  39
  40 static inline struct hstring_private *impl_from_HSTRING(HSTRING string)
  41 {
  42    return (struct hstring_private *)string;
  43 }
  44
  45 static inline struct hstring_private *impl_from_HSTRING_HEADER(HSTRING_HEADER *header)
  46 {
  47    return (struct hstring_private *)header;
  48 }
  49
  50 static inline struct hstring_private *impl_from_HSTRING_BUFFER(HSTRING_BUFFER buffer)
  51 {
  52    return (struct hstring_private *)buffer;
  53 }
  54
  55 static BOOL alloc_string(UINT32 len, HSTRING *out)
  56 {
  57     struct hstring_private *priv;
  58     priv = HeapAlloc(GetProcessHeap(), 0, sizeof(*priv) + (len + 1) * sizeof(*priv->buffer));
  59     if (!priv)
  60         return FALSE;
  61     priv->buffer = (LPWSTR)(priv + 1);
  62     priv->length = len;
  63     priv->reference = FALSE;
  64     priv->refcount = 1;
  65     priv->buffer[len] = '\0';
  66     *out = (HSTRING)priv;
  67     return TRUE;
  68 }
  69
  70 /***********************************************************************
  71  *      WindowsCreateString (combase.@)
  72  */
  73 HRESULT WINAPI WindowsCreateString(LPCWSTR ptr, UINT32 len,
  74                                    HSTRING *out)
  75 {
  76     struct hstring_private *priv;
  77     if (out == NULL)
  78         return E_INVALIDARG;
  79     if (ptr == NULL && len > 0)
  80         return E_POINTER;
  81     if (len == 0)
  82     {
  83         *out = NULL;
  84         return S_OK;
  85     }
  86     if (!alloc_string(len, out))
  87         return E_OUTOFMEMORY;
  88     priv = impl_from_HSTRING(*out);
  89     memcpy(priv->buffer, ptr, len * sizeof(*priv->buffer));
  90     return S_OK;
  91 }
  92
  93 /***********************************************************************
  94  *      WindowsCreateStringReference (combase.@)
  95  */
  96 HRESULT WINAPI WindowsCreateStringReference(LPCWSTR ptr, UINT32 len,
  97                                             HSTRING_HEADER *header, HSTRING *out)
  98 {
  99     struct hstring_private *priv = impl_from_HSTRING_HEADER(header);
 100     if (out == NULL || header == NULL)
 101         return E_INVALIDARG;
 102     if (ptr == NULL && len > 0)
 103         return E_POINTER;
 104     if (ptr[len] != '\0')
 105         return E_INVALIDARG;
 106     if (len == 0)
 107     {
 108         *out = NULL;
 109         return S_OK;
 110     }
 111     priv->buffer = (LPWSTR)ptr;
 112     priv->length = len;
 113     priv->reference = TRUE;
 114     *out = (HSTRING)header;
 115     return S_OK;
 116 }
 117
 118 /***********************************************************************
 119  *      WindowsDeleteString (combase.@)
 120  */
 121 HRESULT WINAPI WindowsDeleteString(HSTRING str)
 122 {
 123     struct hstring_private *priv = impl_from_HSTRING(str);
 124     if (str == NULL)
 125         return S_OK;
 126     if (priv->reference)
 127         return S_OK;
 128     if (InterlockedDecrement(&priv->refcount) == 0)
 129         HeapFree(GetProcessHeap(), 0, priv);
 130     return S_OK;
 131 }
 132
 133 /***********************************************************************
 134  *      WindowsDuplicateString (combase.@)
 135  */
 136 HRESULT WINAPI WindowsDuplicateString(HSTRING str, HSTRING *out)
 137 {
 138     struct hstring_private *priv = impl_from_HSTRING(str);
 139     if (out == NULL)
 140         return E_INVALIDARG;
 141     if (str == NULL)
 142     {
 143         *out = NULL;
 144         return S_OK;
 145     }
 146     if (priv->reference)
 147         return WindowsCreateString(priv->buffer, priv->length, out);
 148     InterlockedIncrement(&priv->refcount);
 149     *out = str;
 150     return S_OK;
 151 }
 152
 153 /***********************************************************************
 154  *      WindowsPreallocateStringBuffer (combase.@)
 155  */
 156 HRESULT WINAPI WindowsPreallocateStringBuffer(UINT32 len, WCHAR **outptr,
 157                                               HSTRING_BUFFER *out)
 158 {
 159     struct hstring_private *priv;
 160     HSTRING str;
 161     if (outptr == NULL || out == NULL)
 162         return E_POINTER;
 163     if (len == 0)
 164     {
 165         *outptr = (LPWSTR)empty;
 166         *out = NULL;
 167         return S_OK;
 168     }
 169
 170     if (!alloc_string(len, &str))
 171         return E_OUTOFMEMORY;
 172     priv = impl_from_HSTRING(str);
 173     *outptr = priv->buffer;
 174     *out = (HSTRING_BUFFER)str;
 175     return S_OK;
 176 }
 177
 178 /***********************************************************************
 179  *      WindowsDeleteStringBuffer (combase.@)
 180  */
 181 HRESULT WINAPI WindowsDeleteStringBuffer(HSTRING_BUFFER buf)
 182 {
 183     return WindowsDeleteString((HSTRING)buf);
 184 }
 185
 186 /***********************************************************************
 187  *      WindowsPromoteStringBuffer (combase.@)
 188  */
 189 HRESULT WINAPI WindowsPromoteStringBuffer(HSTRING_BUFFER buf, HSTRING *out)
 190 {
 191     struct hstring_private *priv = impl_from_HSTRING_BUFFER(buf);
 192     if (out == NULL)
 193         return E_POINTER;
 194     if (buf == NULL)
 195     {
 196         *out = NULL;
 197         return S_OK;
 198     }
 199     if (priv->buffer[priv->length] != 0 || priv->reference || priv->refcount != 1)
 200         return E_INVALIDARG;
 201     *out = (HSTRING)buf;
 202     return S_OK;
 203 }
 204
 205 /***********************************************************************
 206  *      WindowsGetStringLen (combase.@)
 207  */
 208 UINT32 WINAPI WindowsGetStringLen(HSTRING str)
 209 {
 210     struct hstring_private *priv = impl_from_HSTRING(str);
 211     if (str == NULL)
 212         return 0;
 213     return priv->length;
 214 }
 215
 216 /***********************************************************************
 217  *      WindowsGetStringRawBuffer (combase.@)
 218  */
 219 LPCWSTR WINAPI WindowsGetStringRawBuffer(HSTRING str, UINT32 *len)
 220 {
 221     struct hstring_private *priv = impl_from_HSTRING(str);
 222     if (str == NULL)
 223     {
 224         if (len)
 225             *len = 0;
 226         return empty;
 227     }
 228     if (len)
 229         *len = priv->length;
 230     return priv->buffer;
 231 }
 232
 233 /***********************************************************************
 234  *      WindowsStringHasEmbeddedNull (combase.@)
 235  */
 236 HRESULT WINAPI WindowsStringHasEmbeddedNull(HSTRING str, BOOL *out)
 237 {
 238     UINT32 i;
 239     struct hstring_private *priv = impl_from_HSTRING(str);
 240     if (out == NULL)
 241         return E_INVALIDARG;
 242     if (str == NULL)
 243     {
 244         *out = FALSE;
 245         return S_OK;
 246     }
 247     for (i = 0; i < priv->length; i++)
 248     {
 249         if (priv->buffer[i] == '\0')
 250         {
 251             *out = TRUE;
 252             return S_OK;
 253         }
 254     }
 255     *out = FALSE;
 256     return S_OK;
 257 }
 258
 259 /***********************************************************************
 260  *      WindowsIsStringEmpty (combase.@)
 261  */
 262 BOOL WINAPI WindowsIsStringEmpty(HSTRING str)
 263 {
 264     struct hstring_private *priv = impl_from_HSTRING(str);
 265     if (str == NULL)
 266         return TRUE;
 267     return priv->length == 0;
 268 }