#include <stdarg.h>
#include <math.h>
#include "windef.h"
#include "winbase.h"
#include "ole2.h"
#include "olectl.h"
#include "dispex.h"
#include "scrrun.h"
#include "scrrun_private.h"
#include "wine/debug.h"
#include "wine/list.h"

Include dependency graph for dictionary.c:

Classes
struct	keyitem_pair

struct	dictionary

struct	dictionary_enum

Macros
#define	COBJMACROS

#define	BUCKET_COUNT 509

#define	DICT_HASH_MOD 1201

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (scrrun)

static struct dictionary *	impl_from_IDictionary (IDictionary *iface)

static struct dictionary_enum *	impl_from_IEnumVARIANT (IEnumVARIANT *iface)

static struct list *	get_bucket_head (struct dictionary *dict, DWORD hash)

static BOOL	is_string_key (const VARIANT *key)

static BOOL	is_ptr_key (const VARIANT *key)

static BOOL	is_numeric_key (const VARIANT *key)

static WCHAR *	get_key_strptr (const VARIANT *key)

static int	strcmp_key (const struct dictionary dict, const VARIANT key1, const VARIANT *key2)

static BOOL	numeric_key_eq (const VARIANT key1, const VARIANT key2)

static BOOL	is_matching_key (const struct dictionary dict, const struct keyitem_pair pair, const VARIANT *key, DWORD hash)

static struct keyitem_pair *	get_keyitem_pair (struct dictionary dict, VARIANT key)

static HRESULT	add_keyitem_pair (struct dictionary dict, VARIANT key, VARIANT *item)

static void	free_keyitem_pair (struct keyitem_pair *pair)

static HRESULT WINAPI	dict_enum_QueryInterface (IEnumVARIANT iface, REFIID riid, void *obj)

static ULONG WINAPI	dict_enum_AddRef (IEnumVARIANT *iface)

static ULONG WINAPI	dict_enum_Release (IEnumVARIANT *iface)

static HRESULT WINAPI	dict_enum_Next (IEnumVARIANT iface, ULONG count, VARIANT keys, ULONG *fetched)

static HRESULT WINAPI	dict_enum_Skip (IEnumVARIANT *iface, ULONG count)

static HRESULT WINAPI	dict_enum_Reset (IEnumVARIANT *iface)

static HRESULT	create_dict_enum (struct dictionary , IUnknown *)

static HRESULT WINAPI	dict_enum_Clone (IEnumVARIANT iface, IEnumVARIANT *cloned)

static void	notify_remove_pair (struct list notifier, struct list pair)

static HRESULT WINAPI	dictionary_QueryInterface (IDictionary iface, REFIID riid, void *obj)

static ULONG WINAPI	dictionary_AddRef (IDictionary *iface)

static ULONG WINAPI	dictionary_Release (IDictionary *iface)

static HRESULT WINAPI	dictionary_GetTypeInfoCount (IDictionary iface, UINT pctinfo)

static HRESULT WINAPI	dictionary_GetTypeInfo (IDictionary iface, UINT iTInfo, LCID lcid, ITypeInfo *ppTInfo)

static HRESULT WINAPI	dictionary_GetIDsOfNames (IDictionary iface, REFIID riid, LPOLESTR rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)

static HRESULT WINAPI	dictionary_Invoke (IDictionary iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS pDispParams, VARIANT pVarResult, EXCEPINFO pExcepInfo, UINT *puArgErr)

static HRESULT WINAPI	dictionary_putref_Item (IDictionary iface, VARIANT key, VARIANT *item)

static HRESULT WINAPI	dictionary_put_Item (IDictionary iface, VARIANT key, VARIANT *item)

static HRESULT WINAPI	dictionary_get_Item (IDictionary iface, VARIANT key, VARIANT *item)

static HRESULT WINAPI	dictionary_Add (IDictionary iface, VARIANT key, VARIANT *item)

static HRESULT WINAPI	dictionary_get_Count (IDictionary iface, LONG count)

static HRESULT WINAPI	dictionary_Exists (IDictionary iface, VARIANT key, VARIANT_BOOL *exists)

static HRESULT WINAPI	dictionary_Items (IDictionary iface, VARIANT items)

static HRESULT WINAPI	dictionary_put_Key (IDictionary iface, VARIANT key, VARIANT *newkey)

static HRESULT WINAPI	dictionary_Keys (IDictionary iface, VARIANT keys)

static HRESULT WINAPI	dictionary_Remove (IDictionary iface, VARIANT key)

static HRESULT WINAPI	dictionary_RemoveAll (IDictionary *iface)

static HRESULT WINAPI	dictionary_put_CompareMode (IDictionary *iface, CompareMethod method)

static HRESULT WINAPI	dictionary_get_CompareMode (IDictionary iface, CompareMethod method)

static HRESULT WINAPI	dictionary__NewEnum (IDictionary iface, IUnknown *ret)

static DWORD	get_str_hash (const WCHAR *str, CompareMethod method)

static DWORD	get_num_hash (FLOAT num)

static HRESULT	get_flt_hash (FLOAT flt, LONG *hash)

static DWORD	get_ptr_hash (void *ptr)

static HRESULT WINAPI	dictionary_get_HashVal (IDictionary iface, VARIANT key, VARIANT *hash)

HRESULT WINAPI	Dictionary_CreateInstance (IClassFactory factory, IUnknown outer, REFIID riid, void **ret)

Variables
static const IEnumVARIANTVtbl	dictenumvtbl

static const struct IDictionaryVtbl	dictionary_vtbl

