dlls/scrrun/dictionary.c

   1 /*
   2  * Copyright (C) 2012 Alistair Leslie-Hughes
   3  * Copyright 2015 Nikolay Sivov for CodeWeavers
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19 #define COBJMACROS
  20
  21 #include <stdarg.h>
  22 #include <math.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "ole2.h"
  27 #include "olectl.h"
  28 #include "dispex.h"
  29 #include "scrrun.h"
  30 #include "scrrun_private.h"
  31
  32 #include "wine/debug.h"
  33 #include "wine/list.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(scrrun);
  36
  37 #define BUCKET_COUNT  509
  38 #define DICT_HASH_MOD 1201
  39
  40 /* Implementation details
  41
  42    Dictionary contains one list that links all pairs, this way
  43    order in which they were added is preserved. Each bucket has
  44    its own list to hold all pairs in this bucket. Initially all
  45    bucket lists are zeroed and we init them once we about to add
  46    first pair.
  47
  48    When pair is removed it's unlinked from both lists; if it was
  49    a last pair in a bucket list it stays empty in initialized state.
  50
  51    Preserving pair order is important for enumeration, so far testing
  52    indicates that pairs are not reordered basing on hash value.
  53  */
  54
  55 struct keyitem_pair
  56 {
  57     struct  list entry;
  58     struct  list bucket;
  59     DWORD   hash;
  60     VARIANT key;
  61     VARIANT item;
  62 };
  63
  64 struct dictionary
  65 {
  66     struct provideclassinfo classinfo;
  67     IDictionary IDictionary_iface;
  68     LONG ref;
  69
  70     CompareMethod method;
  71     LONG count;
  72     struct list pairs;
  73     struct list buckets[BUCKET_COUNT];
  74     struct list notifier;
  75 };
  76
  77 struct dictionary_enum
  78 {
  79     IEnumVARIANT IEnumVARIANT_iface;
  80     LONG ref;
  81
  82     struct dictionary *dict;
  83     struct list *cur;
  84     struct list notify;
  85 };
  86
  87 static inline struct dictionary *impl_from_IDictionary(IDictionary *iface)
  88 {
  89     return CONTAINING_RECORD(iface, struct dictionary, IDictionary_iface);
  90 }
  91
  92 static inline struct dictionary_enum *impl_from_IEnumVARIANT(IEnumVARIANT *iface)
  93 {
  94     return CONTAINING_RECORD(iface, struct dictionary_enum, IEnumVARIANT_iface);
  95 }
  96
  97 static inline struct list *get_bucket_head(struct dictionary *dict, DWORD hash)
  98 {
  99     return &dict->buckets[hash % BUCKET_COUNT];
 100 }
 101
 102 static inline BOOL is_string_key(const VARIANT *key)
 103 {
 104     return V_VT(key) == VT_BSTR || V_VT(key) == (VT_BSTR|VT_BYREF);
 105 }
 106
 107 /* Only for VT_BSTR or VT_BSTR|VT_BYREF types */
 108 static inline WCHAR *get_key_strptr(const VARIANT *key)
 109 {
 110     if (V_VT(key) == VT_BSTR)
 111         return V_BSTR(key);
 112
 113     if (V_BSTRREF(key))
 114         return *V_BSTRREF(key);
 115
 116     return NULL;
 117 }
 118
 119 /* should be used only when both keys are of string type, it's not checked */
 120 static inline int strcmp_key(const struct dictionary *dict, const VARIANT *key1, const VARIANT *key2)
 121 {
 122     const WCHAR *str1, *str2;
 123
 124     str1 = get_key_strptr(key1);
 125     str2 = get_key_strptr(key2);
 126     return dict->method == BinaryCompare ? wcscmp(str1, str2) : wcsicmp(str1, str2);
 127 }
 128
 129 static BOOL is_matching_key(const struct dictionary *dict, const struct keyitem_pair *pair, const VARIANT *key, DWORD hash)
 130 {
 131     if (is_string_key(key) && is_string_key(&pair->key)) {
 132         if (hash != pair->hash)
 133             return FALSE;
 134
 135         return strcmp_key(dict, key, &pair->key) == 0;
 136     }
 137
 138     if ((is_string_key(key) && !is_string_key(&pair->key)) ||
 139         (!is_string_key(key) && is_string_key(&pair->key)))
 140         return FALSE;
 141
 142     /* for numeric keys only check hash */
 143     return hash == pair->hash;
 144 }
 145
 146 static struct keyitem_pair *get_keyitem_pair(struct dictionary *dict, VARIANT *key)
 147 {
 148     struct keyitem_pair *pair;
 149     struct list *head, *entry;
 150     VARIANT hash;
 151     HRESULT hr;
 152
 153     hr = IDictionary_get_HashVal(&dict->IDictionary_iface, key, &hash);
 154     if (FAILED(hr))
 155         return NULL;
 156
 157     head = get_bucket_head(dict, V_I4(&hash));
 158     if (!head->next || list_empty(head))
 159         return NULL;
 160
 161     entry = list_head(head);
 162     do {
 163         pair = LIST_ENTRY(entry, struct keyitem_pair, bucket);
 164         if (is_matching_key(dict, pair, key, V_I4(&hash))) return pair;
 165     } while ((entry = list_next(head, entry)));
 166
 167     return NULL;
 168 }
 169
 170 static HRESULT add_keyitem_pair(struct dictionary *dict, VARIANT *key, VARIANT *item)
 171 {
 172     struct keyitem_pair *pair;
 173     struct list *head;
 174     VARIANT hash;
 175     HRESULT hr;
 176
 177     hr = IDictionary_get_HashVal(&dict->IDictionary_iface, key, &hash);
 178     if (FAILED(hr))
 179         return hr;
 180
 181     if (!(pair = malloc(sizeof(*pair))))
 182         return E_OUTOFMEMORY;
 183
 184     pair->hash = V_I4(&hash);
 185     VariantInit(&pair->key);
 186     VariantInit(&pair->item);
 187
 188     hr = VariantCopyInd(&pair->key, key);
 189     if (FAILED(hr))
 190         goto failed;
 191
 192     hr = VariantCopyInd(&pair->item, item);
 193     if (FAILED(hr))
 194         goto failed;
 195
 196     head = get_bucket_head(dict, pair->hash);
 197     if (!head->next)
 198         /* this only happens once per bucket */
 199         list_init(head);
 200
 201     /* link to bucket list and to full list */
 202     list_add_tail(head, &pair->bucket);
 203     list_add_tail(&dict->pairs, &pair->entry);
 204     dict->count++;
 205     return S_OK;
 206
 207 failed:
 208     VariantClear(&pair->key);
 209     VariantClear(&pair->item);
 210     free(pair);
 211     return hr;
 212 }
 213
 214 static void free_keyitem_pair(struct keyitem_pair *pair)
 215 {
 216     VariantClear(&pair->key);
 217     VariantClear(&pair->item);
 218     free(pair);
 219 }
 220
 221 static HRESULT WINAPI dict_enum_QueryInterface(IEnumVARIANT *iface, REFIID riid, void **obj)
 222 {
 223     struct dictionary_enum *This = impl_from_IEnumVARIANT(iface);
 224
 225     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), obj);
 226
 227     if (IsEqualIID(riid, &IID_IEnumVARIANT) || IsEqualIID(riid, &IID_IUnknown)) {
 228         *obj = iface;
 229         IEnumVARIANT_AddRef(iface);
 230         return S_OK;
 231     }
 232     else {
 233         WARN("interface not supported %s\n", debugstr_guid(riid));
 234         *obj = NULL;
 235         return E_NOINTERFACE;
 236     }
 237 }
 238
 239 static ULONG WINAPI dict_enum_AddRef(IEnumVARIANT *iface)
 240 {
 241     struct dictionary_enum *This = impl_from_IEnumVARIANT(iface);
 242     ULONG ref = InterlockedIncrement(&This->ref);
 243     TRACE("%p, refcount %lu.\n", iface, ref);
 244     return ref;
 245 }
 246
 247 static ULONG WINAPI dict_enum_Release(IEnumVARIANT *iface)
 248 {
 249     struct dictionary_enum *This = impl_from_IEnumVARIANT(iface);
 250     LONG ref = InterlockedDecrement(&This->ref);
 251
 252     TRACE("%p, refcount %lu.\n", iface, ref);
 253
 254     if (!ref)
 255     {
 256         list_remove(&This->notify);
 257         IDictionary_Release(&This->dict->IDictionary_iface);
 258         free(This);
 259     }
 260
 261     return ref;
 262 }
 263
 264 static HRESULT WINAPI dict_enum_Next(IEnumVARIANT *iface, ULONG count, VARIANT *keys, ULONG *fetched)
 265 {
 266     struct dictionary_enum *This = impl_from_IEnumVARIANT(iface);
 267     struct keyitem_pair *pair;
 268     ULONG i = 0;
 269
 270     TRACE("%p, %lu, %p, %p.\n", iface, count, keys, fetched);
 271
 272     if (fetched)
 273         *fetched = 0;
 274
 275     if (!count)
 276         return S_OK;
 277
 278     while (This->cur && i < count) {
 279         pair = LIST_ENTRY(This->cur, struct keyitem_pair, entry);
 280         VariantCopy(&keys[i], &pair->key);
 281         This->cur = list_next(&This->dict->pairs, This->cur);
 282         i++;
 283     }
 284
 285     if (fetched)
 286         *fetched = i;
 287
 288     return i < count ? S_FALSE : S_OK;
 289 }
 290
 291 static HRESULT WINAPI dict_enum_Skip(IEnumVARIANT *iface, ULONG count)
 292 {
 293     struct dictionary_enum *This = impl_from_IEnumVARIANT(iface);
 294
 295     TRACE("%p, %lu.\n", iface, count);
 296
 297     if (!count)
 298         return S_OK;
 299
 300     if (!This->cur)
 301         return S_FALSE;
 302
 303     while (count--) {
 304         This->cur = list_next(&This->dict->pairs, This->cur);
 305         if (!This->cur) break;
 306     }
 307
 308     return count == 0 ? S_OK : S_FALSE;
 309 }
 310
 311 static HRESULT WINAPI dict_enum_Reset(IEnumVARIANT *iface)
 312 {
 313     struct dictionary_enum *This = impl_from_IEnumVARIANT(iface);
 314
 315     TRACE("(%p)\n", This);
 316
 317     This->cur = list_head(&This->dict->pairs);
 318     return S_OK;
 319 }
 320
 321 static HRESULT create_dict_enum(struct dictionary *, IUnknown**);
 322
 323 static HRESULT WINAPI dict_enum_Clone(IEnumVARIANT *iface, IEnumVARIANT **cloned)
 324 {
 325     struct dictionary_enum *This = impl_from_IEnumVARIANT(iface);
 326     TRACE("(%p)->(%p)\n", This, cloned);
 327     return create_dict_enum(This->dict, (IUnknown**)cloned);
 328 }
 329
 330 static const IEnumVARIANTVtbl dictenumvtbl = {
 331     dict_enum_QueryInterface,
 332     dict_enum_AddRef,
 333     dict_enum_Release,
 334     dict_enum_Next,
 335     dict_enum_Skip,
 336     dict_enum_Reset,
 337     dict_enum_Clone
 338 };
 339
 340 static HRESULT create_dict_enum(struct dictionary *dict, IUnknown **ret)
 341 {
 342     struct dictionary_enum *object;
 343
 344     *ret = NULL;
 345
 346     if (!(object = calloc(1, sizeof(*object))))
 347         return E_OUTOFMEMORY;
 348
 349     object->IEnumVARIANT_iface.lpVtbl = &dictenumvtbl;
 350     object->ref = 1;
 351     object->cur = list_head(&dict->pairs);
 352     list_add_tail(&dict->notifier, &object->notify);
 353     object->dict = dict;
 354     IDictionary_AddRef(&dict->IDictionary_iface);
 355
 356     *ret = (IUnknown *)&object->IEnumVARIANT_iface;
 357
 358     return S_OK;
 359 }
 360
 361 static void notify_remove_pair(struct list *notifier, struct list *pair)
 362 {
 363     struct dictionary_enum *dict_enum;
 364     struct list *cur;
 365
 366     LIST_FOR_EACH(cur, notifier) {
 367         dict_enum = LIST_ENTRY(cur, struct dictionary_enum, notify);
 368         if (!pair)
 369             dict_enum->cur = list_head(&dict_enum->dict->pairs);
 370         else if (dict_enum->cur == pair) {
 371             dict_enum->cur = list_next(&dict_enum->dict->pairs, dict_enum->cur);
 372         }
 373     }
 374 }
 375
 376 static HRESULT WINAPI dictionary_QueryInterface(IDictionary *iface, REFIID riid, void **obj)
 377 {
 378     struct dictionary *dictionary = impl_from_IDictionary(iface);
 379
 380     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 381
 382     *obj = NULL;
 383
 384     if(IsEqualIID(riid, &IID_IUnknown) ||
 385        IsEqualIID(riid, &IID_IDispatch) ||
 386        IsEqualIID(riid, &IID_IDictionary))
 387     {
 388         *obj = &dictionary->IDictionary_iface;
 389     }
 390     else if (IsEqualIID(riid, &IID_IProvideClassInfo))
 391     {
 392         *obj = &dictionary->classinfo.IProvideClassInfo_iface;
 393     }
 394     else if ( IsEqualGUID( riid, &IID_IDispatchEx ))
 395     {
 396         TRACE("Interface IDispatchEx not supported - returning NULL\n");
 397         *obj = NULL;
 398         return E_NOINTERFACE;
 399     }
 400     else if ( IsEqualGUID( riid, &IID_IObjectWithSite ))
 401     {
 402         TRACE("Interface IObjectWithSite not supported - returning NULL\n");
 403         *obj = NULL;
 404         return E_NOINTERFACE;
 405     }
 406     else
 407     {
 408         WARN("interface %s not implemented\n", debugstr_guid(riid));
 409         return E_NOINTERFACE;
 410     }
 411
 412     IUnknown_AddRef((IUnknown*)*obj);
 413     return S_OK;
 414 }
 415
 416 static ULONG WINAPI dictionary_AddRef(IDictionary *iface)
 417 {
 418     struct dictionary *dictionary = impl_from_IDictionary(iface);
 419     ULONG ref = InterlockedIncrement(&dictionary->ref);
 420
 421     TRACE("%p, refcount %lu.\n", iface, ref);
 422
 423     return ref;
 424 }
 425
 426 static ULONG WINAPI dictionary_Release(IDictionary *iface)
 427 {
 428     struct dictionary *dictionary = impl_from_IDictionary(iface);
 429     ULONG ref = InterlockedDecrement(&dictionary->ref);
 430
 431     TRACE("%p, refcount %lu.\n", iface, ref);
 432
 433     if (!ref)
 434     {
 435         IDictionary_RemoveAll(iface);
 436         free(dictionary);
 437     }
 438
 439     return ref;
 440 }
 441
 442 static HRESULT WINAPI dictionary_GetTypeInfoCount(IDictionary *iface, UINT *pctinfo)
 443 {
 444     TRACE("%p, %p.\n", iface, pctinfo);
 445
 446     *pctinfo = 1;
 447     return S_OK;
 448 }
 449
 450 static HRESULT WINAPI dictionary_GetTypeInfo(IDictionary *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 451 {
 452     TRACE("%p, %u, %lx, %p.\n", iface, iTInfo, lcid, ppTInfo);
 453
 454     return get_typeinfo(IDictionary_tid, ppTInfo);
 455 }
 456
 457 static HRESULT WINAPI dictionary_GetIDsOfNames(IDictionary *iface, REFIID riid, LPOLESTR *rgszNames,
 458                 UINT cNames, LCID lcid, DISPID *rgDispId)
 459 {
 460     ITypeInfo *typeinfo;
 461     HRESULT hr;
 462
 463     TRACE("%p, %s, %p, %u, %lx, %p.\n", iface, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 464
 465     hr = get_typeinfo(IDictionary_tid, &typeinfo);
 466     if(SUCCEEDED(hr))
 467     {
 468         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 469         ITypeInfo_Release(typeinfo);
 470     }
 471
 472     return hr;
 473 }
 474
 475 static HRESULT WINAPI dictionary_Invoke(IDictionary *iface, DISPID dispIdMember, REFIID riid,
 476                 LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 477                 EXCEPINFO *pExcepInfo, UINT *puArgErr)
 478 {
 479     ITypeInfo *typeinfo;
 480     HRESULT hr;
 481
 482     TRACE("%p, %ld, %s, %lx, %d, %p, %p, %p, %p.\n", iface, dispIdMember, debugstr_guid(riid),
 483            lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 484
 485     hr = get_typeinfo(IDictionary_tid, &typeinfo);
 486     if(SUCCEEDED(hr))
 487     {
 488         hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 489         ITypeInfo_Release(typeinfo);
 490     }
 491
 492     return hr;
 493 }
 494
 495 static HRESULT WINAPI dictionary_putref_Item(IDictionary *iface, VARIANT *Key, VARIANT *pRetItem)
 496 {
 497     FIXME("%p, %p, %p stub\n", iface, Key, pRetItem);
 498
 499     return E_NOTIMPL;
 500 }
 501
 502 static HRESULT WINAPI dictionary_put_Item(IDictionary *iface, VARIANT *key, VARIANT *item)
 503 {
 504     struct dictionary *dictionary = impl_from_IDictionary(iface);
 505     struct keyitem_pair *pair;
 506
 507     TRACE("%p, %s, %s.\n", iface, debugstr_variant(key), debugstr_variant(item));
 508
 509     if ((pair = get_keyitem_pair(dictionary, key)))
 510         return VariantCopyInd(&pair->item, item);
 511
 512     return IDictionary_Add(iface, key, item);
 513 }
 514
 515 static HRESULT WINAPI dictionary_get_Item(IDictionary *iface, VARIANT *key, VARIANT *item)
 516 {
 517     struct dictionary *dictionary = impl_from_IDictionary(iface);
 518     struct keyitem_pair *pair;
 519
 520     TRACE("%p, %s, %p.\n", iface, debugstr_variant(key), item);
 521
 522     if ((pair = get_keyitem_pair(dictionary, key)))
 523         VariantCopy(item, &pair->item);
 524     else {
 525         VariantInit(item);
 526         return IDictionary_Add(iface, key, item);
 527     }
 528
 529     return S_OK;
 530 }
 531
 532 static HRESULT WINAPI dictionary_Add(IDictionary *iface, VARIANT *key, VARIANT *item)
 533 {
 534     struct dictionary *dictionary = impl_from_IDictionary(iface);
 535
 536     TRACE("%p, %s, %s.\n", iface, debugstr_variant(key), debugstr_variant(item));
 537
 538     if (get_keyitem_pair(dictionary, key))
 539         return CTL_E_KEY_ALREADY_EXISTS;
 540
 541     return add_keyitem_pair(dictionary, key, item);
 542 }
 543
 544 static HRESULT WINAPI dictionary_get_Count(IDictionary *iface, LONG *count)
 545 {
 546     struct dictionary *dictionary = impl_from_IDictionary(iface);
 547
 548     TRACE("%p, %p.\n", iface, count);
 549
 550     *count = dictionary->count;
 551     return S_OK;
 552 }
 553
 554 static HRESULT WINAPI dictionary_Exists(IDictionary *iface, VARIANT *key, VARIANT_BOOL *exists)
 555 {
 556     struct dictionary *dictionary = impl_from_IDictionary(iface);
 557
 558     TRACE("%p, %s, %p.\n", iface, debugstr_variant(key), exists);
 559
 560     if (!exists)
 561         return CTL_E_ILLEGALFUNCTIONCALL;
 562
 563     *exists = get_keyitem_pair(dictionary, key) != NULL ? VARIANT_TRUE : VARIANT_FALSE;
 564     return S_OK;
 565 }
 566
 567 static HRESULT WINAPI dictionary_Items(IDictionary *iface, VARIANT *items)
 568 {
 569     struct dictionary *dictionary = impl_from_IDictionary(iface);
 570     struct keyitem_pair *pair;
 571     SAFEARRAYBOUND bound;
 572     SAFEARRAY *sa;
 573     VARIANT *v;
 574     HRESULT hr;
 575     LONG i;
 576
 577     TRACE("%p, %p.\n", iface, items);
 578
 579     if (!items)
 580         return S_OK;
 581
 582     bound.lLbound = 0;
 583     bound.cElements = dictionary->count;
 584     sa = SafeArrayCreate(VT_VARIANT, 1, &bound);
 585     if (!sa)
 586         return E_OUTOFMEMORY;
 587
 588     hr = SafeArrayAccessData(sa, (void**)&v);
 589     if (FAILED(hr)) {
 590         SafeArrayDestroy(sa);
 591         return hr;
 592     }
 593
 594     i = 0;
 595     LIST_FOR_EACH_ENTRY(pair, &dictionary->pairs, struct keyitem_pair, entry)
 596     {
 597         VariantCopy(&v[i], &pair->item);
 598         i++;
 599     }
 600     SafeArrayUnaccessData(sa);
 601
 602     V_VT(items) = VT_ARRAY|VT_VARIANT;
 603     V_ARRAY(items) = sa;
 604     return S_OK;
 605 }
 606
 607 static HRESULT WINAPI dictionary_put_Key(IDictionary *iface, VARIANT *key, VARIANT *newkey)
 608 {
 609     struct dictionary *dictionary = impl_from_IDictionary(iface);
 610     struct keyitem_pair *pair;
 611     VARIANT empty;
 612     HRESULT hr;
 613
 614     TRACE("%p, %s, %s.\n", iface, debugstr_variant(key), debugstr_variant(newkey));
 615
 616     if ((pair = get_keyitem_pair(dictionary, key)))
 617     {
 618         /* found existing pair for a key, add new pair with new key
 619            and old item and remove old pair after that */
 620
 621         hr = IDictionary_Add(iface, newkey, &pair->item);
 622         if (FAILED(hr))
 623             return hr;
 624
 625         return IDictionary_Remove(iface, key);
 626     }
 627
 628     VariantInit(&empty);
 629     return IDictionary_Add(iface, newkey, &empty);
 630 }
 631
 632 static HRESULT WINAPI dictionary_Keys(IDictionary *iface, VARIANT *keys)
 633 {
 634     struct dictionary *dictionary = impl_from_IDictionary(iface);
 635     struct keyitem_pair *pair;
 636     SAFEARRAYBOUND bound;
 637     SAFEARRAY *sa;
 638     VARIANT *v;
 639     HRESULT hr;
 640     LONG i;
 641
 642     TRACE("%p, %p.\n", iface, keys);
 643
 644     if (!keys)
 645         return S_OK;
 646
 647     bound.lLbound = 0;
 648     bound.cElements = dictionary->count;
 649     sa = SafeArrayCreate(VT_VARIANT, 1, &bound);
 650     if (!sa)
 651         return E_OUTOFMEMORY;
 652
 653     hr = SafeArrayAccessData(sa, (void**)&v);
 654     if (FAILED(hr)) {
 655         SafeArrayDestroy(sa);
 656         return hr;
 657     }
 658
 659     i = 0;
 660     LIST_FOR_EACH_ENTRY(pair, &dictionary->pairs, struct keyitem_pair, entry)
 661     {
 662         VariantCopy(&v[i], &pair->key);
 663         i++;
 664     }
 665     SafeArrayUnaccessData(sa);
 666
 667     V_VT(keys) = VT_ARRAY|VT_VARIANT;
 668     V_ARRAY(keys) = sa;
 669     return S_OK;
 670 }
 671
 672 static HRESULT WINAPI dictionary_Remove(IDictionary *iface, VARIANT *key)
 673 {
 674     struct dictionary *dictionary = impl_from_IDictionary(iface);
 675     struct keyitem_pair *pair;
 676
 677     TRACE("%p, %s.\n", iface, debugstr_variant(key));
 678
 679     if (!(pair = get_keyitem_pair(dictionary, key)))
 680         return CTL_E_ELEMENT_NOT_FOUND;
 681
 682     notify_remove_pair(&dictionary->notifier, &pair->entry);
 683     list_remove(&pair->entry);
 684     list_remove(&pair->bucket);
 685     dictionary->count--;
 686
 687     free_keyitem_pair(pair);
 688     return S_OK;
 689 }
 690
 691 static HRESULT WINAPI dictionary_RemoveAll(IDictionary *iface)
 692 {
 693     struct dictionary *dictionary = impl_from_IDictionary(iface);
 694     struct keyitem_pair *pair, *pair2;
 695
 696     TRACE("%p.\n", iface);
 697
 698     if (!dictionary->count)
 699         return S_OK;
 700
 701     notify_remove_pair(&dictionary->notifier, NULL);
 702     LIST_FOR_EACH_ENTRY_SAFE(pair, pair2, &dictionary->pairs, struct keyitem_pair, entry)
 703     {
 704         list_remove(&pair->entry);
 705         list_remove(&pair->bucket);
 706         free_keyitem_pair(pair);
 707     }
 708     dictionary->count = 0;
 709
 710     return S_OK;
 711 }
 712
 713 static HRESULT WINAPI dictionary_put_CompareMode(IDictionary *iface, CompareMethod method)
 714 {
 715     struct dictionary *dictionary = impl_from_IDictionary(iface);
 716
 717     TRACE("%p, %d.\n", iface, method);
 718
 719     if (dictionary->count)
 720         return CTL_E_ILLEGALFUNCTIONCALL;
 721
 722     dictionary->method = method;
 723     return S_OK;
 724 }
 725
 726 static HRESULT WINAPI dictionary_get_CompareMode(IDictionary *iface, CompareMethod *method)
 727 {
 728     struct dictionary *dictionary = impl_from_IDictionary(iface);
 729
 730     TRACE("%p, %p.\n", iface, method);
 731
 732     *method = dictionary->method;
 733     return S_OK;
 734 }
 735
 736 static HRESULT WINAPI dictionary__NewEnum(IDictionary *iface, IUnknown **ret)
 737 {
 738     struct dictionary *dictionary = impl_from_IDictionary(iface);
 739
 740     TRACE("%p, %p.\n", iface, ret);
 741
 742     return create_dict_enum(dictionary, ret);
 743 }
 744
 745 static DWORD get_str_hash(const WCHAR *str, CompareMethod method)
 746 {
 747     DWORD hash = 0;
 748
 749     if (str) {
 750         while (*str) {
 751             WCHAR ch;
 752
 753             ch = (method == TextCompare || method == DatabaseCompare) ? towlower(*str) : *str;
 754
 755             hash += (hash << 4) + ch;
 756             str++;
 757         }
 758     }
 759
 760     return hash % DICT_HASH_MOD;
 761 }
 762
 763 static DWORD get_num_hash(FLOAT num)
 764 {
 765     return (*((DWORD*)&num)) % DICT_HASH_MOD;
 766 }
 767
 768 static HRESULT get_flt_hash(FLOAT flt, LONG *hash)
 769 {
 770     if (isinf(flt)) {
 771         *hash = 0;
 772         return S_OK;
 773     }
 774     else if (!isnan(flt)) {
 775         *hash = get_num_hash(flt);
 776         return S_OK;
 777     }
 778
 779     /* NaN case */
 780     *hash = ~0u;
 781     return CTL_E_ILLEGALFUNCTIONCALL;
 782 }
 783
 784 static DWORD get_ptr_hash(void *ptr)
 785 {
 786     return PtrToUlong(ptr) % DICT_HASH_MOD;
 787 }
 788
 789 static HRESULT WINAPI dictionary_get_HashVal(IDictionary *iface, VARIANT *key, VARIANT *hash)
 790 {
 791     struct dictionary *dictionary = impl_from_IDictionary(iface);
 792
 793     TRACE("%p, %s, %p.\n", iface, debugstr_variant(key), hash);
 794
 795     V_VT(hash) = VT_I4;
 796     switch (V_VT(key))
 797     {
 798     case VT_BSTR|VT_BYREF:
 799     case VT_BSTR:
 800         V_I4(hash) = get_str_hash(get_key_strptr(key), dictionary->method);
 801         break;
 802     case VT_UI1|VT_BYREF:
 803     case VT_UI1:
 804         V_I4(hash) = get_num_hash(V_VT(key) & VT_BYREF ? *V_UI1REF(key) : V_UI1(key));
 805         break;
 806     case VT_I2|VT_BYREF:
 807     case VT_I2:
 808         V_I4(hash) = get_num_hash(V_VT(key) & VT_BYREF ? *V_I2REF(key) : V_I2(key));
 809         break;
 810     case VT_I4|VT_BYREF:
 811     case VT_I4:
 812         V_I4(hash) = get_num_hash(V_VT(key) & VT_BYREF ? *V_I4REF(key) : V_I4(key));
 813         break;
 814     case VT_UNKNOWN|VT_BYREF:
 815     case VT_DISPATCH|VT_BYREF:
 816     case VT_UNKNOWN:
 817     case VT_DISPATCH:
 818     {
 819         IUnknown *src = (V_VT(key) & VT_BYREF) ? *V_UNKNOWNREF(key) : V_UNKNOWN(key);
 820         IUnknown *unk = NULL;
 821
 822         if (!src) {
 823             V_I4(hash) = 0;
 824             return S_OK;
 825         }
 826
 827         IUnknown_QueryInterface(src, &IID_IUnknown, (void**)&unk);
 828         if (!unk) {
 829             V_I4(hash) = ~0u;
 830             return CTL_E_ILLEGALFUNCTIONCALL;
 831         }
 832         V_I4(hash) = get_ptr_hash(unk);
 833         IUnknown_Release(unk);
 834         break;
 835     }
 836     case VT_DATE|VT_BYREF:
 837     case VT_DATE:
 838         return get_flt_hash(V_VT(key) & VT_BYREF ? *V_DATEREF(key) : V_DATE(key), &V_I4(hash));
 839     case VT_R4|VT_BYREF:
 840     case VT_R4:
 841         return get_flt_hash(V_VT(key) & VT_BYREF ? *V_R4REF(key) : V_R4(key), &V_I4(hash));
 842     case VT_R8|VT_BYREF:
 843     case VT_R8:
 844         return get_flt_hash(V_VT(key) & VT_BYREF ? *V_R8REF(key) : V_R8(key), &V_I4(hash));
 845     case VT_INT:
 846     case VT_UINT:
 847     case VT_I1:
 848     case VT_I8:
 849     case VT_UI2:
 850     case VT_UI4:
 851         V_I4(hash) = ~0u;
 852         return CTL_E_ILLEGALFUNCTIONCALL;
 853     default:
 854         FIXME("not implemented for type %d\n", V_VT(key));
 855         return E_NOTIMPL;
 856     }
 857
 858     return S_OK;
 859 }
 860
 861 static const struct IDictionaryVtbl dictionary_vtbl =
 862 {
 863     dictionary_QueryInterface,
 864     dictionary_AddRef,
 865     dictionary_Release,
 866     dictionary_GetTypeInfoCount,
 867     dictionary_GetTypeInfo,
 868     dictionary_GetIDsOfNames,
 869     dictionary_Invoke,
 870     dictionary_putref_Item,
 871     dictionary_put_Item,
 872     dictionary_get_Item,
 873     dictionary_Add,
 874     dictionary_get_Count,
 875     dictionary_Exists,
 876     dictionary_Items,
 877     dictionary_put_Key,
 878     dictionary_Keys,
 879     dictionary_Remove,
 880     dictionary_RemoveAll,
 881     dictionary_put_CompareMode,
 882     dictionary_get_CompareMode,
 883     dictionary__NewEnum,
 884     dictionary_get_HashVal
 885 };
 886
 887 HRESULT WINAPI Dictionary_CreateInstance(IClassFactory *factory, IUnknown *outer, REFIID riid, void **ret)
 888 {
 889     struct dictionary *object;
 890
 891     TRACE("(%p, %p, %s, %p)\n", factory, outer, debugstr_guid(riid), ret);
 892
 893     *ret = NULL;
 894
 895     if (!(object = calloc(1, sizeof(*object))))
 896         return E_OUTOFMEMORY;
 897
 898     object->IDictionary_iface.lpVtbl = &dictionary_vtbl;
 899     object->ref = 1;
 900     object->method = BinaryCompare;
 901     list_init(&object->pairs);
 902     list_init(&object->notifier);
 903
 904     init_classinfo(&CLSID_Dictionary, (IUnknown *)&object->IDictionary_iface, &object->classinfo);
 905
 906     *ret = &object->IDictionary_iface;
 907
 908     return S_OK;
 909 }