/*
* nsfFunPtrHashTable.c --
*
* Provide a custom Tcl hashtable type, using function pointers
* as hash keys, and a slim wrapper around Tcl's hashtable
* API to manage them.
*
* Copyright (C) 2016-2018 Gustaf Neumann
* Copyright (C) 2016 Stefan Sobernig
*
* Vienna University of Economics and Business
* Institute of Information Systems and New Media
* A-1020, Welthandelsplatz 1
* Vienna, Austria
*
* This work is licensed under the MIT License https://www.opensource.org/licenses/MIT
*
* Copyright:
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
*/
#include "nsfInt.h"
/*
* Definitions for HashType funPtr.
*
* Background: since it is not guaranteed that sizeof(function
* pointer) == sizeof(data pointer) (or sizeof(function pointer) <=
* sizeof(data pointer)), passing function pointers via data pointers
* - which is what default Tcl hash types do - is potentially
* dangerous. Therefore, and on top, it is not allowed under ISO
* C. So, we define our own type that allows one to hash on function
* pointers safely.
*
*/
static Tcl_HashKeyProc FunPtrKey;
static Tcl_CompareHashKeysProc CompareFunPtrKeys;
static Tcl_AllocHashEntryProc AllocFunPtrEntry;
typedef struct funPtrEntry_t {
Nsf_AnyFun *funPtr;
} funPtrEntry_t;
static Tcl_HashKeyType funPtrHashKeyType = {
1, /* version*/
0, /* flags */
FunPtrKey, /* hashKeyProc*/
CompareFunPtrKeys, /* compareKeysProc */
AllocFunPtrEntry, /* allocEntryProc */
NULL /* freeEntryProc */
};
/*
*----------------------------------------------------------------------
*
* FunPtrKey --
*
* Computes an unsigned int hash value from a function pointer.
*
* Results:
* Returns the computed hash.
*
* Side effects:
* None.
*
*----------------------------------------------------------------------
*/
static
#if defined TCL_HASH_TYPE
TCL_HASH_TYPE
#else
unsigned int
#endif
FunPtrKey(
Tcl_HashTable *UNUSED(tablePtr), /* Hash table. */
void *keyPtr /* Key from which to compute hash value. */
) {
funPtrEntry_t *e = (funPtrEntry_t *)keyPtr;
Nsf_AnyFun *value = e->funPtr;
/*
* This is a very simple approach for obtaining a hash value. Maybe one
* needs a more sophisticated approach with weird endians machines.
*/
return PTR2UINT(value);
}
/*
*----------------------------------------------------------------------
*
* CompareFunPtrKeys --
*
* Compares two function pointer keys.
*
* Results:
* The return value is 0 if they are different and 1 if they are the
* same.
*
* Side effects:
* None.
*
*----------------------------------------------------------------------
*/
static int
CompareFunPtrKeys(
void *keyPtr, /* New key to compare. */
Tcl_HashEntry *hPtr /* Existing key to compare. */
) {
funPtrEntry_t *e = (funPtrEntry_t *)keyPtr;
Nsf_AnyFun *existingValue;
memcpy(&existingValue, &hPtr->key.oneWordValue, sizeof(Nsf_AnyFun *));
return e->funPtr == existingValue;
}
/*
*----------------------------------------------------------------------
*
* AllocFunPtrEntry --
*
* Allocate space for a Tcl_HashEntry containing the function pointer.
*
* Results:
* The return value is a pointer to the created entry.
*
* Side effects:
* None.
*
*----------------------------------------------------------------------
*/
static Tcl_HashEntry *
AllocFunPtrEntry(
Tcl_HashTable *UNUSED(tablePtr), /* Hash table. */
void *keyPtr /* Key to store in the hash table entry. */
) {
funPtrEntry_t *e = (funPtrEntry_t *)keyPtr;
Tcl_HashEntry *hPtr;
unsigned int size;
Nsf_AnyFun *value = e->funPtr;
size = sizeof(Tcl_HashEntry) + (sizeof(Nsf_AnyFun *)) - sizeof(hPtr->key);
if (size < sizeof(Tcl_HashEntry)) {
size = sizeof(Tcl_HashEntry);
}
hPtr = (Tcl_HashEntry *) ckalloc(size);
memcpy(&hPtr->key.oneWordValue, &value, sizeof(Nsf_AnyFun *));
hPtr->clientData = 0;
return hPtr;
}
/*
*----------------------------------------------------------------------
* Nsf_InitFunPtrHashTable --
*
* Initializes a hash table structure providing for function
* pointers as hash keys. It is a slim wrapper around
* Tcl_InitCustomHashTable().
*
* Results:
* None.
*
* Side effects:
* None.
*
*----------------------------------------------------------------------
*/
void
Nsf_InitFunPtrHashTable(Tcl_HashTable *tablePtr) {
nonnull_assert(tablePtr != NULL);
Tcl_InitCustomHashTable(tablePtr, TCL_CUSTOM_PTR_KEYS, &funPtrHashKeyType);
}
/*
*----------------------------------------------------------------------
* Nsf_CreateFunPtrHashEntry --
*
* Creates or finds an entry based on a given function-pointer
* key. It is a slim wrapper around Tcl_CreateHashEntry().
*
* Results:
* Returns a pointer to the matching entry.
*
* Side effects:
* A new entry may be stored in the hash table.
*
*----------------------------------------------------------------------
*/
Tcl_HashEntry *
Nsf_CreateFunPtrHashEntry(
Tcl_HashTable *tablePtr,
Nsf_AnyFun *key,
int *isNew
) {
Tcl_HashEntry *hPtr;
funPtrEntry_t entry;
nonnull_assert(tablePtr != NULL);
nonnull_assert(key != NULL);
entry.funPtr = key;
hPtr = Tcl_CreateHashEntry(tablePtr, (const char *)&entry, isNew);
return hPtr;
}
/*
*----------------------------------------------------------------------
* Nsf_FindFunPtrHashEntry --
*
* Finds the entry with a matching function-pointer key in a given
* table. It is a slim wrapper around Tcl_FindHashEntry().
*
* Results:
* Returns a pointer to the matching entry, or NULL.
*
* Side effects:
* None.
*
*----------------------------------------------------------------------
*/
Tcl_HashEntry *
Nsf_FindFunPtrHashEntry(Tcl_HashTable *tablePtr, Nsf_AnyFun *key) {
Tcl_HashEntry *hPtr;
funPtrEntry_t entry;
nonnull_assert(tablePtr != NULL);
nonnull_assert(key != NULL);
entry.funPtr = key;
hPtr = Tcl_FindHashEntry(tablePtr, (const char *)&entry);
return hPtr;
}
/*
* Local Variables:
* mode: c
* c-basic-offset: 2
* fill-column: 78
* indent-tabs-mode: nil
* eval: (c-guess)
* End:
*/