Macro Definition Documentation

◆ BUCKET_COUNT

#define BUCKET_COUNT 509

Definition at line 41 of file dictionary.c.

◆ COBJMACROS

#define COBJMACROS

Definition at line 19 of file dictionary.c.

◆ DICT_HASH_MOD

#define DICT_HASH_MOD 1201

Definition at line 42 of file dictionary.c.

Function Documentation

◆ add_keyitem_pair()

static HRESULT add_keyitem_pair	(	struct dictionary *	dict,
		VARIANT *	key,
		VARIANT *	item
	)

static

Definition at line 241 of file dictionary.c.

{
    struct keyitem_pair *pair;
    struct list *head;
    VARIANT hash;
    HRESULT hr;
 
    hr = IDictionary_get_HashVal(&dict->IDictionary_iface, key, &hash);
    if (FAILED(hr))
        return hr;
 
    if (!(pair = malloc(sizeof(*pair))))
        return E_OUTOFMEMORY;
 
    pair->hash = V_I4(&hash);
    VariantInit(&pair->key);
    VariantInit(&pair->item);
 
    hr = VariantCopyInd(&pair->key, key);
    if (FAILED(hr))
        goto failed;
 
    hr = VariantCopyInd(&pair->item, item);
    if (FAILED(hr))
        goto failed;
 
    head = get_bucket_head(dict, pair->hash);
    if (!head->next)
        /* this only happens once per bucket */
        list_init(head);
 
    /* link to bucket list and to full list */
    list_add_tail(head, &pair->bucket);
    list_add_tail(&dict->pairs, &pair->entry);
    dict->count++;
    return S_OK;
 
failed:
    VariantClear(&pair->key);
    VariantClear(&pair->item);
    free(pair);
    return hr;
}

Referenced by dictionary_Add(), dictionary_put_Item(), and dictionary_putref_Item().

◆ create_dict_enum()

static HRESULT create_dict_enum	(	struct dictionary *	dict,
		IUnknown **	ret
	)

static

Definition at line 411 of file dictionary.c.

{
    struct dictionary_enum *object;
 
    *ret = NULL;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    object->IEnumVARIANT_iface.lpVtbl = &dictenumvtbl;
    object->ref = 1;
    object->cur = list_head(&dict->pairs);
    list_add_tail(&dict->notifier, &object->notify);
    object->dict = dict;
    IDictionary_AddRef(&dict->IDictionary_iface);
 
    *ret = (IUnknown *)&object->IEnumVARIANT_iface;
 
    return S_OK;
}

Referenced by dict_enum_Clone(), and dictionary__NewEnum().

◆ dict_enum_AddRef()

static ULONG WINAPI dict_enum_AddRef ( IEnumVARIANT * iface )

static

Definition at line 310 of file dictionary.c.

{
    struct dictionary_enum *This = impl_from_IEnumVARIANT(iface);
    ULONG ref = InterlockedIncrement(&This->ref);
    TRACE("%p, refcount %lu.\n", iface, ref);
    return ref;
}

◆ dict_enum_Clone()

static HRESULT WINAPI dict_enum_Clone	(	IEnumVARIANT *	iface,
		IEnumVARIANT **	cloned
	)

static

Definition at line 394 of file dictionary.c.

{
    struct dictionary_enum *This = impl_from_IEnumVARIANT(iface);
    TRACE("(%p)->(%p)\n", This, cloned);
    return create_dict_enum(This->dict, (IUnknown**)cloned);
}

◆ dict_enum_Next()

static HRESULT WINAPI dict_enum_Next	(	IEnumVARIANT *	iface,
		ULONG	count,
		VARIANT *	keys,
		ULONG *	fetched
	)

static

Definition at line 335 of file dictionary.c.

{
    struct dictionary_enum *This = impl_from_IEnumVARIANT(iface);
    struct keyitem_pair *pair;
    ULONG i = 0;
 
    TRACE("%p, %lu, %p, %p.\n", iface, count, keys, fetched);
 
    if (fetched)
        *fetched = 0;
 
    if (!count)
        return S_OK;
 
    while (This->cur && i < count) {
        pair = LIST_ENTRY(This->cur, struct keyitem_pair, entry);
        VariantCopy(&keys[i], &pair->key);
        This->cur = list_next(&This->dict->pairs, This->cur);
        i++;
    }
 
    if (fetched)
        *fetched = i;
 
    return i < count ? S_FALSE : S_OK;
}

◆ dict_enum_QueryInterface()

static HRESULT WINAPI dict_enum_QueryInterface	(	IEnumVARIANT *	iface,
		REFIID	riid,
		void **	obj
	)

static

Definition at line 292 of file dictionary.c.

{
    struct dictionary_enum *This = impl_from_IEnumVARIANT(iface);
 
    TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), obj);
 
    if (IsEqualIID(riid, &IID_IEnumVARIANT) || IsEqualIID(riid, &IID_IUnknown)) {
        *obj = iface;
        IEnumVARIANT_AddRef(iface);
        return S_OK;
    }
    else {
        WARN("interface not supported %s\n", debugstr_guid(riid));
        *obj = NULL;
        return E_NOINTERFACE;
    }
}

◆ dict_enum_Release()

static ULONG WINAPI dict_enum_Release ( IEnumVARIANT * iface )

static

Definition at line 318 of file dictionary.c.

{
    struct dictionary_enum *This = impl_from_IEnumVARIANT(iface);
    LONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("%p, refcount %lu.\n", iface, ref);
 
    if (!ref)
    {
        list_remove(&This->notify);
        IDictionary_Release(&This->dict->IDictionary_iface);
        free(This);
    }
 
    return ref;
}

