Christopher Seiwald <seiw...@perforce.com> writes:

He didn't spell it out for me, but I'm guessing that's the case; it's certainly conforming behavior. Actually, looking at it closely, it seems to be conforming behavior for any platform regardless of word size. I don't think I like the suggested fix because it's highly platform-specific. Instead I would just use unsigned integer types. According to the 6.2.5/9 in the 'C' standard,

"A computation involving unsigned operands can never overflow, because a result that cannot be represented by the resulting unsigned integer type is reduced modulo the number that is one greater than the largest value that can be represented by the resulting type."

Then I'd go with:

int /* if you insist, but should be unsigned */ hashitem( register struct hash *hp, HASHDATA **data, int enter ) { ITEM **base; register ITEM *i; char *b = (*data)->key; unsigned keyval;

if( enter && !hp->items.more ) hashrehash( hp );

if( !enter && !hp->items.nel ) return 0;

keyval = (unsigned char)*b;

while( *b ) keyval = keyval * 2147059363u + (unsigned char)*b++;

/* keyval &= 0x7FFFFFFF; */

base = hp->tab.base + ( keyval % (unsigned)hp->tab.nel );

for( i = *base; i; i = i->hdr.next ) if( keyval == i->hdr.keyval && !strcmp( i->data.key, (*data)->key ) ) { *data = &i->data; return !0; }

if( enter ) { i = (ITEM *)hp->items.next; hp->items.next += hp->items.size; hp->items.more--; memcpy( (char *)&i->data, (char *)*data, hp->items.datalen ); i->hdr.keyval = keyval; i->hdr.next = *base; *base = i; *data = &i->data; }

return 0; }