all: apply basic formatting fixes to src/hash.c

There is still a lot of style/formatting work that should probably
be done to this file, but this cleans it up enough so it passes our
basic style checks.

Signed-off-by: Paul Moore <pmoore@redhat.com>

2 files changed, 752 insertions, 509 deletions

diff --git a/src/hash.c b/src/hash.c
index 6c54e18..5b55679 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -112,14 +112,14 @@ rotates.
 -------------------------------------------------------------------------------
 */
 #define mix(a,b,c) \
-{ \
-  a -= c;  a ^= rot(c, 4);  c += b; \
-  b -= a;  b ^= rot(a, 6);  a += c; \
-  c -= b;  c ^= rot(b, 8);  b += a; \
-  a -= c;  a ^= rot(c,16);  c += b; \
-  b -= a;  b ^= rot(a,19);  a += c; \
-  c -= b;  c ^= rot(b, 4);  b += a; \
-}
+	{ \
+		a -= c;  a ^= rot(c, 4);  c += b; \
+		b -= a;  b ^= rot(a, 6);  a += c; \
+		c -= b;  c ^= rot(b, 8);  b += a; \
+		a -= c;  a ^= rot(c,16);  c += b; \
+		b -= a;  b ^= rot(a,19);  a += c; \
+		c -= b;  c ^= rot(b, 4);  b += a; \
+	}
 
 /*
 -------------------------------------------------------------------------------
@@ -147,15 +147,15 @@ and these came close:
 -------------------------------------------------------------------------------
 */
 #define final(a,b,c) \