◆ dict_enum_Reset()

static HRESULT WINAPI dict_enum_Reset ( IEnumVARIANT * iface )

static

Definition at line 382 of file dictionary.c.

{
    struct dictionary_enum *This = impl_from_IEnumVARIANT(iface);
 
    TRACE("(%p)\n", This);
 
    This->cur = list_head(&This->dict->pairs);
    return S_OK;
}

◆ dict_enum_Skip()

static HRESULT WINAPI dict_enum_Skip	(	IEnumVARIANT *	iface,
		ULONG	count
	)

static

Definition at line 362 of file dictionary.c.

{
    struct dictionary_enum *This = impl_from_IEnumVARIANT(iface);
 
    TRACE("%p, %lu.\n", iface, count);
 
    if (!count)
        return S_OK;
 
    if (!This->cur)
        return S_FALSE;
 
    while (count--) {
        This->cur = list_next(&This->dict->pairs, This->cur);
        if (!This->cur) break;
    }
 
    return count == 0 ? S_OK : S_FALSE;
}

◆ dictionary__NewEnum()

static HRESULT WINAPI dictionary__NewEnum	(	IDictionary *	iface,
		IUnknown **	ret
	)

static

Definition at line 813 of file dictionary.c.

{
    struct dictionary *dictionary = impl_from_IDictionary(iface);
 
    TRACE("%p, %p.\n", iface, ret);
 
    return create_dict_enum(dictionary, ret);
}

◆ dictionary_Add()

static HRESULT WINAPI dictionary_Add	(	IDictionary *	iface,
		VARIANT *	key,
		VARIANT *	item
	)

static

Definition at line 609 of file dictionary.c.

{
    struct dictionary *dictionary = impl_from_IDictionary(iface);
 
    TRACE("%p, %s, %s.\n", iface, debugstr_variant(key), debugstr_variant(item));
 
    if (get_keyitem_pair(dictionary, key))
        return CTL_E_KEY_ALREADY_EXISTS;
 
    return add_keyitem_pair(dictionary, key, item);
}

◆ dictionary_AddRef()

static ULONG WINAPI dictionary_AddRef ( IDictionary * iface )

static

Definition at line 487 of file dictionary.c.

{
    struct dictionary *dictionary = impl_from_IDictionary(iface);
    ULONG ref = InterlockedIncrement(&dictionary->ref);
 
    TRACE("%p, refcount %lu.\n", iface, ref);
 
    return ref;
}

◆ Dictionary_CreateInstance()

HRESULT WINAPI Dictionary_CreateInstance	(	IClassFactory *	factory,
		IUnknown *	outer,
		REFIID	riid,
		void **	ret
	)

Definition at line 972 of file dictionary.c.

{
    struct dictionary *object;
 
    TRACE("(%p, %p, %s, %p)\n", factory, outer, debugstr_guid(riid), ret);
 
    *ret = NULL;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    object->IDictionary_iface.lpVtbl = &dictionary_vtbl;
    object->ref = 1;
    object->method = BinaryCompare;
    list_init(&object->pairs);
    list_init(&object->notifier);
 
    init_classinfo(&CLSID_Dictionary, (IUnknown *)&object->IDictionary_iface, &object->classinfo);
 
    *ret = &object->IDictionary_iface;
 
    return S_OK;
}

◆ dictionary_Exists()

static HRESULT WINAPI dictionary_Exists	(	IDictionary *	iface,
		VARIANT *	key,
		VARIANT_BOOL *	exists
	)

static

Definition at line 631 of file dictionary.c.

{
    struct dictionary *dictionary = impl_from_IDictionary(iface);
 
    TRACE("%p, %s, %p.\n", iface, debugstr_variant(key), exists);
 
    if (!exists)
        return CTL_E_ILLEGALFUNCTIONCALL;
 
    *exists = get_keyitem_pair(dictionary, key) != NULL ? VARIANT_TRUE : VARIANT_FALSE;
    return S_OK;
}

◆ dictionary_get_CompareMode()

static HRESULT WINAPI dictionary_get_CompareMode	(	IDictionary *	iface,
		CompareMethod *	method
	)

static

Definition at line 803 of file dictionary.c.

{
    struct dictionary *dictionary = impl_from_IDictionary(iface);
 
    TRACE("%p, %p.\n", iface, method);
 
    *method = dictionary->method;
    return S_OK;
}

◆ dictionary_get_Count()

static HRESULT WINAPI dictionary_get_Count	(	IDictionary *	iface,
		LONG *	count
	)

static

Definition at line 621 of file dictionary.c.

{
    struct dictionary *dictionary = impl_from_IDictionary(iface);
 
    TRACE("%p, %p.\n", iface, count);
 
    *count = dictionary->count;
    return S_OK;
}

◆ dictionary_get_HashVal()

static HRESULT WINAPI dictionary_get_HashVal	(	IDictionary *	iface,
		VARIANT *	key,
		VARIANT *	hash
	)

static

Definition at line 870 of file dictionary.c.

