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