ref: 662ba37996ba211e900bc60ea400f0f3b846ac60
parent: 85f1ce96c558845a7de655c3db05481103960b6a
author: Sigrid Solveig Haflínudóttir <sigrid@ftrv.se>
date: Mon Mar 13 18:25:05 EDT 2023
remove more unused code
--- a/llt/lookup3.c
+++ b/llt/lookup3.c
@@ -4,17 +4,9 @@
These are functions for producing 32-bit hashes for hash table lookup.
hashword(), hashlittle(), hashlittle2(), hashbig(), mix(), and final()
-are externally useful functions. Routines to test the hash are included
-if SELF_TEST is defined. You can use this free for any purpose. It's in
-the public domain. It has no warranty.
+are externally useful functions. You can use this free for any purpose.
+It's in the public domain. It has no warranty.
-You probably want to use hashlittle(). hashlittle() and hashbig()
-hash byte arrays. hashlittle() is is faster than hashbig() on
-little-endian machines. Intel and AMD are little-endian machines.
-On second thought, you probably want hashlittle2(), which is identical to
-hashlittle() except it returns two 32-bit hashes for the price of one.
-You could implement hashbig2() if you wanted but I haven't bothered here.
-
If you want to find a hash of, say, exactly 7 integers, do
a = i1; b = i2; c = i3;
mix(a,b,c);
@@ -33,26 +25,19 @@
on 1 byte), but shoehorning those bytes into integers efficiently is messy.
-------------------------------------------------------------------------------
*/
-//#define SELF_TEST 1
/*
* My best guess at if you are big-endian or little-endian. This may
* need adjustment.
*/
-#if (defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && \
- __BYTE_ORDER == __LITTLE_ENDIAN) || \
- (defined(i386) || defined(__i386__) || defined(__i486__) || \
- defined(__i586__) || defined(__i686__) || defined(vax) || defined(MIPSEL))
-# define HASH_LITTLE_ENDIAN 1
-# define HASH_BIG_ENDIAN 0
-#elif (defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && \
- __BYTE_ORDER == __BIG_ENDIAN) || \
- (defined(sparc) || defined(POWERPC) || defined(mc68000) || defined(sel))
-# define HASH_LITTLE_ENDIAN 0
-# define HASH_BIG_ENDIAN 1
+#if defined(BYTE_ORDER) && defined(LITTLE_ENDIAN) && BYTE_ORDER == LITTLE_ENDIAN
+#define HASH_LITTLE_ENDIAN 1
+#define HASH_BIG_ENDIAN 0
+#elif defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN
+#define HASH_LITTLE_ENDIAN 0
+#define HASH_BIG_ENDIAN 1
#else
-# define HASH_LITTLE_ENDIAN 0
-# define HASH_BIG_ENDIAN 0
+#error endianess unknown
#endif
#define hashsize(n) ((uint32_t)1<<(n))
@@ -242,205 +227,7 @@
*pc=c; *pb=b;
}
-#if 0
/*
--------------------------------------------------------------------------------
-hashlittle() -- hash a variable-length key into a 32-bit value
- k : the key (the unaligned variable-length array of bytes)
- length : the length of the key, counting by bytes
- initval : can be any 4-byte value
-Returns a 32-bit value. Every bit of the key affects every bit of
-the return value. Two keys differing by one or two bits will have
-totally different hash values.
-
-The best hash table sizes are powers of 2. There is no need to do
-mod a prime (mod is sooo slow!). If you need less than 32 bits,
-use a bitmask. For example, if you need only 10 bits, do
- h = (h & hashmask(10));
-In which case, the hash table should have hashsize(10) elements.
-
-If you are hashing n strings (uint8_t **)k, do it like this:
- for (i=0, h=0; i<n; ++i) h = hashlittle( k[i], len[i], h);
-
-By Bob Jenkins, 2006. bob_jenkins@burtleburtle.net. You may use this
-code any way you wish, private, educational, or commercial. It's free.
-
-Use for hash table lookup, or anything where one collision in 2^^32 is
-acceptable. Do NOT use for cryptographic purposes.
--------------------------------------------------------------------------------
-*/
-
-uint32_t hashlittle( const void *key, size_t length, uint32_t initval)
-{- uint32_t a,b,c; /* internal state */
- union { const void *ptr; size_t i; } u; /* needed for Mac Powerbook G4 */-
- /* Set up the internal state */
- a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
-
- u.ptr = key;
- if (HASH_LITTLE_ENDIAN && ((u.i & 0x3) == 0)) {- const uint32_t *k = (const uint32_t *)key; /* read 32-bit chunks */
- const uint8_t *k8;
-
- /*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */
- while (length > 12)
- {- a += k[0];
- b += k[1];
- c += k[2];
- mix(a,b,c);
- length -= 12;
- k += 3;
- }
-
- /*----------------------------- handle the last (probably partial) block */
- /*
- * "k[2]&0xffffff" actually reads beyond the end of the string, but
- * then masks off the part it's not allowed to read. Because the
- * string is aligned, the masked-off tail is in the same word as the
- * rest of the string. Every machine with memory protection I've seen
- * does it on word boundaries, so is OK with this. But VALGRIND will
- * still catch it and complain. The masking trick does make the hash
- * noticably faster for short strings (like English words).
- */
-#ifndef VALGRIND
-
- switch(length)
- {- case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
- case 11: c+=k[2]&0xffffff; b+=k[1]; a+=k[0]; break;
- case 10: c+=k[2]&0xffff; b+=k[1]; a+=k[0]; break;
- case 9 : c+=k[2]&0xff; b+=k[1]; a+=k[0]; break;
- case 8 : b+=k[1]; a+=k[0]; break;
- case 7 : b+=k[1]&0xffffff; a+=k[0]; break;
- case 6 : b+=k[1]&0xffff; a+=k[0]; break;
- case 5 : b+=k[1]&0xff; a+=k[0]; break;
- case 4 : a+=k[0]; break;
- case 3 : a+=k[0]&0xffffff; break;
- case 2 : a+=k[0]&0xffff; break;
- case 1 : a+=k[0]&0xff; break;
- case 0 : return c; /* zero length strings require no mixing */
- }
-
-#else /* make valgrind happy */
-
- k8 = (const uint8_t *)k;
- switch(length)
- {- case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
- case 11: c+=((uint32_t)k8[10])<<16; /* fall through */
- case 10: c+=((uint32_t)k8[9])<<8; /* fall through */
- case 9 : c+=k8[8]; /* fall through */
- case 8 : b+=k[1]; a+=k[0]; break;
- case 7 : b+=((uint32_t)k8[6])<<16; /* fall through */
- case 6 : b+=((uint32_t)k8[5])<<8; /* fall through */
- case 5 : b+=k8[4]; /* fall through */
- case 4 : a+=k[0]; break;
- case 3 : a+=((uint32_t)k8[2])<<16; /* fall through */
- case 2 : a+=((uint32_t)k8[1])<<8; /* fall through */
- case 1 : a+=k8[0]; break;
- case 0 : return c;
- }
-
-#endif /* !valgrind */
-
- } else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) {- const uint16_t *k = (const uint16_t *)key; /* read 16-bit chunks */
- const uint8_t *k8;
-
- /*--------------- all but last block: aligned reads and different mixing */
- while (length > 12)
- {- a += k[0] + (((uint32_t)k[1])<<16);
- b += k[2] + (((uint32_t)k[3])<<16);
- c += k[4] + (((uint32_t)k[5])<<16);
- mix(a,b,c);
- length -= 12;
- k += 6;
- }
-
- /*----------------------------- handle the last (probably partial) block */
- k8 = (const uint8_t *)k;
- switch(length)
- {- case 12: c+=k[4]+(((uint32_t)k[5])<<16);
- b+=k[2]+(((uint32_t)k[3])<<16);
- a+=k[0]+(((uint32_t)k[1])<<16);
- break;
- case 11: c+=((uint32_t)k8[10])<<16; /* fall through */
- case 10: c+=k[4];
- b+=k[2]+(((uint32_t)k[3])<<16);
- a+=k[0]+(((uint32_t)k[1])<<16);
- break;
- case 9 : c+=k8[8]; /* fall through */
- case 8 : b+=k[2]+(((uint32_t)k[3])<<16);
- a+=k[0]+(((uint32_t)k[1])<<16);
- break;
- case 7 : b+=((uint32_t)k8[6])<<16; /* fall through */
- case 6 : b+=k[2];
- a+=k[0]+(((uint32_t)k[1])<<16);
- break;
- case 5 : b+=k8[4]; /* fall through */
- case 4 : a+=k[0]+(((uint32_t)k[1])<<16);
- break;
- case 3 : a+=((uint32_t)k8[2])<<16; /* fall through */
- case 2 : a+=k[0];
- break;
- case 1 : a+=k8[0];
- break;
- case 0 : return c; /* zero length requires no mixing */
- }
-
- } else { /* need to read the key one byte at a time */- const uint8_t *k = (const uint8_t *)key;
-
- /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
- while (length > 12)
- {- a += k[0];
- a += ((uint32_t)k[1])<<8;
- a += ((uint32_t)k[2])<<16;
- a += ((uint32_t)k[3])<<24;
- b += k[4];
- b += ((uint32_t)k[5])<<8;
- b += ((uint32_t)k[6])<<16;
- b += ((uint32_t)k[7])<<24;
- c += k[8];
- c += ((uint32_t)k[9])<<8;
- c += ((uint32_t)k[10])<<16;
- c += ((uint32_t)k[11])<<24;
- mix(a,b,c);
- length -= 12;
- k += 12;
- }
-
- /*-------------------------------- last block: affect all 32 bits of (c) */
- switch(length) /* all the case statements fall through */
- {- case 12: c+=((uint32_t)k[11])<<24;
- case 11: c+=((uint32_t)k[10])<<16;
- case 10: c+=((uint32_t)k[9])<<8;
- case 9 : c+=k[8];
- case 8 : b+=((uint32_t)k[7])<<24;
- case 7 : b+=((uint32_t)k[6])<<16;
- case 6 : b+=((uint32_t)k[5])<<8;
- case 5 : b+=k[4];
- case 4 : a+=((uint32_t)k[3])<<24;
- case 3 : a+=((uint32_t)k[2])<<16;
- case 2 : a+=((uint32_t)k[1])<<8;
- case 1 : a+=k[0];
- break;
- case 0 : return c;
- }
- }
-
- final(a,b,c);
- return c;
-}
-#endif
-
-/*
* hashlittle2: return 2 32-bit hash values
*
* This is identical to hashlittle(), except it returns two 32-bit hash
@@ -623,348 +410,3 @@
final(a,b,c);
*pc=c; *pb=b;
}
-
-
-#if 0
-/*
- * hashbig():
- * This is the same as hashword() on big-endian machines. It is different
- * from hashlittle() on all machines. hashbig() takes advantage of
- * big-endian byte ordering.
- */
-uint32_t hashbig( const void *key, size_t length, uint32_t initval)
-{- uint32_t a,b,c;
- union { const void *ptr; size_t i; } u; /* to cast key to (size_t) happily */-
- /* Set up the internal state */
- a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
-
- u.ptr = key;
- if (HASH_BIG_ENDIAN && ((u.i & 0x3) == 0)) {- const uint32_t *k = (const uint32_t *)key; /* read 32-bit chunks */
- const uint8_t *k8;
-
- /*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */
- while (length > 12)
- {- a += k[0];
- b += k[1];
- c += k[2];
- mix(a,b,c);
- length -= 12;
- k += 3;
- }
-
- /*----------------------------- handle the last (probably partial) block */
- /*
- * "k[2]<<8" actually reads beyond the end of the string, but
- * then shifts out the part it's not allowed to read. Because the
- * string is aligned, the illegal read is in the same word as the
- * rest of the string. Every machine with memory protection I've seen
- * does it on word boundaries, so is OK with this. But VALGRIND will
- * still catch it and complain. The masking trick does make the hash
- * noticably faster for short strings (like English words).
- */
-#ifndef VALGRIND
-
- switch(length)
- {- case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
- case 11: c+=k[2]&0xffffff00; b+=k[1]; a+=k[0]; break;
- case 10: c+=k[2]&0xffff0000; b+=k[1]; a+=k[0]; break;
- case 9 : c+=k[2]&0xff000000; b+=k[1]; a+=k[0]; break;
- case 8 : b+=k[1]; a+=k[0]; break;
- case 7 : b+=k[1]&0xffffff00; a+=k[0]; break;
- case 6 : b+=k[1]&0xffff0000; a+=k[0]; break;
- case 5 : b+=k[1]&0xff000000; a+=k[0]; break;
- case 4 : a+=k[0]; break;
- case 3 : a+=k[0]&0xffffff00; break;
- case 2 : a+=k[0]&0xffff0000; break;
- case 1 : a+=k[0]&0xff000000; break;
- case 0 : return c; /* zero length strings require no mixing */
- }
-
-#else /* make valgrind happy */
-
- k8 = (const uint8_t *)k;
- switch(length) /* all the case statements fall through */
- {- case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
- case 11: c+=((uint32_t)k8[10])<<8; /* fall through */
- case 10: c+=((uint32_t)k8[9])<<16; /* fall through */
- case 9 : c+=((uint32_t)k8[8])<<24; /* fall through */
- case 8 : b+=k[1]; a+=k[0]; break;
- case 7 : b+=((uint32_t)k8[6])<<8; /* fall through */
- case 6 : b+=((uint32_t)k8[5])<<16; /* fall through */
- case 5 : b+=((uint32_t)k8[4])<<24; /* fall through */
- case 4 : a+=k[0]; break;
- case 3 : a+=((uint32_t)k8[2])<<8; /* fall through */
- case 2 : a+=((uint32_t)k8[1])<<16; /* fall through */
- case 1 : a+=((uint32_t)k8[0])<<24; break;
- case 0 : return c;
- }
-
-#endif /* !VALGRIND */
-
- } else { /* need to read the key one byte at a time */- const uint8_t *k = (const uint8_t *)key;
-
- /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
- while (length > 12)
- {- a += ((uint32_t)k[0])<<24;
- a += ((uint32_t)k[1])<<16;
- a += ((uint32_t)k[2])<<8;
- a += ((uint32_t)k[3]);
- b += ((uint32_t)k[4])<<24;
- b += ((uint32_t)k[5])<<16;
- b += ((uint32_t)k[6])<<8;
- b += ((uint32_t)k[7]);
- c += ((uint32_t)k[8])<<24;
- c += ((uint32_t)k[9])<<16;
- c += ((uint32_t)k[10])<<8;
- c += ((uint32_t)k[11]);
- mix(a,b,c);
- length -= 12;
- k += 12;
- }
-
- /*-------------------------------- last block: affect all 32 bits of (c) */
- switch(length) /* all the case statements fall through */
- {- case 12: c+=k[11];
- case 11: c+=((uint32_t)k[10])<<8;
- case 10: c+=((uint32_t)k[9])<<16;
- case 9 : c+=((uint32_t)k[8])<<24;
- case 8 : b+=k[7];
- case 7 : b+=((uint32_t)k[6])<<8;
- case 6 : b+=((uint32_t)k[5])<<16;
- case 5 : b+=((uint32_t)k[4])<<24;
- case 4 : a+=k[3];
- case 3 : a+=((uint32_t)k[2])<<8;
- case 2 : a+=((uint32_t)k[1])<<16;
- case 1 : a+=((uint32_t)k[0])<<24;
- break;
- case 0 : return c;
- }
- }
-
- final(a,b,c);
- return c;
-}
-#endif
-
-#ifdef SELF_TEST
-
-/* used for timings */
-void driver1()
-{- uint8_t buf[256];
- uint32_t i;
- uint32_t h=0;
- time_t a,z;
-
- time(&a);
- for (i=0; i<256; ++i) buf[i] = 'x';
- for (i=0; i<1; ++i)
- {- h = hashlittle(&buf[0],1,h);
- }
- time(&z);
- if (z-a > 0) printf("time %d %.8x\n", z-a, h);-}
-
-/* check that every input bit changes every output bit half the time */
-#define HASHSTATE 1
-#define HASHLEN 1
-#define MAXPAIR 60
-#define MAXLEN 70
-void driver2()
-{- uint8_t qa[MAXLEN+1], qb[MAXLEN+2], *a = &qa[0], *b = &qb[1];
- uint32_t c[HASHSTATE], d[HASHSTATE], i=0, j=0, k, l, m=0, z;
- uint32_t e[HASHSTATE],f[HASHSTATE],g[HASHSTATE],h[HASHSTATE];
- uint32_t x[HASHSTATE],y[HASHSTATE];
- uint32_t hlen;
-
- printf("No more than %d trials should ever be needed \n",MAXPAIR/2);- for (hlen=0; hlen < MAXLEN; ++hlen)
- {- z=0;
- for (i=0; i<hlen; ++i) /*----------------------- for each input byte, */
- {- for (j=0; j<8; ++j) /*------------------------ for each input bit, */
- {- for (m=1; m<8; ++m) /*------------ for serveral possible initvals, */
- {- for (l=0; l<HASHSTATE; ++l)
- e[l]=f[l]=g[l]=h[l]=x[l]=y[l]=~((uint32_t)0);
-
- /*---- check that every output bit is affected by that input bit */
- for (k=0; k<MAXPAIR; k+=2)
- { - uint32_t finished=1;
- /* keys have one bit different */
- for (l=0; l<hlen+1; ++l) {a[l] = b[l] = (uint8_t)0;}- /* have a and b be two keys differing in only one bit */
- a[i] ^= (k<<j);
- a[i] ^= (k>>(8-j));
- c[0] = hashlittle(a, hlen, m);
- b[i] ^= ((k+1)<<j);
- b[i] ^= ((k+1)>>(8-j));
- d[0] = hashlittle(b, hlen, m);
- /* check every bit is 1, 0, set, and not set at least once */
- for (l=0; l<HASHSTATE; ++l)
- {- e[l] &= (c[l]^d[l]);
- f[l] &= ~(c[l]^d[l]);
- g[l] &= c[l];
- h[l] &= ~c[l];
- x[l] &= d[l];
- y[l] &= ~d[l];
- if (e[l]|f[l]|g[l]|h[l]|x[l]|y[l]) finished=0;
- }
- if (finished) break;
- }
- if (k>z) z=k;
- if (k==MAXPAIR)
- {- printf("Some bit didn't change: ");- printf("%.8x %.8x %.8x %.8x %.8x %.8x ",- e[0],f[0],g[0],h[0],x[0],y[0]);
- printf("i %d j %d m %d len %d\n", i, j, m, hlen);- }
- if (z==MAXPAIR) goto done;
- }
- }
- }
- done:
- if (z < MAXPAIR)
- {- printf("Mix success %2d bytes %2d initvals ",i,m);- printf("required %d trials\n", z/2);- }
- }
- printf("\n");-}
-
-/* Check for reading beyond the end of the buffer and alignment problems */
-void driver3()
-{- uint8_t buf[MAXLEN+20], *b;
- uint32_t len;
- uint8_t q[] = "This is the time for all good men to come to the aid of their country...";
- uint32_t h;
- uint8_t qq[] = "xThis is the time for all good men to come to the aid of their country...";
- uint32_t i;
- uint8_t qqq[] = "xxThis is the time for all good men to come to the aid of their country...";
- uint32_t j;
- uint8_t qqqq[] = "xxxThis is the time for all good men to come to the aid of their country...";
- uint32_t ref,x,y;
- uint8_t *p;
-
- printf("Endianness. These lines should all be the same (for values filled in):\n");- printf("%.8x %.8x %.8x\n",- hashword((const uint32_t *)q, (sizeof(q)-1)/4, 13),
- hashword((const uint32_t *)q, (sizeof(q)-5)/4, 13),
- hashword((const uint32_t *)q, (sizeof(q)-9)/4, 13));
- p = q;
- printf("%.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x\n",- hashlittle(p, sizeof(q)-1, 13), hashlittle(p, sizeof(q)-2, 13),
- hashlittle(p, sizeof(q)-3, 13), hashlittle(p, sizeof(q)-4, 13),
- hashlittle(p, sizeof(q)-5, 13), hashlittle(p, sizeof(q)-6, 13),
- hashlittle(p, sizeof(q)-7, 13), hashlittle(p, sizeof(q)-8, 13),
- hashlittle(p, sizeof(q)-9, 13), hashlittle(p, sizeof(q)-10, 13),
- hashlittle(p, sizeof(q)-11, 13), hashlittle(p, sizeof(q)-12, 13));
- p = &qq[1];
- printf("%.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x\n",- hashlittle(p, sizeof(q)-1, 13), hashlittle(p, sizeof(q)-2, 13),
- hashlittle(p, sizeof(q)-3, 13), hashlittle(p, sizeof(q)-4, 13),
- hashlittle(p, sizeof(q)-5, 13), hashlittle(p, sizeof(q)-6, 13),
- hashlittle(p, sizeof(q)-7, 13), hashlittle(p, sizeof(q)-8, 13),
- hashlittle(p, sizeof(q)-9, 13), hashlittle(p, sizeof(q)-10, 13),
- hashlittle(p, sizeof(q)-11, 13), hashlittle(p, sizeof(q)-12, 13));
- p = &qqq[2];
- printf("%.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x\n",- hashlittle(p, sizeof(q)-1, 13), hashlittle(p, sizeof(q)-2, 13),
- hashlittle(p, sizeof(q)-3, 13), hashlittle(p, sizeof(q)-4, 13),
- hashlittle(p, sizeof(q)-5, 13), hashlittle(p, sizeof(q)-6, 13),
- hashlittle(p, sizeof(q)-7, 13), hashlittle(p, sizeof(q)-8, 13),
- hashlittle(p, sizeof(q)-9, 13), hashlittle(p, sizeof(q)-10, 13),
- hashlittle(p, sizeof(q)-11, 13), hashlittle(p, sizeof(q)-12, 13));
- p = &qqqq[3];
- printf("%.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x\n",- hashlittle(p, sizeof(q)-1, 13), hashlittle(p, sizeof(q)-2, 13),
- hashlittle(p, sizeof(q)-3, 13), hashlittle(p, sizeof(q)-4, 13),
- hashlittle(p, sizeof(q)-5, 13), hashlittle(p, sizeof(q)-6, 13),
- hashlittle(p, sizeof(q)-7, 13), hashlittle(p, sizeof(q)-8, 13),
- hashlittle(p, sizeof(q)-9, 13), hashlittle(p, sizeof(q)-10, 13),
- hashlittle(p, sizeof(q)-11, 13), hashlittle(p, sizeof(q)-12, 13));
- printf("\n");-
- /* check that hashlittle2 and hashlittle produce the same results */
- i=47; j=0;
- hashlittle2(q, sizeof(q), &i, &j);
- if (hashlittle(q, sizeof(q), 47) != i)
- printf("hashlittle2 and hashlittle mismatch\n");-
- /* check that hashword2 and hashword produce the same results */
- len = 0xdeadbeef;
- i=47, j=0;
- hashword2(&len, 1, &i, &j);
- if (hashword(&len, 1, 47) != i)
- printf("hashword2 and hashword mismatch %x %x\n", - i, hashword(&len, 1, 47));
-
- /* check hashlittle doesn't read before or after the ends of the string */
- for (h=0, b=buf+1; h<8; ++h, ++b)
- {- for (i=0; i<MAXLEN; ++i)
- {- len = i;
- for (j=0; j<i; ++j) *(b+j)=0;
-
- /* these should all be equal */
- ref = hashlittle(b, len, (uint32_t)1);
- *(b+i)=(uint8_t)~0;
- *(b-1)=(uint8_t)~0;
- x = hashlittle(b, len, (uint32_t)1);
- y = hashlittle(b, len, (uint32_t)1);
- if ((ref != x) || (ref != y))
- {- printf("alignment error: %.8x %.8x %.8x %d %d\n",ref,x,y,- h, i);
- }
- }
- }
-}
-
-/* check for problems with nulls */
- void driver4()
-{- uint8_t buf[1];
- uint32_t h,i,state[HASHSTATE];
-
-
- buf[0] = ~0;
- for (i=0; i<HASHSTATE; ++i) state[i] = 1;
- printf("These should all be different\n");- for (i=0, h=0; i<8; ++i)
- {- h = hashlittle(buf, 0, h);
- printf("%2ld 0-byte strings, hash is %.8x\n", i, h);- }
-}
-
-
-int main()
-{- driver1(); /* test that the key is hashed: used for timings */
- driver2(); /* test that whole key is hashed thoroughly */
- driver3(); /* test that nothing but the key is hashed */
- driver4(); /* test hashing multiple buffers (all buffers are null) */
- return 1;
-}
-
-#endif /* SELF_TEST */
--- a/llt/mt19937ar.c
+++ b/llt/mt19937ar.c
@@ -169,23 +169,3 @@
return(a*67108864.0+b)*(1.0/9007199254740992.0);
}
#endif
-/* These real versions are due to Isaku Wada, 2002/01/09 added */
-#if 0
-int main(void)
-{- int i;
- uint32_t init[4]={0x123, 0x234, 0x345, 0x456}, length=4;- init_by_array(init, length);
- printf("1000 outputs of genrand_int32()\n");- for (i=0; i<1000; i++) {- printf("%10lu ", genrand_int32());- if (i%5==4) printf("\n");- }
- printf("\n1000 outputs of genrand_real2()\n");- for (i=0; i<1000; i++) {- printf("%10.8f ", genrand_real2());- if (i%5==4) printf("\n");- }
- return 0;
-}
-#endif
--- a/operators.c
+++ b/operators.c
@@ -13,35 +13,6 @@
#endif
// given a number, determine an appropriate type for storing it
-#if 0
-numerictype_t effective_numerictype(double r)
-{- double fp;
-
- fp = fpart(r);
- if (fp != 0 || r > UINT64_MAX || r < INT64_MIN) {- if (r > FLT_MAX || r < -FLT_MAX || (fabs(r) < FLT_MIN)) {- return T_DOUBLE;
- }
- else {- return T_FLOAT;
- }
- }
- else if (r >= SCHAR_MIN && r <= SCHAR_MAX) {- return T_INT8;
- }
- else if (r >= SHRT_MIN && r <= SHRT_MAX) {- return T_INT16;
- }
- else if (r >= INT_MIN && r <= INT_MAX) {- return T_INT32;
- }
- else if (r <= INT64_MAX) {- return T_INT64;
- }
- return T_UINT64;
-}
-#else
// simpler version implementing a smaller preferred type repertoire
numerictype_t effective_numerictype(double r)
{@@ -48,18 +19,14 @@
double fp;
fp = fpart(r);
- if (fp != 0 || r > (double)INT64_MAX || r < INT64_MIN) {+ if (fp != 0 || r > (double)INT64_MAX || r < INT64_MIN)
return T_DOUBLE;
- }
- else if (r >= INT_MIN && r <= INT_MAX) {+ else if (r >= INT_MIN && r <= INT_MAX)
return T_INT32;
- }
- else if (r <= (double)INT64_MAX) {+ else if (r <= (double)INT64_MAX)
return T_INT64;
- }
return T_UINT64;
}
-#endif
double conv_to_double(void *data, numerictype_t tag)
{@@ -205,9 +172,8 @@
if (atag == T_UINT64) { if (btag == T_INT64) {- if (*(int64_t*)b >= 0) {+ if (*(int64_t*)b >= 0)
return (*(uint64_t*)a < (uint64_t)*(int64_t*)b);
- }
return ((int64_t)*(uint64_t*)a < *(int64_t*)b);
}
else if (btag == T_DOUBLE) {@@ -217,9 +183,8 @@
}
else if (atag == T_INT64) { if (btag == T_UINT64) {- if (*(int64_t*)a >= 0) {+ if (*(int64_t*)a >= 0)
return ((uint64_t)*(int64_t*)a < *(uint64_t*)b);
- }
return (*(int64_t*)a < (int64_t)*(uint64_t*)b);
}
else if (btag == T_DOUBLE) {@@ -266,36 +231,28 @@
if (atag == T_UINT64) {// this is safe because if a had been bigger than INT64_MAX,
// we would already have concluded that it's bigger than b.
- if (btag == T_INT64) {+ if (btag == T_INT64)
return ((int64_t)*(uint64_t*)a == *(int64_t*)b);
- }
- else if (btag == T_DOUBLE) {+ else if (btag == T_DOUBLE)
return (*(uint64_t*)a == (uint64_t)(int64_t)*(double*)b);
- }
}
else if (atag == T_INT64) {- if (btag == T_UINT64) {+ if (btag == T_UINT64)
return (*(int64_t*)a == (int64_t)*(uint64_t*)b);
- }
- else if (btag == T_DOUBLE) {+ else if (btag == T_DOUBLE)
return (*(int64_t*)a == (int64_t)*(double*)b);
- }
}
else if (btag == T_UINT64) {- if (atag == T_INT64) {+ if (atag == T_INT64)
return ((int64_t)*(uint64_t*)b == *(int64_t*)a);
- }
- else if (atag == T_DOUBLE) {+ else if (atag == T_DOUBLE)
return (*(uint64_t*)b == (uint64_t)(int64_t)*(double*)a);
- }
}
else if (btag == T_INT64) {- if (atag == T_UINT64) {+ if (atag == T_UINT64)
return (*(int64_t*)b == (int64_t)*(uint64_t*)a);
- }
- else if (atag == T_DOUBLE) {+ else if (atag == T_DOUBLE)
return (*(int64_t*)b == (int64_t)*(double*)a);
- }
}
return 1;
}