{
    struct dictionary *dictionary = impl_from_IDictionary(iface);
 
    TRACE("%p, %s, %p.\n", iface, debugstr_variant(key), hash);
 
    V_VT(hash) = VT_I4;
    switch (V_VT(key))
    {
    case VT_BSTR|VT_BYREF:
    case VT_BSTR:
        V_I4(hash) = get_str_hash(get_key_strptr(key), dictionary->method);
        break;
    case VT_UI1|VT_BYREF:
    case VT_UI1:
        V_I4(hash) = get_num_hash(V_VT(key) & VT_BYREF ? *V_UI1REF(key) : V_UI1(key));
        break;
    case VT_I2|VT_BYREF:
    case VT_I2:
        V_I4(hash) = get_num_hash(V_VT(key) & VT_BYREF ? *V_I2REF(key) : V_I2(key));
        break;
    case VT_I4|VT_BYREF:
    case VT_I4:
        V_I4(hash) = get_num_hash(V_VT(key) & VT_BYREF ? *V_I4REF(key) : V_I4(key));
        break;
    case VT_UNKNOWN|VT_BYREF:
    case VT_DISPATCH|VT_BYREF:
    case VT_UNKNOWN:
    case VT_DISPATCH:
    {
        IUnknown *src = (V_VT(key) & VT_BYREF) ? *V_UNKNOWNREF(key) : V_UNKNOWN(key);
        IUnknown *unk = NULL;
 
        if (!src) {
            V_I4(hash) = 0;
            return S_OK;
        }
 
        IUnknown_QueryInterface(src, &IID_IUnknown, (void**)&unk);
        if (!unk) {
            V_I4(hash) = ~0u;
            return CTL_E_ILLEGALFUNCTIONCALL;
        }
        V_I4(hash) = get_ptr_hash(unk);
        IUnknown_Release(unk);
        break;
    }
    case VT_DATE|VT_BYREF:
    case VT_DATE:
        return get_flt_hash(V_VT(key) & VT_BYREF ? *V_DATEREF(key) : V_DATE(key), &V_I4(hash));
    case VT_R4|VT_BYREF:
    case VT_R4:
        return get_flt_hash(V_VT(key) & VT_BYREF ? *V_R4REF(key) : V_R4(key), &V_I4(hash));
    case VT_R8|VT_BYREF:
    case VT_R8:
        return get_flt_hash(V_VT(key) & VT_BYREF ? *V_R8REF(key) : V_R8(key), &V_I4(hash));
    case VT_EMPTY:
    case VT_NULL:
        V_I4(hash) = 0;
        return S_OK;
    case VT_INT:
    case VT_UINT:
    case VT_I1:
    case VT_I8:
    case VT_UI2:
    case VT_UI4:
        V_I4(hash) = ~0u;
        return CTL_E_ILLEGALFUNCTIONCALL;
    default:
        FIXME("not implemented for type %d\n", V_VT(key));
        return E_NOTIMPL;
    }
 
    return S_OK;
}

◆ dictionary_get_Item()

static HRESULT WINAPI dictionary_get_Item	(	IDictionary *	iface,
		VARIANT *	key,
		VARIANT *	item
	)

static

Definition at line 592 of file dictionary.c.

{
    struct dictionary *dictionary = impl_from_IDictionary(iface);
    struct keyitem_pair *pair;
 
    TRACE("%p, %s, %p.\n", iface, debugstr_variant(key), item);
 
    if ((pair = get_keyitem_pair(dictionary, key)))
        VariantCopy(item, &pair->item);
    else {
        VariantInit(item);
        return IDictionary_Add(iface, key, item);
    }
 
    return S_OK;
}

◆ dictionary_GetIDsOfNames()

static HRESULT WINAPI dictionary_GetIDsOfNames	(	IDictionary *	iface,
		REFIID	riid,
		LPOLESTR *	rgszNames,
		UINT	cNames,
		LCID	lcid,
		DISPID *	rgDispId
	)

static

Definition at line 528 of file dictionary.c.

