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 "config.h"
  22 #include "wine/port.h"
  23
  24 #include <stdarg.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "ole2.h"
  29 #include "olectl.h"
  30 #include "dispex.h"
  31 #include "scrrun.h"
  32 #include "scrrun_private.h"
  33
  34 #include "wine/debug.h"
  35 #include "wine/unicode.h"
  36 #include "wine/list.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(scrrun);
  39
  40 #define BUCKET_COUNT  509
  41 #define DICT_HASH_MOD 1201
  42
  43 /* Implementation details
  44
  45    Dictionary contains one list that links all pairs, this way
  46    order in which they were added is preserved. Each bucket has
  47    its own list to hold all pairs in this bucket. Initially all
  48    bucket lists are zeroed and we init them once we about to add
  49    first pair.
  50
  51    When pair is removed it's unlinked from both lists; if it was
  52    a last pair in a bucket list it stays empty in initialized state.
  53
  54    Preserving pair order is important for enumeration, so far testing
  55    indicates that pairs are not reordered basing on hash value.
  56  */
  57
  58 struct keyitem_pair {
  59     struct  list entry;
  60     struct  list bucket;
  61     DWORD   hash;
  62     VARIANT key;
  63     VARIANT item;
  64 };
  65
  66 typedef struct
  67 {
  68     IDictionary IDictionary_iface;
  69     LONG ref;
  70
  71     CompareMethod method;
  72     LONG count;
  73     struct list pairs;
  74     struct list buckets[BUCKET_COUNT];
  75     struct list notifier;
  76 } dictionary;
  77
  78 struct dictionary_enum {
  79     IEnumVARIANT IEnumVARIANT_iface;
  80     LONG ref;
  81
  82     dictionary *dict;
  83     struct list *cur;
  84     struct list notify;
  85 };
  86
  87 static inline dictionary *impl_from_IDictionary(IDictionary *iface)
  88 {
  89     return CONTAINING_RECORD(iface, 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(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 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 ? strcmpW(str1, str2) : strcmpiW(str1, str2);
 127 }
 128
 129 static BOOL is_matching_key(const 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(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(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     pair = heap_alloc(sizeof(*pair));
 182     if (!pair)
 183         return E_OUTOFMEMORY;
 184
 185     pair->hash = V_I4(&hash);
 186     VariantInit(&pair->key);
 187     VariantInit(&pair->item);
 188
 189     hr = VariantCopyInd(&pair->key, key);
 190     if (FAILED(hr))
 191         goto failed;
 192
 193     hr = VariantCopyInd(&pair->item, item);
 194     if (FAILED(hr))
 195         goto failed;
 196
 197     head = get_bucket_head(dict, pair->hash);
 198     if (!head->next)
 199         /* this only happens once per bucket */
 200         list_init(head);
 201
 202     /* link to bucket list and to full list */
 203     list_add_tail(head, &pair->bucket);
 204     list_add_tail(&dict->pairs, &pair->entry);
 205     dict->count++;
 206     return S_OK;
 207
 208 failed:
 209     VariantClear(&pair->key);
 210     VariantClear(&pair->item);
 211     heap_free(pair);
 212     return hr;
 213 }
 214
 215 static void free_keyitem_pair(struct keyitem_pair *pair)
 216 {
 217     VariantClear(&pair->key);
 218     VariantClear(&pair->item);
 219     heap_free(pair);
 220 }
 221
 222 static HRESULT WINAPI dict_enum_QueryInterface(IEnumVARIANT *iface, REFIID riid, void **obj)
 223 {
 224     struct dictionary_enum *This = impl_from_IEnumVARIANT(iface);
 225
 226     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), obj);
 227
 228     if (IsEqualIID(riid, &IID_IEnumVARIANT) || IsEqualIID(riid, &IID_IUnknown)) {
 229         *obj = iface;
 230         IEnumVARIANT_AddRef(iface);
 231         return S_OK;
 232     }
 233     else {
 234         WARN("interface not supported %s\n", debugstr_guid(riid));
 235         *obj = NULL;
 236         return E_NOINTERFACE;
 237     }
 238 }
 239
 240 static ULONG WINAPI dict_enum_AddRef(IEnumVARIANT *iface)
 241 {
 242     struct dictionary_enum *This = impl_from_IEnumVARIANT(iface);
 243     TRACE("(%p)\n", This);
 244     return InterlockedIncrement(&This->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;
 251
 252     TRACE("(%p)\n", This);
 253
 254     ref = InterlockedDecrement(&This->ref);
 255     if(ref == 0) {
 256         list_remove(&This->notify);
 257         IDictionary_Release(&This->dict->IDictionary_iface);
 258         heap_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)->(%u %p %p)\n", This, 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)->(%u)\n", This, 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(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(dictionary *dict, IUnknown **ret)
 341 {
 342     struct dictionary_enum *This;
 343
 344     *ret = NULL;
 345
 346     This = heap_alloc(sizeof(*This));
 347     if (!This)
 348         return E_OUTOFMEMORY;
 349
 350     This->IEnumVARIANT_iface.lpVtbl = &dictenumvtbl;
 351     This->ref = 1;
 352     This->cur = list_head(&dict->pairs);
 353     list_add_tail(&dict->notifier, &This->notify);
 354     This->dict = dict;
 355     IDictionary_AddRef(&dict->IDictionary_iface);
 356
 357     *ret = (IUnknown*)&This->IEnumVARIANT_iface;
 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     dictionary *This = impl_from_IDictionary(iface);
 379     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), obj);
 380
 381     *obj = NULL;
 382
 383     if(IsEqualIID(riid, &IID_IUnknown) ||
 384        IsEqualIID(riid, &IID_IDispatch) ||
 385        IsEqualIID(riid, &IID_IDictionary))
 386     {
 387         *obj = &This->IDictionary_iface;
 388     }
 389     else if ( IsEqualGUID( riid, &IID_IDispatchEx ))
 390     {
 391         TRACE("Interface IDispatchEx not supported - returning NULL\n");
 392         *obj = NULL;
 393         return E_NOINTERFACE;
 394     }
 395     else if ( IsEqualGUID( riid, &IID_IObjectWithSite ))
 396     {
 397         TRACE("Interface IObjectWithSite not supported - returning NULL\n");
 398         *obj = NULL;
 399         return E_NOINTERFACE;
 400     }
 401     else
 402     {
 403         WARN("interface %s not implemented\n", debugstr_guid(riid));
 404         return E_NOINTERFACE;
 405     }
 406
 407     IDictionary_AddRef(iface);
 408     return S_OK;
 409 }
 410
 411 static ULONG WINAPI dictionary_AddRef(IDictionary *iface)
 412 {
 413     dictionary *This = impl_from_IDictionary(iface);
 414     TRACE("(%p)\n", This);
 415
 416     return InterlockedIncrement(&This->ref);
 417 }
 418
 419 static ULONG WINAPI dictionary_Release(IDictionary *iface)
 420 {
 421     dictionary *This = impl_from_IDictionary(iface);
 422     LONG ref;
 423
 424     TRACE("(%p)\n", This);
 425
 426     ref = InterlockedDecrement(&This->ref);
 427     if(ref == 0) {
 428         IDictionary_RemoveAll(iface);
 429         heap_free(This);
 430     }
 431
 432     return ref;
 433 }
 434
 435 static HRESULT WINAPI dictionary_GetTypeInfoCount(IDictionary *iface, UINT *pctinfo)
 436 {
 437     dictionary *This = impl_from_IDictionary(iface);
 438
 439     TRACE("(%p)->()\n", This);
 440
 441     *pctinfo = 1;
 442     return S_OK;
 443 }
 444
 445 static HRESULT WINAPI dictionary_GetTypeInfo(IDictionary *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 446 {
 447     dictionary *This = impl_from_IDictionary(iface);
 448
 449     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 450     return get_typeinfo(IDictionary_tid, ppTInfo);
 451 }
 452
 453 static HRESULT WINAPI dictionary_GetIDsOfNames(IDictionary *iface, REFIID riid, LPOLESTR *rgszNames,
 454                 UINT cNames, LCID lcid, DISPID *rgDispId)
 455 {
 456     dictionary *This = impl_from_IDictionary(iface);
 457     ITypeInfo *typeinfo;
 458     HRESULT hr;
 459
 460     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 461
 462     hr = get_typeinfo(IDictionary_tid, &typeinfo);
 463     if(SUCCEEDED(hr))
 464     {
 465         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 466         ITypeInfo_Release(typeinfo);
 467     }
 468
 469     return hr;
 470 }
 471
 472 static HRESULT WINAPI dictionary_Invoke(IDictionary *iface, DISPID dispIdMember, REFIID riid,
 473                 LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 474                 EXCEPINFO *pExcepInfo, UINT *puArgErr)
 475 {
 476     dictionary *This = impl_from_IDictionary(iface);
 477     ITypeInfo *typeinfo;
 478     HRESULT hr;
 479
 480     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 481            lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 482
 483     hr = get_typeinfo(IDictionary_tid, &typeinfo);
 484     if(SUCCEEDED(hr))
 485     {
 486         hr = ITypeInfo_Invoke(typeinfo, &This->IDictionary_iface, dispIdMember, wFlags,
 487                 pDispParams, pVarResult, pExcepInfo, puArgErr);
 488         ITypeInfo_Release(typeinfo);
 489     }
 490
 491     return hr;
 492 }
 493
 494 static HRESULT WINAPI dictionary_putref_Item(IDictionary *iface, VARIANT *Key, VARIANT *pRetItem)
 495 {
 496     dictionary *This = impl_from_IDictionary(iface);
 497
 498     FIXME("(%p)->(%p %p)\n", This, Key, pRetItem);
 499
 500     return E_NOTIMPL;
 501 }
 502
 503 static HRESULT WINAPI dictionary_put_Item(IDictionary *iface, VARIANT *key, VARIANT *item)
 504 {
 505     dictionary *This = impl_from_IDictionary(iface);
 506     struct keyitem_pair *pair;
 507
 508     TRACE("(%p)->(%s %s)\n", This, debugstr_variant(key), debugstr_variant(item));
 509
 510     if ((pair = get_keyitem_pair(This, key)))
 511         return VariantCopyInd(&pair->item, item);
 512
 513     return IDictionary_Add(iface, key, item);
 514 }
 515
 516 static HRESULT WINAPI dictionary_get_Item(IDictionary *iface, VARIANT *key, VARIANT *item)
 517 {
 518     dictionary *This = impl_from_IDictionary(iface);
 519     struct keyitem_pair *pair;
 520
 521     TRACE("(%p)->(%s %p)\n", This, debugstr_variant(key), item);
 522
 523     if ((pair = get_keyitem_pair(This, key)))
 524         VariantCopy(item, &pair->item);
 525     else {
 526         VariantInit(item);
 527         return IDictionary_Add(iface, key, item);
 528     }
 529
 530     return S_OK;
 531 }
 532
 533 static HRESULT WINAPI dictionary_Add(IDictionary *iface, VARIANT *key, VARIANT *item)
 534 {
 535     dictionary *This = impl_from_IDictionary(iface);
 536
 537     TRACE("(%p)->(%s %s)\n", This, debugstr_variant(key), debugstr_variant(item));
 538
 539     if (get_keyitem_pair(This, key))
 540         return CTL_E_KEY_ALREADY_EXISTS;
 541
 542     return add_keyitem_pair(This, key, item);
 543 }
 544
 545 static HRESULT WINAPI dictionary_get_Count(IDictionary *iface, LONG *count)
 546 {
 547     dictionary *This = impl_from_IDictionary(iface);
 548
 549     TRACE("(%p)->(%p)\n", This, count);
 550
 551     *count = This->count;
 552     return S_OK;
 553 }
 554
 555 static HRESULT WINAPI dictionary_Exists(IDictionary *iface, VARIANT *key, VARIANT_BOOL *exists)
 556 {
 557     dictionary *This = impl_from_IDictionary(iface);
 558
 559     TRACE("(%p)->(%s %p)\n", This, debugstr_variant(key), exists);
 560
 561     if (!exists)
 562         return CTL_E_ILLEGALFUNCTIONCALL;
 563
 564     *exists = get_keyitem_pair(This, key) != NULL ? VARIANT_TRUE : VARIANT_FALSE;
 565     return S_OK;
 566 }
 567
 568 static HRESULT WINAPI dictionary_Items(IDictionary *iface, VARIANT *items)
 569 {
 570     dictionary *This = impl_from_IDictionary(iface);
 571     struct keyitem_pair *pair;
 572     SAFEARRAYBOUND bound;
 573     SAFEARRAY *sa;
 574     VARIANT *v;
 575     HRESULT hr;
 576     LONG i;
 577
 578     TRACE("(%p)->(%p)\n", This, items);
 579
 580     if (!items)
 581         return S_OK;
 582
 583     bound.lLbound = 0;
 584     bound.cElements = This->count;
 585     sa = SafeArrayCreate(VT_VARIANT, 1, &bound);
 586     if (!sa)
 587         return E_OUTOFMEMORY;
 588
 589     hr = SafeArrayAccessData(sa, (void**)&v);
 590     if (FAILED(hr)) {
 591         SafeArrayDestroy(sa);
 592         return hr;
 593     }
 594
 595     i = 0;
 596     LIST_FOR_EACH_ENTRY(pair, &This->pairs, struct keyitem_pair, entry) {
 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     dictionary *This = impl_from_IDictionary(iface);
 610     struct keyitem_pair *pair;
 611     VARIANT empty;
 612     HRESULT hr;
 613
 614     TRACE("(%p)->(%s %s)\n", This, debugstr_variant(key), debugstr_variant(newkey));
 615
 616     if ((pair = get_keyitem_pair(This, key))) {
 617         /* found existing pair for a key, add new pair with new key
 618            and old item and remove old pair after that */
 619
 620         hr = IDictionary_Add(iface, newkey, &pair->item);
 621         if (FAILED(hr))
 622             return hr;
 623
 624         return IDictionary_Remove(iface, key);
 625     }
 626
 627     VariantInit(&empty);
 628     return IDictionary_Add(iface, newkey, &empty);
 629 }
 630
 631 static HRESULT WINAPI dictionary_Keys(IDictionary *iface, VARIANT *keys)
 632 {
 633     dictionary *This = impl_from_IDictionary(iface);
 634     struct keyitem_pair *pair;
 635     SAFEARRAYBOUND bound;
 636     SAFEARRAY *sa;
 637     VARIANT *v;
 638     HRESULT hr;
 639     LONG i;
 640
 641     TRACE("(%p)->(%p)\n", This, keys);
 642
 643     if (!keys)
 644         return S_OK;
 645
 646     bound.lLbound = 0;
 647     bound.cElements = This->count;
 648     sa = SafeArrayCreate(VT_VARIANT, 1, &bound);
 649     if (!sa)
 650         return E_OUTOFMEMORY;
 651
 652     hr = SafeArrayAccessData(sa, (void**)&v);
 653     if (FAILED(hr)) {
 654         SafeArrayDestroy(sa);
 655         return hr;
 656     }
 657
 658     i = 0;
 659     LIST_FOR_EACH_ENTRY(pair, &This->pairs, struct keyitem_pair, entry) {
 660         VariantCopy(&v[i], &pair->key);
 661         i++;
 662     }
 663     SafeArrayUnaccessData(sa);
 664
 665     V_VT(keys) = VT_ARRAY|VT_VARIANT;
 666     V_ARRAY(keys) = sa;
 667     return S_OK;
 668 }
 669
 670 static HRESULT WINAPI dictionary_Remove(IDictionary *iface, VARIANT *key)
 671 {
 672     dictionary *This = impl_from_IDictionary(iface);
 673     struct keyitem_pair *pair;
 674
 675     TRACE("(%p)->(%s)\n", This, debugstr_variant(key));
 676
 677     if (!(pair = get_keyitem_pair(This, key)))
 678         return CTL_E_ELEMENT_NOT_FOUND;
 679
 680     notify_remove_pair(&This->notifier, &pair->entry);
 681     list_remove(&pair->entry);
 682     list_remove(&pair->bucket);
 683     This->count--;
 684
 685     free_keyitem_pair(pair);
 686     return S_OK;
 687 }
 688
 689 static HRESULT WINAPI dictionary_RemoveAll(IDictionary *iface)
 690 {
 691     dictionary *This = impl_from_IDictionary(iface);
 692     struct keyitem_pair *pair, *pair2;
 693
 694     TRACE("(%p)\n", This);
 695
 696     if (This->count == 0)
 697         return S_OK;
 698
 699     notify_remove_pair(&This->notifier, NULL);
 700     LIST_FOR_EACH_ENTRY_SAFE(pair, pair2, &This->pairs, struct keyitem_pair, entry) {
 701         list_remove(&pair->entry);
 702         list_remove(&pair->bucket);
 703         free_keyitem_pair(pair);
 704     }
 705     This->count = 0;
 706
 707     return S_OK;
 708 }
 709
 710 static HRESULT WINAPI dictionary_put_CompareMode(IDictionary *iface, CompareMethod method)
 711 {
 712     dictionary *This = impl_from_IDictionary(iface);
 713
 714     TRACE("(%p)->(%d)\n", This, method);
 715
 716     if (This->count)
 717         return CTL_E_ILLEGALFUNCTIONCALL;
 718
 719     This->method = method;
 720     return S_OK;
 721 }
 722
 723 static HRESULT WINAPI dictionary_get_CompareMode(IDictionary *iface, CompareMethod *method)
 724 {
 725     dictionary *This = impl_from_IDictionary(iface);
 726
 727     TRACE("(%p)->(%p)\n", This, method);
 728
 729     *method = This->method;
 730     return S_OK;
 731 }
 732
 733 static HRESULT WINAPI dictionary__NewEnum(IDictionary *iface, IUnknown **ret)
 734 {
 735     dictionary *This = impl_from_IDictionary(iface);
 736
 737     TRACE("(%p)->(%p)\n", This, ret);
 738
 739     return create_dict_enum(This, ret);
 740 }
 741
 742 static DWORD get_str_hash(const WCHAR *str, CompareMethod method)
 743 {
 744     DWORD hash = 0;
 745
 746     if (str) {
 747         while (*str) {
 748             WCHAR ch;
 749
 750             ch = (method == TextCompare || method == DatabaseCompare) ? tolowerW(*str) : *str;
 751
 752             hash += (hash << 4) + ch;
 753             str++;
 754         }
 755     }
 756
 757     return hash % DICT_HASH_MOD;
 758 }
 759
 760 static DWORD get_num_hash(FLOAT num)
 761 {
 762     return (*((DWORD*)&num)) % DICT_HASH_MOD;
 763 }
 764
 765 static HRESULT get_flt_hash(FLOAT flt, LONG *hash)
 766 {
 767     if (isinf(flt)) {
 768         *hash = 0;
 769         return S_OK;
 770     }
 771     else if (!isnan(flt)) {
 772         *hash = get_num_hash(flt);
 773         return S_OK;
 774     }
 775
 776     /* NaN case */
 777     *hash = ~0u;
 778     return CTL_E_ILLEGALFUNCTIONCALL;
 779 }
 780
 781 static DWORD get_ptr_hash(void *ptr)
 782 {
 783     return PtrToUlong(ptr) % DICT_HASH_MOD;
 784 }
 785
 786 static HRESULT WINAPI dictionary_get_HashVal(IDictionary *iface, VARIANT *key, VARIANT *hash)
 787 {
 788     dictionary *This = impl_from_IDictionary(iface);
 789
 790     TRACE("(%p)->(%s %p)\n", This, debugstr_variant(key), hash);
 791
 792     V_VT(hash) = VT_I4;
 793     switch (V_VT(key))
 794     {
 795     case VT_BSTR|VT_BYREF:
 796     case VT_BSTR:
 797         V_I4(hash) = get_str_hash(get_key_strptr(key), This->method);
 798         break;
 799     case VT_UI1|VT_BYREF:
 800     case VT_UI1:
 801         V_I4(hash) = get_num_hash(V_VT(key) & VT_BYREF ? *V_UI1REF(key) : V_UI1(key));
 802         break;
 803     case VT_I2|VT_BYREF:
 804     case VT_I2:
 805         V_I4(hash) = get_num_hash(V_VT(key) & VT_BYREF ? *V_I2REF(key) : V_I2(key));
 806         break;
 807     case VT_I4|VT_BYREF:
 808     case VT_I4:
 809         V_I4(hash) = get_num_hash(V_VT(key) & VT_BYREF ? *V_I4REF(key) : V_I4(key));
 810         break;
 811     case VT_UNKNOWN|VT_BYREF:
 812     case VT_DISPATCH|VT_BYREF:
 813     case VT_UNKNOWN:
 814     case VT_DISPATCH:
 815     {
 816         IUnknown *src = (V_VT(key) & VT_BYREF) ? *V_UNKNOWNREF(key) : V_UNKNOWN(key);
 817         IUnknown *unk = NULL;
 818
 819         if (!src) {
 820             V_I4(hash) = 0;
 821             return S_OK;
 822         }
 823
 824         IUnknown_QueryInterface(src, &IID_IUnknown, (void**)&unk);
 825         if (!unk) {
 826             V_I4(hash) = ~0u;
 827             return CTL_E_ILLEGALFUNCTIONCALL;
 828         }
 829         V_I4(hash) = get_ptr_hash(unk);
 830         IUnknown_Release(unk);
 831         break;
 832     }
 833     case VT_DATE|VT_BYREF:
 834     case VT_DATE:
 835         return get_flt_hash(V_VT(key) & VT_BYREF ? *V_DATEREF(key) : V_DATE(key), &V_I4(hash));
 836     case VT_R4|VT_BYREF:
 837     case VT_R4:
 838         return get_flt_hash(V_VT(key) & VT_BYREF ? *V_R4REF(key) : V_R4(key), &V_I4(hash));
 839     case VT_R8|VT_BYREF:
 840     case VT_R8:
 841         return get_flt_hash(V_VT(key) & VT_BYREF ? *V_R8REF(key) : V_R8(key), &V_I4(hash));
 842     case VT_INT:
 843     case VT_UINT:
 844     case VT_I1:
 845     case VT_I8:
 846     case VT_UI2:
 847     case VT_UI4:
 848         V_I4(hash) = ~0u;
 849         return CTL_E_ILLEGALFUNCTIONCALL;
 850     default:
 851         FIXME("not implemented for type %d\n", V_VT(key));
 852         return E_NOTIMPL;
 853     }
 854
 855     return S_OK;
 856 }
 857
 858 static const struct IDictionaryVtbl dictionary_vtbl =
 859 {
 860     dictionary_QueryInterface,
 861     dictionary_AddRef,
 862     dictionary_Release,
 863     dictionary_GetTypeInfoCount,
 864     dictionary_GetTypeInfo,
 865     dictionary_GetIDsOfNames,
 866     dictionary_Invoke,
 867     dictionary_putref_Item,
 868     dictionary_put_Item,
 869     dictionary_get_Item,
 870     dictionary_Add,
 871     dictionary_get_Count,
 872     dictionary_Exists,
 873     dictionary_Items,
 874     dictionary_put_Key,
 875     dictionary_Keys,
 876     dictionary_Remove,
 877     dictionary_RemoveAll,
 878     dictionary_put_CompareMode,
 879     dictionary_get_CompareMode,
 880     dictionary__NewEnum,
 881     dictionary_get_HashVal
 882 };
 883
 884 HRESULT WINAPI Dictionary_CreateInstance(IClassFactory *factory,IUnknown *outer,REFIID riid, void **obj)
 885 {
 886     dictionary *This;
 887
 888     TRACE("(%p)\n", obj);
 889
 890     *obj = NULL;
 891
 892     This = heap_alloc(sizeof(*This));
 893     if(!This) return E_OUTOFMEMORY;
 894
 895     This->IDictionary_iface.lpVtbl = &dictionary_vtbl;
 896     This->ref = 1;
 897     This->method = BinaryCompare;
 898     This->count = 0;
 899     list_init(&This->pairs);
 900     list_init(&This->notifier);
 901     memset(This->buckets, 0, sizeof(This->buckets));
 902
 903     *obj = &This->IDictionary_iface;
 904
 905     return S_OK;
 906 }