Function hashtable_find

hashtable.c:80–185

Returns the node that holds the indicated key if it exists. When it does not * exist, it returns either NULL (when data_when_new is NULL), or it returns a * new node with its node->data set to the indicated value. * * If your code doesn't know the data value for a new node in advance (usually * because it doesn't know if a node is new or not) you should pass in a unique * (non-0) value that

 * This return is a void* just because it might be pointing at a ht_int32_node
 * or a ht_int64_node, and that makes the caller's assignment a little easier. */
void *hashtable_find(struct hashtable *tbl, int64 key, void *data_when_new)
{
	int key64 = tbl->key64;
	struct ht_int32_node *node;
	uint32 ndx;

	if (key64 ? key == 0 : (int32)key == 0) {
		rprintf(FERROR, "Internal hashtable error: illegal key supplied!\n");
		exit_cleanup(RERR_MESSAGEIO);
	}

	if (data_when_new && tbl->entries > HASH_LOAD_LIMIT(tbl->size)) {
		void *old_nodes = tbl->nodes;
		int size = tbl->size * 2;
		int i;

		tbl->nodes = new_array0(char, size * tbl->node_size);
		tbl->size = size;
		tbl->entries = 0;

		if (DEBUG_GTE(HASH, 1)) {
			rprintf(FINFO, "[%s] growing hashtable %lx (size: %d, keys: %d-bit)\n",
				who_am_i(), (long)tbl, size, key64 ? 64 : 32);
		}

		for (i = size / 2; i-- > 0; ) {
			struct ht_int32_node *move_node = HT_NODE(tbl, old_nodes, i);
			int64 move_key = HT_KEY(move_node, key64);
			if (move_key == 0)
				continue;
			if (move_node->data)
				hashtable_find(tbl, move_key, move_node->data);
			else {
				node = hashtable_find(tbl, move_key, "");
				node->data = 0;
			}
		}

		free(old_nodes);
	}

	if (!key64) {
		/* Based on Jenkins One-at-a-time hash. */
		uchar buf[4], *keyp = buf;
		int i;

		SIVALu(buf, 0, key);
		for (ndx = 0, i = 0; i < 4; i++) {
			ndx += keyp[i];
			ndx += (ndx << 10);
			ndx ^= (ndx >> 6);
		}
		ndx += (ndx << 3);
		ndx ^= (ndx >> 11);
		ndx += (ndx << 15);
	} else {
		/* Based on Jenkins hashword() from lookup3.c. */
		uint32 a, b, c;