{
    ITypeInfo *typeinfo;
    HRESULT hr;
 
    TRACE("%p, %s, %p, %u, %lx, %p.\n", iface, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 
    hr = get_typeinfo(IDictionary_tid, &typeinfo);
    if(SUCCEEDED(hr))
    {
        hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
        ITypeInfo_Release(typeinfo);
    }
 
    return hr;
}

◆ dictionary_GetTypeInfo()

static HRESULT WINAPI dictionary_GetTypeInfo	(	IDictionary *	iface,
		UINT	iTInfo,
		LCID	lcid,
		ITypeInfo **	ppTInfo
	)

static

Definition at line 521 of file dictionary.c.

{
    TRACE("%p, %u, %lx, %p.\n", iface, iTInfo, lcid, ppTInfo);
 
    return get_typeinfo(IDictionary_tid, ppTInfo);
}

◆ dictionary_GetTypeInfoCount()

static HRESULT WINAPI dictionary_GetTypeInfoCount	(	IDictionary *	iface,
		UINT *	pctinfo
	)

static

Definition at line 513 of file dictionary.c.

{
    TRACE("%p, %p.\n", iface, pctinfo);
 
    *pctinfo = 1;
    return S_OK;
}

◆ dictionary_Invoke()

static HRESULT WINAPI dictionary_Invoke	(	IDictionary *	iface,
		DISPID	dispIdMember,
		REFIID	riid,
		LCID	lcid,
		WORD	wFlags,
		DISPPARAMS *	pDispParams,
		VARIANT *	pVarResult,
		EXCEPINFO *	pExcepInfo,
		UINT *	puArgErr
	)

static

Definition at line 546 of file dictionary.c.

{
    ITypeInfo *typeinfo;
    HRESULT hr;
 
    TRACE("%p, %ld, %s, %lx, %d, %p, %p, %p, %p.\n", iface, dispIdMember, debugstr_guid(riid),
           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 
    hr = get_typeinfo(IDictionary_tid, &typeinfo);
    if(SUCCEEDED(hr))
    {
        hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
        ITypeInfo_Release(typeinfo);
    }
 
    return hr;
}

◆ dictionary_Items()

static HRESULT WINAPI dictionary_Items	(	IDictionary *	iface,
		VARIANT *	items
	)

static

Definition at line 644 of file dictionary.c.

{
    struct dictionary *dictionary = impl_from_IDictionary(iface);
    struct keyitem_pair *pair;
    SAFEARRAYBOUND bound;
    SAFEARRAY *sa;
    VARIANT *v;
    HRESULT hr;
    LONG i;
 
    TRACE("%p, %p.\n", iface, items);
 
    if (!items)
        return S_OK;
 
    bound.lLbound = 0;
    bound.cElements = dictionary->count;
    sa = SafeArrayCreate(VT_VARIANT, 1, &bound);
    if (!sa)
        return E_OUTOFMEMORY;
 
    hr = SafeArrayAccessData(sa, (void**)&v);
    if (FAILED(hr)) {
        SafeArrayDestroy(sa);
        return hr;
    }
 
    i = 0;
    LIST_FOR_EACH_ENTRY(pair, &dictionary->pairs, struct keyitem_pair, entry)
    {
        VariantCopy(&v[i], &pair->item);
        i++;
    }
    SafeArrayUnaccessData(sa);
 
    V_VT(items) = VT_ARRAY|VT_VARIANT;
    V_ARRAY(items) = sa;
    return S_OK;
}

◆ dictionary_Keys()

static HRESULT WINAPI dictionary_Keys	(	IDictionary *	iface,
		VARIANT *	keys
	)

static

Definition at line 709 of file dictionary.c.

{
    struct dictionary *dictionary = impl_from_IDictionary(iface);
    struct keyitem_pair *pair;
    SAFEARRAYBOUND bound;
    SAFEARRAY *sa;
    VARIANT *v;
    HRESULT hr;
    LONG i;
 
    TRACE("%p, %p.\n", iface, keys);
 
    if (!keys)
        return S_OK;
 
    bound.lLbound = 0;
    bound.cElements = dictionary->count;
    sa = SafeArrayCreate(VT_VARIANT, 1, &bound);
    if (!sa)
        return E_OUTOFMEMORY;
 
    hr = SafeArrayAccessData(sa, (void**)&v);
    if (FAILED(hr)) {
        SafeArrayDestroy(sa);
        return hr;
    }
 
    i = 0;
    LIST_FOR_EACH_ENTRY(pair, &dictionary->pairs, struct keyitem_pair, entry)
    {
        VariantCopy(&v[i], &pair->key);
        i++;
    }
    SafeArrayUnaccessData(sa);
 
    V_VT(keys) = VT_ARRAY|VT_VARIANT;
    V_ARRAY(keys) = sa;
    return S_OK;
}

◆ dictionary_put_CompareMode()

static HRESULT WINAPI dictionary_put_CompareMode	(	IDictionary *	iface,
		CompareMethod	method
	)

static

Definition at line 790 of file dictionary.c.

{
    struct dictionary *dictionary = impl_from_IDictionary(iface);
 
    TRACE("%p, %d.\n", iface, method);
 
    if (dictionary->count)
        return CTL_E_ILLEGALFUNCTIONCALL;
 
    dictionary->method = method;
    return S_OK;
}

◆ dictionary_put_Item()

static HRESULT WINAPI dictionary_put_Item	(	IDictionary *	iface,
		VARIANT *	key,
		VARIANT *	item
	)

static

Definition at line 579 of file dictionary.c.

{
    struct dictionary *dictionary = impl_from_IDictionary(iface);
    struct keyitem_pair *pair;
 
    TRACE("%p, %s, %s.\n", iface, debugstr_variant(key), debugstr_variant(item));
 
    if ((pair = get_keyitem_pair(dictionary, key)))
        return VariantCopyInd(&pair->item, item);
 
    return add_keyitem_pair(dictionary, key, item);
}

◆ dictionary_put_Key()

static HRESULT WINAPI dictionary_put_Key	(	IDictionary *	iface,
		VARIANT *	key,
		VARIANT *	newkey
	)

static

Definition at line 684 of file dictionary.c.

{
    struct dictionary *dictionary = impl_from_IDictionary(iface);
    struct keyitem_pair *pair;
    VARIANT empty;
    HRESULT hr;
 
    TRACE("%p, %s, %s.\n", iface, debugstr_variant(key), debugstr_variant(newkey));
 
    if ((pair = get_keyitem_pair(dictionary, key)))
    {
        /* found existing pair for a key, add new pair with new key
           and old item and remove old pair after that */
 
        hr = IDictionary_Add(iface, newkey, &pair->item);
        if (FAILED(hr))
            return hr;
 
        return IDictionary_Remove(iface, key);
    }
 
    VariantInit(&empty);
    return IDictionary_Add(iface, newkey, &empty);
}

◆ dictionary_putref_Item()

static HRESULT WINAPI dictionary_putref_Item	(	IDictionary *	iface,
		VARIANT *	key,
		VARIANT *	item
	)

static

Definition at line 566 of file dictionary.c.

{
    struct dictionary *dictionary = impl_from_IDictionary(iface);
    struct keyitem_pair *pair;
 
    TRACE("%p, %s, %s.\n", iface, debugstr_variant(key), debugstr_variant(item));
 
    if ((pair = get_keyitem_pair(dictionary, key)))
        return VariantCopyInd(&pair->item, item);
 
    return add_keyitem_pair(dictionary, key, item);
}

◆ dictionary_QueryInterface()

static HRESULT WINAPI dictionary_QueryInterface	(	IDictionary *	iface,
		REFIID	riid,
		void **	obj
	)

static

Definition at line 447 of file dictionary.c.

{
    struct dictionary *dictionary = impl_from_IDictionary(iface);
 
    TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 
    *obj = NULL;
 
    if(IsEqualIID(riid, &IID_IUnknown) ||
       IsEqualIID(riid, &IID_IDispatch) ||
       IsEqualIID(riid, &IID_IDictionary))
    {
        *obj = &dictionary->IDictionary_iface;
    }
    else if (IsEqualIID(riid, &IID_IProvideClassInfo))
    {
        *obj = &dictionary->classinfo.IProvideClassInfo_iface;
    }
    else if ( IsEqualGUID( riid, &IID_IDispatchEx ))
    {
        TRACE("Interface IDispatchEx not supported - returning NULL\n");
        *obj = NULL;
        return E_NOINTERFACE;
    }
    else if ( IsEqualGUID( riid, &IID_IObjectWithSite ))
    {
        TRACE("Interface IObjectWithSite not supported - returning NULL\n");
        *obj = NULL;
        return E_NOINTERFACE;
    }
    else
    {
        WARN("interface %s not implemented\n", debugstr_guid(riid));
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown*)*obj);
    return S_OK;
}

◆ dictionary_Release()

static ULONG WINAPI dictionary_Release ( IDictionary * iface )

static

Definition at line 497 of file dictionary.c.

{
    struct dictionary *dictionary = impl_from_IDictionary(iface);
    ULONG ref = InterlockedDecrement(&dictionary->ref);
 
    TRACE("%p, refcount %lu.\n", iface, ref);
 
    if (!ref)
    {
        IDictionary_RemoveAll(iface);
        free(dictionary);
    }
 
    return ref;
}

◆ dictionary_Remove()

static HRESULT WINAPI dictionary_Remove	(	IDictionary *	iface,
		VARIANT *	key
	)

static

Definition at line 749 of file dictionary.c.

{
    struct dictionary *dictionary = impl_from_IDictionary(iface);
    struct keyitem_pair *pair;
 
    TRACE("%p, %s.\n", iface, debugstr_variant(key));
 
    if (!(pair = get_keyitem_pair(dictionary, key)))
        return CTL_E_ELEMENT_NOT_FOUND;
 
    notify_remove_pair(&dictionary->notifier, &pair->entry);
    list_remove(&pair->entry);
    list_remove(&pair->bucket);
    dictionary->count--;
 
    free_keyitem_pair(pair);
    return S_OK;
}

◆ dictionary_RemoveAll()

static HRESULT WINAPI dictionary_RemoveAll ( IDictionary * iface )

static

Definition at line 768 of file dictionary.c.

{
    struct dictionary *dictionary = impl_from_IDictionary(iface);
    struct keyitem_pair *pair, *pair2;
 
    TRACE("%p.\n", iface);
 
    if (!dictionary->count)
        return S_OK;
 
    notify_remove_pair(&dictionary->notifier, NULL);
    LIST_FOR_EACH_ENTRY_SAFE(pair, pair2, &dictionary->pairs, struct keyitem_pair, entry)
    {
        list_remove(&pair->entry);
        list_remove(&pair->bucket);
        free_keyitem_pair(pair);
    }
    dictionary->count = 0;
 
    return S_OK;
}

◆ free_keyitem_pair()

static void free_keyitem_pair ( struct keyitem_pair * pair )

static

Definition at line 285 of file dictionary.c.

{
    VariantClear(&pair->key);
    VariantClear(&pair->item);
    free(pair);
}

Referenced by dictionary_Remove(), and dictionary_RemoveAll().

◆ get_bucket_head()

static struct list * get_bucket_head	(	struct dictionary *	dict,
		DWORD	hash
	)

inlinestatic

Definition at line 101 of file dictionary.c.

{
    return &dict->buckets[hash % BUCKET_COUNT];
}

Referenced by add_keyitem_pair(), and get_keyitem_pair().

◆ get_flt_hash()

static HRESULT get_flt_hash	(	FLOAT	flt,
		LONG *	hash
	)

static

Definition at line 845 of file dictionary.c.

{
    if (isinf(flt)) {
        *hash = 0;
        return S_OK;
    }
    else if (!isnan(flt)) {
        *hash = get_num_hash(flt);
        return S_OK;
    }
 
    /* NaN case */
    *hash = ~0u;
    return CTL_E_ILLEGALFUNCTIONCALL;
}

Referenced by dictionary_get_HashVal().

◆ get_key_strptr()

static WCHAR * get_key_strptr ( const VARIANT * key )

inlinestatic

Definition at line 133 of file dictionary.c.

{
    if (V_VT(key) == VT_BSTR)
        return V_BSTR(key);
 
    if (V_BSTRREF(key))
        return *V_BSTRREF(key);
 
    return NULL;
}

Referenced by dictionary_get_HashVal(), and strcmp_key().

◆ get_keyitem_pair()

static struct keyitem_pair * get_keyitem_pair	(	struct dictionary *	dict,
		VARIANT *	key
	)

static

Definition at line 206 of file dictionary.c.

{
    struct keyitem_pair *pair;
    struct list *head, *entry;
    VARIANT hash, v;
    HRESULT hr;
 
    hr = IDictionary_get_HashVal(&dict->IDictionary_iface, key, &hash);
    if (FAILED(hr))
        return NULL;
 
    head = get_bucket_head(dict, V_I4(&hash));
    if (!head->next || list_empty(head))
        return NULL;
 
    VariantInit(&v);
    if (FAILED(VariantCopyInd(&v, key)))
        return NULL;
 
    entry = list_head(head);
    do
    {
        pair = LIST_ENTRY(entry, struct keyitem_pair, bucket);
        if (is_matching_key(dict, pair, &v, V_I4(&hash)))
        {
            VariantClear(&v);
            return pair;
        }
    } while ((entry = list_next(head, entry)));
 
    VariantClear(&v);
 
    return NULL;
}

Referenced by dictionary_Add(), dictionary_Exists(), dictionary_get_Item(), dictionary_put_Item(), dictionary_put_Key(), dictionary_putref_Item(), and dictionary_Remove().

◆ get_num_hash()

static DWORD get_num_hash ( FLOAT num )

static

Definition at line 840 of file dictionary.c.

{
    return (*((DWORD*)&num)) % DICT_HASH_MOD;
}

Referenced by dictionary_get_HashVal(), get_flt_hash(), and test_hash_value().

◆ get_ptr_hash()

static DWORD get_ptr_hash ( void * ptr )

static

Definition at line 861 of file dictionary.c.

{
    DWORD hash = PtrToUlong(ptr);
#ifdef _WIN64
    hash ^= (ULONG_PTR)ptr >> 32;
#endif
    return hash % 1201;
}

Referenced by dictionary_get_HashVal(), and test_hash_value().

◆ get_str_hash()

static DWORD get_str_hash	(	const WCHAR *	str,
		CompareMethod	method
	)

static

Definition at line 822 of file dictionary.c.

{
    DWORD hash = 0;
 
    if (str) {
        while (*str) {
            WCHAR ch;
 
            ch = (method == TextCompare || method == DatabaseCompare) ? towlower(*str) : *str;
 
            hash += (hash << 4) + ch;
            str++;
        }
    }
 
    return hash % DICT_HASH_MOD;
}

Referenced by dictionary_get_HashVal(), and test_hash_value().

◆ impl_from_IDictionary()

static struct dictionary * impl_from_IDictionary ( IDictionary * iface )

inlinestatic

Definition at line 91 of file dictionary.c.

{
    return CONTAINING_RECORD(iface, struct dictionary, IDictionary_iface);
}

Referenced by dictionary__NewEnum(), dictionary_Add(), dictionary_AddRef(), dictionary_Exists(), dictionary_get_CompareMode(), dictionary_get_Count(), dictionary_get_HashVal(), dictionary_get_Item(), dictionary_Items(), dictionary_Keys(), dictionary_put_CompareMode(), dictionary_put_Item(), dictionary_put_Key(), dictionary_putref_Item(), dictionary_QueryInterface(), dictionary_Release(), dictionary_Remove(), and dictionary_RemoveAll().

◆ impl_from_IEnumVARIANT()

static struct dictionary_enum * impl_from_IEnumVARIANT ( IEnumVARIANT * iface )

inlinestatic

Definition at line 96 of file dictionary.c.

{
    return CONTAINING_RECORD(iface, struct dictionary_enum, IEnumVARIANT_iface);
}

Referenced by dict_enum_AddRef(), dict_enum_Clone(), dict_enum_Next(), dict_enum_QueryInterface(), dict_enum_Release(), dict_enum_Reset(), and dict_enum_Skip().

◆ is_matching_key()

static BOOL is_matching_key	(	const struct dictionary *	dict,
		const struct keyitem_pair *	pair,
		const VARIANT *	key,
		DWORD	hash
	)

static

Definition at line 169 of file dictionary.c.

{
    if (is_string_key(key) != is_string_key(&pair->key))
    {
        return FALSE;
    }
    else if (is_string_key(key) && is_string_key(&pair->key))
    {
        return hash == pair->hash && !strcmp_key(dict, key, &pair->key);
    }
    else if (is_ptr_key(key) != is_ptr_key(&pair->key))
    {
        return FALSE;
    }
    else if (is_ptr_key(key) && is_ptr_key(&pair->key))
    {
        return hash == pair->hash && V_UNKNOWN(key) == V_UNKNOWN(&pair->key);
    }
    else if (is_numeric_key(key) != is_numeric_key(&pair->key))
    {
        return FALSE;
    }
    else if (is_numeric_key(key) && is_numeric_key(&pair->key))
    {
        return hash == pair->hash && numeric_key_eq(key, &pair->key);
    }
    else if (V_VT(&pair->key) == VT_EMPTY || V_VT(&pair->key) == VT_NULL)
    {
        return V_VT(&pair->key) == V_VT(key);
    }
    else
    {
        WARN("Unexpected key type %#x.\n", V_VT(key));
        return FALSE;
    }
}

Referenced by get_keyitem_pair().

◆ is_numeric_key()

static BOOL is_numeric_key ( const VARIANT * key )

inlinestatic

Definition at line 116 of file dictionary.c.

{
    switch (V_VT(key))
    {
        case VT_UI1:
        case VT_I2:
        case VT_I4:
        case VT_DATE:
        case VT_R4:
        case VT_R8:
            return TRUE;
        default:
            return FALSE;
    }
}

Referenced by is_matching_key().

◆ is_ptr_key()

static BOOL is_ptr_key ( const VARIANT * key )

inlinestatic

Definition at line 111 of file dictionary.c.

{
    return V_VT(key) == VT_UNKNOWN || V_VT(key) == VT_DISPATCH;
}

Referenced by is_matching_key().

◆ is_string_key()

static BOOL is_string_key ( const VARIANT * key )

inlinestatic

Definition at line 106 of file dictionary.c.

{
    return V_VT(key) == VT_BSTR;
}

Referenced by is_matching_key().

◆ notify_remove_pair()

static void notify_remove_pair	(	struct list *	notifier,
		struct list *	pair
	)

static

Definition at line 432 of file dictionary.c.

{
    struct dictionary_enum *dict_enum;
    struct list *cur;
 
    LIST_FOR_EACH(cur, notifier) {
        dict_enum = LIST_ENTRY(cur, struct dictionary_enum, notify);
        if (!pair)
            dict_enum->cur = list_head(&dict_enum->dict->pairs);
        else if (dict_enum->cur == pair) {
            dict_enum->cur = list_next(&dict_enum->dict->pairs, dict_enum->cur);
        }
    }
}

Referenced by dictionary_Remove(), and dictionary_RemoveAll().

◆ numeric_key_eq()

static BOOL numeric_key_eq	(	const VARIANT *	key1,
		const VARIANT *	key2
	)

inlinestatic

Definition at line 154 of file dictionary.c.

{
    VARIANT v1, v2;
 
    VariantInit(&v1);
    if (FAILED(VariantChangeType(&v1, key1, 0, VT_R4)))
        return FALSE;
 
    VariantInit(&v2);
    if (FAILED(VariantChangeType(&v2, key2, 0, VT_R4)))
        return FALSE;
 
    return V_R4(&v1) == V_R4(&v2);
}

Referenced by is_matching_key().

◆ strcmp_key()

static int strcmp_key	(	const struct dictionary *	dict,
		const VARIANT *	key1,
		const VARIANT *	key2
	)

inlinestatic

Definition at line 145 of file dictionary.c.

{
    const WCHAR *str1, *str2;
 
    str1 = get_key_strptr(key1);
    str2 = get_key_strptr(key2);
    return dict->method == BinaryCompare ? wcscmp(str1, str2) : wcsicmp(str1, str2);
}

Referenced by is_matching_key().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( scrrun )

Variable Documentation

◆ dictenumvtbl

const IEnumVARIANTVtbl dictenumvtbl

static

Initial value:

= {
    dict_enum_QueryInterface,
    dict_enum_AddRef,
    dict_enum_Release,
    dict_enum_Next,
    dict_enum_Skip,
    dict_enum_Reset,
    dict_enum_Clone
}

Definition at line 401 of file dictionary.c.

Referenced by create_dict_enum().

◆ dictionary_vtbl

const struct IDictionaryVtbl dictionary_vtbl

static

Initial value:

=
{
    dictionary_QueryInterface,
    dictionary_AddRef,
    dictionary_Release,
    dictionary_GetTypeInfoCount,
    dictionary_GetTypeInfo,
    dictionary_GetIDsOfNames,
    dictionary_Invoke,
    dictionary_putref_Item,
    dictionary_put_Item,
    dictionary_get_Item,
    dictionary_Add,
    dictionary_get_Count,
    dictionary_Exists,
    dictionary_Items,
    dictionary_put_Key,
    dictionary_Keys,
    dictionary_Remove,
    dictionary_RemoveAll,
    dictionary_put_CompareMode,
    dictionary_get_CompareMode,
    dictionary__NewEnum,
    dictionary_get_HashVal
}

Definition at line 946 of file dictionary.c.

Referenced by Dictionary_CreateInstance().

Classes

Macros

Functions

Variables

Macro Definition Documentation

◆ BUCKET_COUNT

◆ COBJMACROS

◆ DICT_HASH_MOD

Function Documentation

◆ add_keyitem_pair()

◆ create_dict_enum()

◆ dict_enum_AddRef()

◆ dict_enum_Clone()

◆ dict_enum_Next()

◆ dict_enum_QueryInterface()

◆ dict_enum_Release()

◆ dict_enum_Reset()

◆ dict_enum_Skip()

◆ dictionary__NewEnum()

◆ dictionary_Add()

◆ dictionary_AddRef()

◆ Dictionary_CreateInstance()

◆ dictionary_Exists()

◆ dictionary_get_CompareMode()

◆ dictionary_get_Count()

◆ dictionary_get_HashVal()

◆ dictionary_get_Item()

◆ dictionary_GetIDsOfNames()

◆ dictionary_GetTypeInfo()

◆ dictionary_GetTypeInfoCount()

◆ dictionary_Invoke()

◆ dictionary_Items()

◆ dictionary_Keys()

◆ dictionary_put_CompareMode()

◆ dictionary_put_Item()

◆ dictionary_put_Key()

◆ dictionary_putref_Item()

◆ dictionary_QueryInterface()

◆ dictionary_Release()

◆ dictionary_Remove()

◆ dictionary_RemoveAll()

◆ free_keyitem_pair()

◆ get_bucket_head()

◆ get_flt_hash()

◆ get_key_strptr()

◆ get_keyitem_pair()

◆ get_num_hash()

◆ get_ptr_hash()

◆ get_str_hash()

◆ impl_from_IDictionary()

◆ impl_from_IEnumVARIANT()

◆ is_matching_key()

◆ is_numeric_key()

◆ is_ptr_key()

◆ is_string_key()

◆ notify_remove_pair()

◆ numeric_key_eq()

◆ strcmp_key()

◆ WINE_DEFAULT_DEBUG_CHANNEL()

Variable Documentation

◆ dictenumvtbl

◆ dictionary_vtbl