indent all of nvramtool to make it fit into coreboot's

coding style

Signed-off-by: Stefan Reinauer <stepan@coresystems.de>
Acked-by: Stefan Reinauer <stepan@coresystems.de>



git-svn-id: svn://svn.coreboot.org/coreboot/trunk@5007 2b7e53f0-3cfb-0310-b3e9-8179ed1497e1

1 files changed, 120 insertions, 111 deletions

diff --git a/util/nvramtool/hexdump.c b/util/nvramtool/hexdump.c
index 5df2619881..78199eb0ce 100644
--- a/util/nvramtool/hexdump.c
+++ b/util/nvramtool/hexdump.c
@@ -43,11 +43,11 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-static void addrprint (FILE *outfile, uint64_t address, int width);
-static void hexprint (FILE *outfile, unsigned char byte);
-static void charprint (FILE *outfile, unsigned char byte,
-                       unsigned char nonprintable,
-                       is_printable_fn_t is_printable_fn);
+static void addrprint(FILE * outfile, uint64_t address, int width);
+static void hexprint(FILE * outfile, unsigned char byte);
+static void charprint(FILE * outfile, unsigned char byte,
+		      unsigned char nonprintable,
+		      is_printable_fn_t is_printable_fn);
 
 /*--------------------------------------------------------------------------
  * hexdump
@@ -65,95 +65,98 @@ static void charprint (FILE *outfile, unsigned char byte,
  *     format:          A structure specifying how the hex dump should be
  *                      formatted.
  *--------------------------------------------------------------------------*/
-void hexdump (const void *mem, int bytes, uint64_t addrprint_start,
-              FILE *outfile, const hexdump_format_t *format)
- { int bytes_left, index, i;
-   const unsigned char *p;
-   is_printable_fn_t is_printable_fn;
+void hexdump(const void *mem, int bytes, uint64_t addrprint_start,
+	     FILE * outfile, const hexdump_format_t * format)
+{
+	int bytes_left, index, i;
+	const unsigned char *p;
+	is_printable_fn_t is_printable_fn;
 
-   /* Quietly return if the caller asks us to do something unreasonable. */
-   if ((format->bytes_per_line <= 0) || (bytes < 0))
-      return;
+	/* Quietly return if the caller asks us to do something unreasonable. */
+	if ((format->bytes_per_line <= 0) || (bytes < 0))
+		return;
 
-   is_printable_fn = format->is_printable_fn;
+	is_printable_fn = format->is_printable_fn;
 
-   if (is_printable_fn == NULL)
-      is_printable_fn = default_is_printable_fn;
+	if (is_printable_fn == NULL)
+		is_printable_fn = default_is_printable_fn;
 
-   p = (const unsigned char *) mem;
-   index = 0;
+	p = (const unsigned char *)mem;
+	index = 0;
 
-   /* Each iteration handles one full line of output.  When loop terminates,
-    * the number of remaining bytes to display (if any) will not be enough to
-    * fill an entire line.
-    */
-   for (bytes_left = bytes;
-        bytes_left >= format->bytes_per_line;
-        bytes_left -= format->bytes_per_line)
-    { /* print start address for current line */
-      fprintf(outfile, format->indent);
-      addrprint(outfile, addrprint_start + index, format->addrprint_width);
-      fprintf(outfile, format->sep1);
+	/* Each iteration handles one full line of output.  When loop
+	 * terminates, the number of remaining bytes to display (if any)
+	 * will not be enough to fill an entire line.
+	 */
+	for (bytes_left = bytes; 
+			bytes_left >= format->bytes_per_line;
+			bytes_left -= format->bytes_per_line) {
+		/* print start address for current line */
+		fprintf(outfile, format->indent);
+		addrprint(outfile, addrprint_start + index,
+			  format->addrprint_width);
+		fprintf(outfile, format->sep1);
 
-      /* display the bytes in hex */
-      for (i = 0; ; )
-       { hexprint(outfile, p[index++]);
+		/* display the bytes in hex */
+		for (i = 0;;) {
+			hexprint(outfile, p[index++]);
 
-         if (++i >= format->bytes_per_line)
-            break;
+			if (++i >= format->bytes_per_line)
+				break;
 
-         fprintf(outfile, format->sep2);
-       }
+			fprintf(outfile, format->sep2);
+		}
 
-      index -= format->bytes_per_line;
-      fprintf(outfile, format->sep3);
+		index -= format->bytes_per_line;
+		fprintf(outfile, format->sep3);
 
-      /* display the bytes as characters */
-      for (i = 0; i < format->bytes_per_line; i++)
-         charprint(outfile, p[index++], format->nonprintable,
-                   is_printable_fn);
+		/* display the bytes as characters */
+		for (i = 0; i < format->bytes_per_line; i++)
+			charprint(outfile, p[index++], format->nonprintable,
+				  is_printable_fn);
 
-      fprintf(outfile, "\n");
-    }
+		fprintf(outfile, "\n");
+	}
 
-   if (bytes_left == 0)
-      return;
+	if (bytes_left == 0)
+		return;
 
-   /* print start address for last line */
-   fprintf(outfile, format->indent);
-   addrprint(outfile, addrprint_start + index, format->addrprint_width);
-   fprintf(outfile, format->sep1);
+	/* print start address for last line */
+	fprintf(outfile, format->indent);
+	addrprint(outfile, addrprint_start + index, format->addrprint_width);
+	fprintf(outfile, format->sep1);
 
-   /* display bytes for last line in hex */
-   for (i = 0; i < bytes_left; i++)
-    { hexprint(outfile, p[index++]);
-      fprintf(outfile, format->sep2);
-    }
+	/* display bytes for last line in hex */
+	for (i = 0; i < bytes_left; i++) {
+		hexprint(outfile, p[index++]);
+		fprintf(outfile, format->sep2);
+	}
 
-   index -= bytes_left;
+	index -= bytes_left;
 
-   /* pad the rest of the hex byte area with spaces */
-   for (; ; )
-    { fprintf(outfile, "  ");
+	/* pad the rest of the hex byte area with spaces */
+	for (;;) {
+		fprintf(outfile, "  ");
 
-      if (++i >= format->bytes_per_line)
-         break;
+		if (++i >= format->bytes_per_line)
+			break;
 
-      fprintf(outfile, format->sep2);
-    }
+		fprintf(outfile, format->sep2);
+	}
 
-   fprintf(outfile, format->sep3);
+	fprintf(outfile, format->sep3);
 
-   /* display bytes for last line as characters */
-   for (i = 0; i < bytes_left; i++)
-      charprint(outfile, p[index++], format->nonprintable, is_printable_fn);
+	/* display bytes for last line as characters */
+	for (i = 0; i < bytes_left; i++)
+		charprint(outfile, p[index++], format->nonprintable,
+			  is_printable_fn);
 
-   /* pad the rest of the character area with spaces */
-   for (; i < format->bytes_per_line; i++)
-      fprintf(outfile, " ");
+	/* pad the rest of the character area with spaces */
+	for (; i < format->bytes_per_line; i++)
+		fprintf(outfile, " ");
 
-   fprintf(outfile, "\n");
- }
+	fprintf(outfile, "\n");
+}
 
 /*--------------------------------------------------------------------------
  * default_is_printable_fn
@@ -169,8 +172,10 @@ void hexdump (const void *mem, int bytes, uint64_t addrprint_start,
  * return value:
  *     Return 1 if the input character is printable.  Otherwise return 0.
  *--------------------------------------------------------------------------*/
