[batman-adv] bitarray.[ch] Linux coding style cleanup

Index: batman-adv-kernelland/bitarray.c
===================================================================
--- batman-adv-kernelland/bitarray.c	(revision 1343)
+++ batman-adv-kernelland/bitarray.c	(working copy)
@@ -17,16 +17,10 @@ 
  *
  */
 
-
-
-
-
 #include "main.h"
 #include "bitarray.h"
 #include "log.h"
 
-
-
 /* clear the bits */
 void bit_init(TYPE_OF_WORD *seq_bits)
 {
@@ -36,8 +30,10 @@ 
 		seq_bits[i] = 0;
 }
 
-/* returns true if corresponding bit in given seq_bits indicates so and curr_seqno is within range of last_seqno */
-uint8_t get_bit_status(TYPE_OF_WORD *seq_bits, uint16_t last_seqno, uint16_t curr_seqno)
+/* returns true if the corresponding bit in the given seq_bits indicates true
+ * and curr_seqno is within range of last_seqno */
+uint8_t get_bit_status(TYPE_OF_WORD *seq_bits, uint16_t last_seqno,
+		       uint16_t curr_seqno)
 {
 	int16_t diff, word_offset, word_num;
 
@@ -45,8 +41,10 @@ 
 	if (diff < 0 || diff >= TQ_LOCAL_WINDOW_SIZE) {
 		return 0;
 	} else {
-		word_offset = (last_seqno - curr_seqno) % WORD_BIT_SIZE;/* which position in the selected word */
-		word_num = (last_seqno - curr_seqno) / WORD_BIT_SIZE;	/* which word */
+		/* which word */
+		word_num = (last_seqno - curr_seqno) / WORD_BIT_SIZE;
+		/* which position in the selected word */
+		word_offset = (last_seqno - curr_seqno) % WORD_BIT_SIZE;
 
 		if (seq_bits[word_num] & 1 << word_offset)
 			return 1;
@@ -57,22 +55,19 @@ 
 
 /* print the packet array, for debugging purposes */
 static char bit_string[130];
-char* bit_print(TYPE_OF_WORD *seq_bits) {
-	int i,j,k=0,b=0;
+char *bit_print(TYPE_OF_WORD *seq_bits)
+{
+	int i, j, k = 0, b = 0;
 
-// 	printf("the last %d packets, we got %d:\n", TQ_LOCAL_WINDOW_SIZE, bit_packet_count(seq_bits));
-	for ( i=0; i<NUM_WORDS; i++ ) {
-		for ( j=0; j<WORD_BIT_SIZE; j++) {
-			bit_string[k++] = ((seq_bits[i]>>j)%2 ? '1':'0'); /* print the j position */
-			if( ++b == TQ_LOCAL_WINDOW_SIZE ) {
-				bit_string[k++]='|';
-			}
+	for (i = 0; i < NUM_WORDS; i++) {
+		for (j = 0; j < WORD_BIT_SIZE; j++) {
+			bit_string[k++] = ((seq_bits[i]>>j)%2 ? '1' : '0');
+			if (++b == TQ_LOCAL_WINDOW_SIZE)
+				bit_string[k++] = '|';
 		}
-		bit_string[k++]=' ';
+		bit_string[k++] = ' ';
 	}
-	bit_string[k++]='\0';
-//	debug_output( 4, "%s\n", bit_string);
-//	printf("\n\n");
+	bit_string[k++] = '\0';
 	return bit_string;
 }
 
@@ -82,18 +77,18 @@ 
 	int32_t word_offset, word_num;
 
 	/* if too old, just drop it */
-	if (n<0 || n >= TQ_LOCAL_WINDOW_SIZE)
+	if (n < 0 || n >= TQ_LOCAL_WINDOW_SIZE)
 		return;
 
-// 	printf("mark bit %d\n", n);
+	/* which word */
+	word_num = n / WORD_BIT_SIZE;
+	/* which position in the selected word */
+	word_offset = n % WORD_BIT_SIZE;
 
-	word_offset = n % WORD_BIT_SIZE;	/* which position in the selected word */
-	word_num = n / WORD_BIT_SIZE;	/* which word */
-
 	seq_bits[word_num] |= 1 << word_offset;	/* turn the position on */
 }
 
-/* shift the packet array p by n places. */
+/* shift the packet array by n places. */
 void bit_shift(TYPE_OF_WORD *seq_bits, int32_t n)
 {
 	int32_t word_offset, word_num;
@@ -102,29 +97,36 @@ 
 	if (n <= 0)
 		return;
 
-	word_offset= n % WORD_BIT_SIZE;	/* shift how much inside each word */
+	word_offset = n % WORD_BIT_SIZE;/* shift how much inside each word */
 	word_num = n / WORD_BIT_SIZE;	/* shift over how much (full) words */
 
 	for (i = NUM_WORDS - 1; i > word_num; i--) {
-		/* going from old to new, so we can't overwrite the data we copy from. *
- 		 * left is high, right is low: FEDC BA98 7654 3210
+		/* going from old to new, so we don't overwrite the data we copy
+		 * from.
+		 *
+		 * left is high, right is low: FEDC BA98 7654 3210
 		 *	                                  ^^ ^^
 		 *                             vvvv
 		 * ^^^^ = from, vvvvv =to, we'd have word_num==1 and
-		 * word_offset==WORD_BIT_SIZE/2 ????? in this example. (=24 bits)
+		 * word_offset==WORD_BIT_SIZE/2 ????? in this example.
+		 * (=24 bits)
 		 *
 		 * our desired output would be: 9876 5432 1000 0000
 		 * */
 
 		seq_bits[i] =
 			(seq_bits[i - word_num] << word_offset) +
-					/* take the lower port from the left half, shift it left to its final position */
-			(seq_bits[i - word_num - 1] >> (WORD_BIT_SIZE-word_offset));
-					/* and the upper part of the right half and shift it left to it's position */
-		/* for our example that would be: word[0] = 9800 + 0076 = 9876 */
+			/* take the lower port from the left half, shift it left
+			 * to its final position */
+			(seq_bits[i - word_num - 1] >>
+			 (WORD_BIT_SIZE-word_offset));
+		/* and the upper part of the right half and shift it left to
+		 * it's position */
+		/* for our example that would be: word[0] = 9800 + 0076 =
+		 * 9876 */
 	}
-	/* now for our last word, i==word_num, we only have the it's "left" half. that's the 1000 word in
-	 * our example.*/
+	/* now for our last word, i==word_num, we only have the it's "left"
+	 * half. that's the 1000 word in our example.*/
 
 	seq_bits[i] = (seq_bits[i - word_num] << word_offset);
 
@@ -136,27 +138,33 @@ 
 }
 
 
-/* receive and process one packet, returns 1 if received seq_num is considered new, 0 if old  */
-char bit_get_packet(TYPE_OF_WORD *seq_bits, int16_t seq_num_diff, int8_t set_mark)
+/* receive and process one packet, returns 1 if received seq_num is considered
+ * new, 0 if old  */
+char bit_get_packet(TYPE_OF_WORD *seq_bits, int16_t seq_num_diff,
+		    int8_t set_mark)
 {
 	int i;
 
-	/* we already got a sequence number higher than this one, so we just mark it. this should wrap around the integer just fine */
+	/* we already got a sequence number higher than this one, so we just
+	 * mark it. this should wrap around the integer just fine */
 	if ((seq_num_diff < 0) && (seq_num_diff >= -TQ_LOCAL_WINDOW_SIZE)) {
 		if (set_mark)
 			bit_mark(seq_bits, -seq_num_diff);
-
 		return 0;
 	}
 
 	/* it seems we missed a lot of packets or the other host restarted */
-	if ((seq_num_diff > TQ_LOCAL_WINDOW_SIZE ) || (seq_num_diff < -TQ_LOCAL_WINDOW_SIZE)) {
+	if ((seq_num_diff > TQ_LOCAL_WINDOW_SIZE) ||
+	    (seq_num_diff < -TQ_LOCAL_WINDOW_SIZE)) {
 
 		if (seq_num_diff > TQ_LOCAL_WINDOW_SIZE)
-			debug_log(LOG_TYPE_BATMAN, "It seems we missed a lot of packets (%i) !\n",  seq_num_diff-1);
+			debug_log(LOG_TYPE_BATMAN,
+				  "We missed a lot of packets (%i) !\n",
+				  seq_num_diff-1);
 
 		if (-seq_num_diff > TQ_LOCAL_WINDOW_SIZE)
-			debug_log(LOG_TYPE_BATMAN, "Other host probably restarted !\n");
+			debug_log(LOG_TYPE_BATMAN,
+				  "Other host probably restarted !\n");
 
 		for (i = 0; i < NUM_WORDS; i++)
 			seq_bits[i] = 0;
@@ -173,35 +181,22 @@ 
 	return 1;
 }
 
-/* count the hamming weight, how many good packets did we receive? just count the 1's ... */
+/* count the hamming weight, how many good packets did we receive? just count
+ * the 1's. The inner loop uses the Kernighan algorithm, see
+ * http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetKernighan
+ */
 int bit_packet_count(TYPE_OF_WORD *seq_bits)
 {
 	int i, hamming = 0;
 	TYPE_OF_WORD word;
 
 	for (i = 0; i < NUM_WORDS; i++) {
-
 		word = seq_bits[i];
 
 		while (word) {
-			word &= word-1;   /* see http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetKernighan */
+			word &= word-1;
 			hamming++;
 		}
-
 	}
-
 	return hamming;
 }
-
-uint8_t bit_count(int32_t to_count)
-{
-	uint8_t hamming = 0;
-
-	while (to_count) {
-		to_count &= to_count - 1;   /* see http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetKernighan */
-		hamming++;
-	}
-
-	return hamming;
-}
-
Index: batman-adv-kernelland/bitarray.h
===================================================================
--- batman-adv-kernelland/bitarray.h	(revision 1343)
+++ batman-adv-kernelland/bitarray.h	(working copy)
@@ -18,18 +18,32 @@ 
  */
 
 
-
-#define TYPE_OF_WORD unsigned long /* you should choose something big, if you don't want to waste cpu */
+/* you should choose something big, if you don't want to waste cpu */
+#define TYPE_OF_WORD unsigned long
 #define WORD_BIT_SIZE (sizeof(TYPE_OF_WORD) * 8)
 
+/* clear the bits, ready for use */
+void bit_init(TYPE_OF_WORD *seq_bits);
 
+/* returns true if the corresponding bit in the given seq_bits indicates true
+ * and curr_seqno is within range of last_seqno */
+uint8_t get_bit_status(TYPE_OF_WORD *seq_bits, uint16_t last_seqno,
+					   uint16_t curr_seqno);
 
-void bit_init(TYPE_OF_WORD *seq_bits);
-uint8_t get_bit_status(TYPE_OF_WORD *seq_bits, uint16_t last_seqno, uint16_t curr_seqno);
-char *bit_print(TYPE_OF_WORD *seq_bits);
+/* turn corresponding bit on, so we can remember that we got the packet */
 void bit_mark(TYPE_OF_WORD *seq_bits, int32_t n);
+
+/* shift the packet array by n places. */
 void bit_shift(TYPE_OF_WORD *seq_bits, int32_t n);
-char bit_get_packet(TYPE_OF_WORD *seq_bits, int16_t seq_num_diff, int8_t set_mark);
+
+
+/* receive and process one packet, returns 1 if received seq_num is considered
+ * new, 0 if old  */
+char bit_get_packet(TYPE_OF_WORD *seq_bits, int16_t seq_num_diff,
+					int8_t set_mark);
+
+/* count the hamming weight, how many good packets did we receive? */
 int  bit_packet_count(TYPE_OF_WORD *seq_bits);
-uint8_t bit_count(int32_t to_count);
 
+/* print the packet array, for debugging purposes */
+char *bit_print(TYPE_OF_WORD *seq_bits);