dlls/vbscript/utils.c

   1 /*
   2  * Copyright 2017 Piotr Caban for CodeWeavers
   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 "vbscript.h"
  20
  21 #include "wine/debug.h"
  22
  23 WINE_DEFAULT_DEBUG_CHANNEL(vbscript);
  24
  25 typedef struct {
  26     IEnumVARIANT IEnumVARIANT_iface;
  27
  28     LONG ref;
  29
  30     SAFEARRAY *sa;
  31     BOOL owned;
  32     ULONG i, size;
  33 } safearray_iter;
  34
  35 static inline safearray_iter *impl_from_IEnumVARIANT(IEnumVARIANT *iface)
  36 {
  37     return CONTAINING_RECORD(iface, safearray_iter, IEnumVARIANT_iface);
  38 }
  39
  40 static HRESULT WINAPI safearray_iter_IEnumVARIANT_QueryInterface(
  41         IEnumVARIANT *iface, REFIID riid, void **ppv)
  42 {
  43     safearray_iter *This = impl_from_IEnumVARIANT(iface);
  44
  45     if(IsEqualGUID(riid, &IID_IUnknown)) {
  46         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
  47         *ppv = &This->IEnumVARIANT_iface;
  48     }else if(IsEqualGUID(riid, &IID_IEnumVARIANT)) {
  49         TRACE("(%p)->(IID_IEnumVARIANT %p)\n", This, ppv);
  50         *ppv = &This->IEnumVARIANT_iface;
  51     }else {
  52         FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
  53         *ppv = NULL;
  54         return E_NOINTERFACE;
  55     }
  56
  57     IUnknown_AddRef((IUnknown*)*ppv);
  58     return S_OK;
  59 }
  60
  61 static ULONG WINAPI safearray_iter_IEnumVARIANT_AddRef(IEnumVARIANT *iface)
  62 {
  63     safearray_iter *This = impl_from_IEnumVARIANT(iface);
  64     LONG ref = InterlockedIncrement(&This->ref);
  65
  66     TRACE("(%p) ref=%ld\n", This, ref);
  67
  68     return ref;
  69 }
  70
  71 static ULONG WINAPI safearray_iter_IEnumVARIANT_Release(IEnumVARIANT *iface)
  72 {
  73     safearray_iter *This = impl_from_IEnumVARIANT(iface);
  74     LONG ref = InterlockedDecrement(&This->ref);
  75
  76     TRACE("(%p) ref=%ld\n", iface, ref);
  77
  78     if(!ref) {
  79         if(This->sa) {
  80             SafeArrayUnlock(This->sa);
  81             if(This->owned)
  82                 SafeArrayDestroy(This->sa);
  83         }
  84         free(This);
  85     }
  86
  87     return ref;
  88 }
  89
  90 static HRESULT WINAPI safearray_iter_IEnumVARIANT_Next(IEnumVARIANT *iface,
  91         ULONG celt, VARIANT *rgVar, ULONG *pCeltFetched)
  92 {
  93     safearray_iter *This = impl_from_IEnumVARIANT(iface);
  94     HRESULT hres;
  95     VARIANT *v;
  96
  97     TRACE("(%p)->(%lu %p %p)\n", This, celt, rgVar, pCeltFetched);
  98
  99     if(celt != 1) {
 100         FIXME("celt != 1\n");
 101         return E_NOTIMPL;
 102     }
 103
 104     if(This->i >= This->size) {
 105         if(pCeltFetched)
 106             *pCeltFetched = 0;
 107         return S_FALSE;
 108     }
 109
 110     if(!This->sa->cLocks)
 111         ERR("SAFEARRAY not locked\n");
 112
 113     v = (VARIANT*)(((BYTE*)This->sa->pvData) + This->i * This->sa->cbElements);
 114     V_VT(rgVar) = VT_EMPTY;
 115     hres = VariantCopy(rgVar, v);
 116     if(FAILED(hres))
 117         return hres;
 118
 119     This->i++;
 120     if(pCeltFetched)
 121         *pCeltFetched = 1;
 122     return S_OK;
 123 }
 124
 125 static HRESULT WINAPI safearray_iter_IEnumVARIANT_Skip(IEnumVARIANT *iface, ULONG celt)
 126 {
 127     FIXME("\n");
 128     return E_NOTIMPL;
 129 }
 130
 131 static HRESULT WINAPI safearray_iter_IEnumVARIANT_Reset(IEnumVARIANT *iface)
 132 {
 133     FIXME("\n");
 134     return E_NOTIMPL;
 135 }
 136
 137 static HRESULT WINAPI safearray_iter_IEnumVARIANT_Clone(
 138         IEnumVARIANT *iface, IEnumVARIANT **ppEnum)
 139 {
 140     FIXME("\n");
 141     return E_NOTIMPL;
 142 }
 143
 144 static const IEnumVARIANTVtbl safearray_iter_EnumVARIANTVtbl = {
 145     safearray_iter_IEnumVARIANT_QueryInterface,
 146     safearray_iter_IEnumVARIANT_AddRef,
 147     safearray_iter_IEnumVARIANT_Release,
 148     safearray_iter_IEnumVARIANT_Next,
 149     safearray_iter_IEnumVARIANT_Skip,
 150     safearray_iter_IEnumVARIANT_Reset,
 151     safearray_iter_IEnumVARIANT_Clone
 152 };
 153
 154 static ULONG get_safearray_size(SAFEARRAY *sa)
 155 {
 156     ULONG ret = 1;
 157     USHORT i;
 158
 159     if(!sa)
 160         return 0;
 161
 162     for(i=0; i<sa->cDims && ret; i++)
 163         ret *= sa->rgsabound[i].cElements;
 164     return ret;
 165 }
 166
 167 HRESULT create_safearray_iter(SAFEARRAY *sa, BOOL owned, IEnumVARIANT **ev)
 168 {
 169     safearray_iter *iter;
 170     HRESULT hres;
 171
 172     if(sa && !(sa->fFeatures & FADF_VARIANT)) {
 173         FIXME("enumeration not supported: %x\n", sa->fFeatures);
 174         return E_NOTIMPL;
 175     }
 176
 177     iter = malloc(sizeof(*iter));
 178     if(!iter)
 179         return E_OUTOFMEMORY;
 180
 181     if(sa) {
 182         hres = SafeArrayLock(sa);
 183         if(FAILED(hres)) {
 184             free(iter);
 185             return hres;
 186         }
 187     }
 188
 189     iter->IEnumVARIANT_iface.lpVtbl = &safearray_iter_EnumVARIANTVtbl;
 190     iter->ref = 1;
 191     iter->sa = sa;
 192     iter->owned = owned;
 193     iter->i = 0;
 194     iter->size = get_safearray_size(sa);
 195
 196     *ev = &iter->IEnumVARIANT_iface;
 197     return S_OK;
 198 }