-int default_is_printable_fn (unsigned char c)
- { return (c >= 0x20) && (c <= 0x7e); }
+int default_is_printable_fn(unsigned char c)
+{
+	return (c >= 0x20) && (c <= 0x7e);
+}
 
 /*--------------------------------------------------------------------------
  * addrprint
@@ -183,32 +188,33 @@ int default_is_printable_fn (unsigned char c)
  *     width:   The number of bytes wide the address should be displayed as.
  *              Must be a value from 1 to 8.
  *--------------------------------------------------------------------------*/
-static void addrprint (FILE *outfile, uint64_t address, int width)
- { char s[17];
-   int i;
-
-   /* force the user's input to be valid */
-   if (width < 1)
-      width = 1;
-   else if (width > 8)
-      width = 8;
-
-   /* convert address to string */
-   sprintf(s, "%016llx", (unsigned long long) address);
-
-   /* write it out, with colons separating consecutive 16-bit chunks of the
-    * address
-    */
-   for (i = 16 - (2 * width); ; )
-    { fprintf(outfile, "%c", s[i]);
-
-      if (++i >= 16)
-         break;
-
-      if ((i % 4) == 0)
-         fprintf(outfile, ":");
-    }
- }
+static void addrprint(FILE * outfile, uint64_t address, int width)
+{
+	char s[17];
+	int i;
+
+	/* force the user's input to be valid */
+	if (width < 1)
+		width = 1;
+	else if (width > 8)
+		width = 8;
+
+	/* convert address to string */
+	sprintf(s, "%016llx", (unsigned long long)address);
+
+	/* write it out, with colons separating consecutive 16-bit
+	 * chunks of the address
+	 */
+	for (i = 16 - (2 * width);;) {
+		fprintf(outfile, "%c", s[i]);
+
+		if (++i >= 16)
+			break;
+
+		if ((i % 4) == 0)
+			fprintf(outfile, ":");
+	}
+}
 
 /*--------------------------------------------------------------------------
  * hexprint
@@ -219,14 +225,15 @@ static void addrprint (FILE *outfile, uint64_t address, int width)
  *     outfile: the place where the output should be written
  *     byte:    the byte to display
  *--------------------------------------------------------------------------*/
-static void hexprint (FILE *outfile, unsigned char byte)
- { static const char tbl[] =
-    { '0', '1', '2', '3', '4', '5', '6', '7',
-      '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
-    };
+static void hexprint(FILE * outfile, unsigned char byte)
+{
+	static const char tbl[] = {
+		'0', '1', '2', '3', '4', '5', '6', '7',
+		'8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
+	};
 
-   fprintf(outfile, "%c%c", tbl[byte >> 4], tbl[byte & 0x0f]);
- }
+	fprintf(outfile, "%c%c", tbl[byte >> 4], tbl[byte & 0x0f]);
+}
 
 /*--------------------------------------------------------------------------
  * charprint
@@ -241,7 +248,9 @@ static void hexprint (FILE *outfile, unsigned char byte)
  *     is_printable_fn: a function that returns a boolean value indicating
  *                      whether a given character is printable
  *--------------------------------------------------------------------------*/
-static void charprint (FILE *outfile, unsigned char byte,
-                       unsigned char nonprintable,
-                       is_printable_fn_t is_printable_fn)
- { fprintf(outfile, "%c", is_printable_fn(byte) ? byte : nonprintable); }
+static void charprint(FILE * outfile, unsigned char byte,
+		      unsigned char nonprintable,
+		      is_printable_fn_t is_printable_fn)
+{
+	fprintf(outfile, "%c", is_printable_fn(byte) ? byte : nonprintable);
+}