-{ \
-  c ^= b; c -= rot(b,14); \
-  a ^= c; a -= rot(c,11); \
-  b ^= a; b -= rot(a,25); \
-  c ^= b; c -= rot(b,16); \
-  a ^= c; a -= rot(c,4);  \
-  b ^= a; b -= rot(a,14); \
-  c ^= b; c -= rot(b,24); \
-}
+	{ \
+		c ^= b; c -= rot(b,14); \
+		a ^= c; a -= rot(c,11); \
+		b ^= a; b -= rot(a,25); \
+		c ^= b; c -= rot(b,16); \
+		a ^= c; a -= rot(c,4);  \
+		b ^= a; b -= rot(a,14); \
+		c ^= b; c -= rot(b,24); \
+	}
 
 /*
 --------------------------------------------------------------------
@@ -171,38 +171,39 @@ and these came close:
 --------------------------------------------------------------------
 */
 uint32_t hashword(
-const uint32_t *k,                   /* the key, an array of uint32_t values */
-size_t          length,               /* the length of the key, in uint32_ts */
-uint32_t        initval)         /* the previous hash, or an arbitrary value */
+	const uint32_t *k,            /* the key, an array of uint32_t values */
+	size_t          length,        /* the length of the key, in uint32_ts */
+	uint32_t        initval)  /* the previous hash, or an arbitrary value */
 {
-  uint32_t a,b,c;
-
-  /* Set up the internal state */
-  a = b = c = 0xdeadbeef + (((uint32_t)length)<<2) + initval;
-
-  /*------------------------------------------------- handle most of the key */
-  while (length > 3)
-  {
-    a += k[0];
-    b += k[1];
-    c += k[2];
-    mix(a,b,c);
-    length -= 3;
-    k += 3;
-  }
-
-  /*------------------------------------------- handle the last 3 uint32_t's */
-  switch(length)                     /* all the case statements fall through */
-  {
-  case 3 : c+=k[2];
-  case 2 : b+=k[1];
-  case 1 : a+=k[0];
-    final(a,b,c);
-  case 0:     /* case 0: nothing left to add */
-    break;
-  }
-  /*------------------------------------------------------ report the result */
-  return c;
+	uint32_t a, b, c;
+
+	/* Set up the internal state */
+	a = b = c = 0xdeadbeef + (((uint32_t)length) << 2) + initval;
+
+	/*-------------------------------------------- handle most of the key */
+	while (length > 3) {
+		a += k[0];
+		b += k[1];
+		c += k[2];
+		mix(a, b, c);
+		length -= 3;
+		k += 3;
+	}
+
+	/*-------------------------------------- handle the last 3 uint32_t's */
+	switch(length) {              /* all the case statements fall through */
+	case 3 :
+		c += k[2];
+	case 2 :
+		b += k[1];
+	case 1 :
+		a += k[0];
+		final(a, b, c);
+	case 0:     /* case 0: nothing left to add */
+		break;
+	}
+	/*------------------------------------------------- report the result */
+	return c;
 }
 
 /*
@@ -214,40 +215,42 @@ both be initialized with seeds.  If you pass in (*pb)==0, the output
 --------------------------------------------------------------------
 */
 void hashword2 (
-const uint32_t *k,                   /* the key, an array of uint32_t values */
-size_t          length,               /* the length of the key, in uint32_ts */
-uint32_t       *pc,                      /* IN: seed OUT: primary hash value */
-uint32_t       *pb)               /* IN: more seed OUT: secondary hash value */
+	const uint32_t *k,            /* the key, an array of uint32_t values */
+	size_t          length,        /* the length of the key, in uint32_ts */
+	uint32_t       *pc,               /* IN: seed OUT: primary hash value */
+	uint32_t       *pb)        /* IN: more seed OUT: secondary hash value */
 {
-  uint32_t a,b,c;
-
-  /* Set up the internal state */
-  a = b = c = 0xdeadbeef + ((uint32_t)(length<<2)) + *pc;
-  c += *pb;
-
-  /*------------------------------------------------- handle most of the key */
-  while (length > 3)
-  {
-    a += k[0];
-    b += k[1];
-    c += k[2];
-    mix(a,b,c);
-    length -= 3;
-    k += 3;
-  }
-
-  /*------------------------------------------- handle the last 3 uint32_t's */
-  switch(length)                     /* all the case statements fall through */
-  {
-  case 3 : c+=k[2];
-  case 2 : b+=k[1];
-  case 1 : a+=k[0];
-    final(a,b,c);
-  case 0:     /* case 0: nothing left to add */
-    break;
-  }
-  /*------------------------------------------------------ report the result */
-  *pc=c; *pb=b;
+	uint32_t a, b, c;
+
+	/* Set up the internal state */
+	a = b = c = 0xdeadbeef + ((uint32_t)(length << 2)) + *pc;
+	c += *pb;
+
+	/*-------------------------------------------- handle most of the key */
+	while (length > 3) {
+		a += k[0];
+		b += k[1];
+		c += k[2];
+		mix(a, b, c);
+		length -= 3;
+		k += 3;
+	}
+
+	/*-------------------------------------- handle the last 3 uint32_t's */
+	switch(length) {              /* all the case statements fall through */
+	case 3 :
+		c += k[2];
+	case 2 :
+		b += k[1];
+	case 1 :
+		a += k[0];
+		final(a, b, c);
+	case 0:     /* case 0: nothing left to add */
+		break;
+	}
+	/*------------------------------------------------- report the result */
+	*pc = c;
+	*pb = b;
 }
 
 /*
@@ -278,170 +281,251 @@ 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 */
-
-    /*------ 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).
-     */
+	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 32b chunks */
+
+		/* 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 */
-    }
+		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;
-    }
+		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;
+	} else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) {
+		const uint16_t *k = (const uint16_t *)key; /* read 16b 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;
 }
 
 /*
@@ -455,176 +539,266 @@ uint32_t hashlittle( const void *key, size_t length, uint32_t initval)
  * a 64-bit value do something like "*pc + (((uint64_t)*pb)<<32)".
  */
 void hashlittle2(
-  const void *key,       /* the key to hash */
-  size_t      length,    /* length of the key */
-  uint32_t   *pc,        /* IN: primary initval, OUT: primary hash */
-  uint32_t   *pb)        /* IN: secondary initval, OUT: secondary hash */
+	const void *key,       /* the key to hash */
+	size_t      length,    /* length of the key */
+	uint32_t   *pc,        /* IN: primary initval, OUT: primary hash */
+	uint32_t   *pb)        /* IN: secondary initval, OUT: secondary hash */
 {
-  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) + *pc;
-  c += *pb;
-
-  u.ptr = key;
-  if (HASH_LITTLE_ENDIAN && ((u.i & 0x3) == 0)) {
-    const uint32_t *k = (const uint32_t *)key;         /* read 32-bit chunks */
-
-    /*------ 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).
-     */
+	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) + *pc;
+	c += *pb;
+
+	u.ptr = key;
+	if (HASH_LITTLE_ENDIAN && ((u.i & 0x3) == 0)) {
+		const uint32_t *k = (const uint32_t *)key; /* read 32b chunks */
+
+		/* 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 : *pc=c; *pb=b; return;  /* zero length strings require no mixing */
-    }
+		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 :
+			*pc = c;
+			*pb = b;
+			return;  /* 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 : *pc=c; *pb=b; return;  /* zero length strings require no mixing */
-    }
+		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 :
+			*pc = c;
+			*pb = b;
+			return;  /* zero length strings require no mixing */
+		}
 
 #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 : *pc=c; *pb=b; return;  /* zero length strings require 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 : *pc=c; *pb=b; return;  /* zero length strings require no mixing */
-    }
-  }
-
-  final(a,b,c);
-  *pc=c; *pb=b;
+	} else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) {
+		const uint16_t *k = (const uint16_t *)key; /* read 16b 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 :
+			*pc = c;
+			*pb = b;
+			return;  /* zero length strings require 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 :
+			*pc = c;
+			*pb = b;
+			return;  /* zero length strings require no mixing */
+		}
+	}
+
+	final(a, b, c);
+	*pc = c;
+	*pb = b;
 }
 
 /*
@@ -635,122 +809,191 @@ void hashlittle2(
  */
 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 */
-
-    /*------ 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).
-     */
+	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 32b chunks */
+
+		/* 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 */
-    }
+		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;
-    }
+		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;
+	} 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;
 }
-
diff --git a/tools/check-syntax b/tools/check-syntax
index b5ae9cc..f356a46 100755
--- a/tools/check-syntax
+++ b/tools/check-syntax
@@ -25,7 +25,7 @@ CHK_C_LIST="include/seccomp.h.in \
 	    src/*.c src/*.h \
 	    tests/*.c tests/*.h \
 	    tools/*.c tools/*.h"
-CHK_C_EXCLUDE="src/hash.c"
+CHK_C_EXCLUDE=""
 
 ####
 # functions