Another round of semi-automated white space clean up

I used Uncrustify, meld, and some hand-editing to clean up the white space.
See https://review.coreboot.org/#/c/13963/ for method details.

Change-Id: I0ec070969d7660cdea485bd3bce49267a7389814
Signed-off-by: Ben Gardner <gardner.ben@gmail.com>
Reviewed-on: https://review.coreboot.org/14092
Tested-by: build bot (Jenkins)
Reviewed-by: Paul Menzel <paulepanter@users.sourceforge.net>
Reviewed-by: Martin Roth <martinroth@google.com>
diff --git a/patn.c b/patn.c
index 57262e9..2e35a38 100644
--- a/patn.c
+++ b/patn.c
@@ -32,26 +32,27 @@
  *  - Print a new pattern only when the pattern array is changed.
  */
 
-#define COMBINE_MASK(a,b,c,d) ((a & b & c & d) | (~a & b & ~c & d))
+#define COMBINE_MASK(a, b, c, d) ((a & b & c & d) | (~a & b & ~c & d))
 
 /* Combine two adr/mask pairs to one adr/mask pair.
  */
 void combine (ulong adr1, ulong mask1, ulong adr2, ulong mask2,
-		ulong *adr, ulong *mask) {
-
+              ulong *adr, ulong *mask)
+{
 	*mask = COMBINE_MASK (adr1, mask1, adr2, mask2);
 
 	*adr  = adr1 | adr2;
-	*adr &= *mask;	// Normalise, no fundamental need for this
+	*adr &= *mask;  // Normalise, no fundamental need for this
 }
 
 /* Count the number of addresses covered with a mask.
  */
-ulong addresses (ulong mask) {
+ulong addresses (ulong mask)
+{
 	ulong ctr=1;
 	int i=32;
 	while (i-- > 0) {
-		if (! (mask & 1)) {
+		if (!(mask & 1)) {
 			ctr += ctr;
 		}
 		mask >>= 1;
@@ -62,7 +63,8 @@
 /* Count how much more addresses would be covered by adr1/mask1 when combined
  * with adr2/mask2.
  */
-ulong combicost (ulong adr1, ulong mask1, ulong adr2, ulong mask2) {
+ulong combicost (ulong adr1, ulong mask1, ulong adr2, ulong mask2)
+{
 	ulong cost1=addresses (mask1);
 	ulong tmp, mask;
 	combine (adr1, mask1, adr2, mask2, &tmp, &mask);
@@ -72,7 +74,8 @@
 /* Find the cheapest array index to extend with the given adr/mask pair.
  * Return -1 if nothing below the given minimum cost can be found.
  */
-int cheapindex (ulong adr1, ulong mask1, ulong mincost) {
+int cheapindex (ulong adr1, ulong mask1, ulong mincost)
+{
 	int i=v->numpatn;
 	int idx=-1;
 	while (i-- > 0) {
@@ -88,11 +91,12 @@
 /* Try to find a relocation index for idx if it costs nothing.
  * Return -1 if no such index exists.
  */
-int relocateidx (int idx) {
+int relocateidx (int idx)
+{
 	ulong adr =v->patn[idx].adr;
 	ulong mask=v->patn[idx].mask;
 	int new;
-	v->patn[idx].adr ^= ~0L;	// Never select idx
+	v->patn[idx].adr ^= ~0L;        // Never select idx
 	new=cheapindex (adr, mask, 1+addresses (mask));
 	v->patn[idx].adr = adr;
 	return new;
@@ -102,13 +106,14 @@
  * This is useful to combine to `neighbouring' sections to integrate.
  * Inspired on the Buddy memalloc principle in the Linux kernel.
  */
-void relocateiffree (int idx) {
+void relocateiffree (int idx)
+{
 	int newidx=relocateidx (idx);
 	if (newidx>=0) {
 		ulong cadr, cmask;
 		combine (v->patn [newidx].adr, v->patn[newidx].mask,
 		         v->patn [   idx].adr, v->patn[   idx].mask,
-			 &cadr, &cmask);
+		         &cadr, &cmask);
 		v->patn[newidx].adr =cadr;
 		v->patn[newidx].mask=cmask;
 		if (idx < --v->numpatn) {
@@ -122,7 +127,8 @@
 /* Insert a single faulty address in the pattern array.
  * Return 1 only if the array was changed.
  */
-int insertaddress (ulong adr) {
+int insertaddress (ulong adr)
+{
 	if (cheapindex (adr, DEFAULT_MASK, 1L) != -1)
 		return 0;