pull upstream changes, add auto formatting

3 files changed, 401 insertions, 406 deletions

diff --git a/util/BuildImage.c b/util/BuildImage.c
index 2124c9d..42430ce 100644
--- a/util/BuildImage.c
+++ b/util/BuildImage.c
@@ -14,27 +14,27 @@
 **
 */
 
-#define	_POSIX_C_SOURCE	200809L
+#define _POSIX_C_SOURCE 200809L
 
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <unistd.h>
 #include <string.h>
-#include <errno.h>
+#include <unistd.h>
 
-#define	TRUE	1
-#define	FALSE	0
+#define TRUE 1
+#define FALSE 0
 
-#define	DRIVE_FLOPPY	0x00
-#define	DRIVE_USB		0x80
+#define DRIVE_FLOPPY 0x00
+#define DRIVE_USB 0x80
 
-#define	SECT_SIZE	512
+#define SECT_SIZE 512
 
-char *progname;				/* invocation name of this program */
-char *bootstrap_filename;	/* path of file holding bootstrap program */
-char *output_filename;		/* path of disk image file */
-FILE *out;					/* output stream for disk image file */
-short drive = DRIVE_USB;	/* boot drive */
+char *progname; /* invocation name of this program */
+char *bootstrap_filename; /* path of file holding bootstrap program */
+char *output_filename; /* path of disk image file */
+FILE *out; /* output stream for disk image file */
+short drive = DRIVE_USB; /* boot drive */
 
 /*
 ** Array into which program information will be stored, starting at the
@@ -46,9 +46,9 @@ short drive = DRIVE_USB;	/* boot drive */
 ** can be loaded.
 */
 
-#define	N_INFO	( SECT_SIZE / sizeof( short ) )
+#define N_INFO (SECT_SIZE / sizeof(short))
 
-short info[ N_INFO ];
+short info[N_INFO];
 int n_info = N_INFO;
 
 /**
@@ -60,43 +60,46 @@ int n_info = N_INFO;
 **
 ** does not return
 */
-void quit( char *msg, int call_perror ) {
-	if( msg != NULL ){
+void quit(char *msg, int call_perror)
+{
+	if (msg != NULL) {
 		// preserve the error code in case we need it
 		int err_num = errno;
-		fprintf( stderr, "%s: ", progname );
+		fprintf(stderr, "%s: ", progname);
 		errno = err_num;
-		if( call_perror ){
-			perror( msg );
+		if (call_perror) {
+			perror(msg);
 		} else {
-			fprintf( stderr, "%s\n", msg );
+			fprintf(stderr, "%s\n", msg);
 		}
 	}
-	if( output_filename != NULL ){
-		unlink( output_filename );
+	if (output_filename != NULL) {
+		unlink(output_filename);
 	}
-	exit( EXIT_FAILURE );
+	exit(EXIT_FAILURE);
 	// NOTREACHED
 }
 
-const char	usage_error_msg[] =
-  "\nUsage: %s [ -d drive ] -b bootfile -o outfile { progfile loadpt } ...\n\n"
-  "\t'drive' is either 'floppy' or 'usb' (default 'usb')\n\n"
-  "\tThere must be at least one program file and load point.\n\n"
-  "\tLoad points may be specified either as 32-bit quantities in hex,\n"
-  "\tdecimal or octal (e.g. 0x10c00, 68608, 0206000 are all equivalent),\n"
-  "\tor as an explicit segment:offset pair whose digits are always\n"
-  "\tinterpreted as hexadecimal values (e.g. 10c0:0000, 1000:0c00 are\n"
-  "\tboth equivalent to the previous examples).\n\n";
+const char usage_error_msg[] =
+	"\nUsage: %s [ -d drive ] -b bootfile -o outfile { progfile loadpt } "
+	"...\n\n"
+	"\t'drive' is either 'floppy' or 'usb' (default 'usb')\n\n"
+	"\tThere must be at least one program file and load point.\n\n"
+	"\tLoad points may be specified either as 32-bit quantities in hex,\n"
+	"\tdecimal or octal (e.g. 0x10c00, 68608, 0206000 are all equivalent),\n"
+	"\tor as an explicit segment:offset pair whose digits are always\n"
+	"\tinterpreted as hexadecimal values (e.g. 10c0:0000, 1000:0c00 are\n"
+	"\tboth equivalent to the previous examples).\n\n";
 
 /**
 ** print a usage message and then call quit()
 **
 ** does not return
 */
-void usage_error( void ){
-	fprintf( stderr, usage_error_msg, progname );
-	quit( NULL, FALSE );
+void usage_error(void)
+{
+	fprintf(stderr, usage_error_msg, progname);
+	quit(NULL, FALSE);
 	// NOTREACHED
 }
 
@@ -107,29 +110,30 @@ void usage_error( void ){
 ** @param in   open FILE to be read
 ** @return the number of sectors copied from the file
 */
-int copy_file( FILE *in ){
+int copy_file(FILE *in)
+{
 	int n_sectors = 0;
-	char buf[ SECT_SIZE ];
+	char buf[SECT_SIZE];
 	int n_bytes;
 	int i;
 
 	/*
-	** Copy the file to the output, being careful that the
-	** last sector is padded with null bytes out to the
-	** sector size.
-	*/
+  ** Copy the file to the output, being careful that the
+  ** last sector is padded with null bytes out to the
+  ** sector size.
+  */
 	n_sectors = 0;
-	while( (n_bytes = fread( buf, 1, sizeof( buf ), in )) > 0 ){
+	while ((n_bytes = fread(buf, 1, sizeof(buf), in)) > 0) {
 		// pad this sector out to block size
-		if( n_bytes < sizeof( buf ) ){
+		if (n_bytes < sizeof(buf)) {
 			int i;
 
-			for( i = n_bytes; i < sizeof( buf ); i += 1 ){
-				buf[ i ] = '\0';
+			for (i = n_bytes; i < sizeof(buf); i += 1) {
+				buf[i] = '\0';
 			}
 		}
-		if( fwrite( buf, 1, sizeof( buf ), out ) != sizeof( buf ) ){
-			quit( "Write failed or was wrong size", FALSE );
+		if (fwrite(buf, 1, sizeof(buf), out) != sizeof(buf)) {
+			quit("Write failed or was wrong size", FALSE);
 		}
 		n_sectors += 1;
 	}
@@ -143,85 +147,85 @@ int copy_file( FILE *in ){
 ** @param name  path to the file to be copied
 ** @param addr  string containing the load address
 */
-void process_file( char *name, char *addr ){
+void process_file(char *name, char *addr)
+{
 	long address;
 	short segment, offset;
 	int n_bytes;
 
 	/*
-	** Open the input file.
-	*/
-	FILE *in = fopen( name, "rb" );
-	if( in == NULL ){
-		quit( name, TRUE );
+  ** Open the input file.
+  */
+	FILE *in = fopen(name, "rb");
+	if (in == NULL) {
+		quit(name, TRUE);
 	}
 
 	/*
-	** Copy the file to the output, being careful that the
-	** last block is padded with null bytes.
-	*/
-	int n_sectors = copy_file( in );
-	fclose( in );
+  ** Copy the file to the output, being careful that the
+  ** last block is padded with null bytes.
+  */
+	int n_sectors = copy_file(in);
+	fclose(in);
 
 	/*
-	** Decode the address they gave us. We'll accept two forms:
-	** "nnnn:nnnn" for a segment:offset value (assumed to be hex),
-	** "nnnnnnn" for a decimal, hex, or octal value
-	*/
+  ** Decode the address they gave us. We'll accept two forms:
+  ** "nnnn:nnnn" for a segment:offset value (assumed to be hex),
+  ** "nnnnnnn" for a decimal, hex, or octal value
+  */
 	int valid_address = FALSE;
-	char *cp = strchr( addr, ':' );
-	if( cp != NULL ){
+	char *cp = strchr(addr, ':');
+	if (cp != NULL) {
 		// must be in nnnn:nnnn form exactly
-		if( strlen( addr ) == 9 && cp == addr + 4 ){
+		if (strlen(addr) == 9 && cp == addr + 4) {
 			char *ep1, *ep2;
 			int a1, a2;
 
-			segment = strtol( addr, &ep1, 16 );
-			offset = strtol( addr + 5, &ep2, 16 );
-			address = ( segment << 4 ) + offset;
+			segment = strtol(addr, &ep1, 16);
+			offset = strtol(addr + 5, &ep2, 16);
+			address = (segment << 4) + offset;
 			valid_address = *ep1 == '\0' && *ep2 == '\0';
 		} else {
-			fprintf( stderr, "Bad address format - '%s'\n", addr );
-			quit( NULL, FALSE );
+			fprintf(stderr, "Bad address format - '%s'\n", addr);
+			quit(NULL, FALSE);
 		}
 	} else {
 		// just a number, possibly hex or octal
 		char *ep;
 
-		address = strtol( addr, &ep, 0 );
-		segment = (short)( address >> 4 );
-		offset = (short)( address & 0xf );
+		address = strtol(addr, &ep, 0);
+		segment = (short)(address >> 4);
+		offset = (short)(address & 0xf);
 		valid_address = *ep == '\0' && address <= 0x0009ffff;
 	}
 
-	if( !valid_address ){
-		fprintf( stderr, "%s: Invalid address: %s\n", progname, addr );
-		quit( NULL, FALSE );
+	if (!valid_address) {
+		fprintf(stderr, "%s: Invalid address: %s\n", progname, addr);
+		quit(NULL, FALSE);
 	}
 
 	/*
-	** Make sure the program will fit!
-	*/
-	if( address + n_sectors * SECT_SIZE > 0x0009ffff ){
-		fprintf( stderr, "Program %s too large to start at 0x%08x\n",
-		    name, (unsigned int) address );
-		quit( NULL, FALSE );
+  ** Make sure the program will fit!
+  */
+	if (address + n_sectors * SECT_SIZE > 0x0009ffff) {
+		fprintf(stderr, "Program %s too large to start at 0x%08x\n", name,
+				(unsigned int)address);
+		quit(NULL, FALSE);
 	}
 
-	if( n_info < 3 ){
-		quit( "Too many programs!", FALSE );
+	if (n_info < 3) {
+		quit("Too many programs!", FALSE);
 	}
 
-
 	/*
-	** Looks good: report and store the information.
-	*/
-	fprintf( stderr, "  %s: %d sectors, loaded at 0x%x\n",
-	    name, n_sectors, (unsigned int) address );
+  ** Looks good: report and store the information.
+  */
+	fprintf(stderr, "  %s: %d sectors, loaded at 0x%x\n", name, n_sectors,
+			(unsigned int)address);
 
-	info[ --n_info ] = n_sectors;
-	info[ --n_info ] = segment;
-	info[ --n_info ] = offset;
+	info[--n_info] = n_sectors;
+	info[--n_info] = segment;
+	info[--n_info] = offset;
 }
 
 /*
@@ -237,64 +241,65 @@ extern char *optarg;
 ** @param ac  the count of entries in av
 ** @param av  the argument vector
 */
-void process_args( int ac, char **av ) {
+void process_args(int ac, char **av)
+{
 	int c;
-	
-	while( (c=getopt(ac,av,":d:o:b:")) != EOF ) {
-
-		switch( c ) {
 
-		case ':':	/* missing arg value */
-			fprintf( stderr, "missing operand after -%c\n", optopt );
+	while ((c = getopt(ac, av, ":d:o:b:")) != EOF) {
+		switch (c) {
+		case ':': /* missing arg value */
+			fprintf(stderr, "missing operand after -%c\n", optopt);
 			/* FALL THROUGH */
 
-		case '?':	/* error */
+		case '?': /* error */
 			usage_error();
 			/* NOTREACHED */
 
-		case 'b':	/* -b bootstrap_file */
+		case 'b': /* -b bootstrap_file */
 			bootstrap_filename = optarg;
 			break;
 
-		case 'd':	/* -d drive */
-			switch( *optarg ) {
-			case 'f':	drive = DRIVE_FLOPPY; break;
-			case 'u':	drive = DRIVE_USB; break;
-			default:	usage_error();
+		case 'd': /* -d drive */
+			switch (*optarg) {
+			case 'f':
+				drive = DRIVE_FLOPPY;
+				break;
+			case 'u':
+				drive = DRIVE_USB;
+				break;
+			default:
+				usage_error();
 			}
 			break;
 
-		case 'o':	/* -o output_file */
+		case 'o': /* -o output_file */
 			output_filename = optarg;
 			break;
-		
+
 		default:
 			usage_error();
-		
 		}
-	
 	}
 
-	if( !bootstrap_filename ) {
-		fprintf( stderr, "%s: no bootstrap file specified\n", progname );
-		exit( 2 );
+	if (!bootstrap_filename) {
+		fprintf(stderr, "%s: no bootstrap file specified\n", progname);
+		exit(2);
 	}
 
-	if( !output_filename ) {
-		fprintf( stderr, "%s: no disk image file specified\n", progname );
-		exit( 2 );
+	if (!output_filename) {
+		fprintf(stderr, "%s: no disk image file specified\n", progname);
+		exit(2);
 	}
 
 	/*
-	** Must have at least two remaining arguments (file to load, 
-	** address at which it should be loaded), and must have an
-	** even number of remaining arguments.
-	*/
+  ** Must have at least two remaining arguments (file to load,
+  ** address at which it should be loaded), and must have an
+  ** even number of remaining arguments.
+  */
 	int remain = ac - optind;
-	if( remain < 2 || (remain & 1) != 0 ) {
+	if (remain < 2 || (remain & 1) != 0) {
 		usage_error();
 	}
-
 }
 
 /**
@@ -307,109 +312,110 @@ void process_args( int ac, char **av ) {
 ** @param av   command-line argument vector
 ** @return EXIT_SUCCESS or EXIT_FAILURE
 */
-int main( int ac, char **av ) {
-	FILE	*bootimage;
-	int	bootimage_size;
-	int	n_bytes, n_words;
-	short	existing_data[ N_INFO ];
-	int	i;
-	
+int main(int ac, char **av)
+{
+	FILE *bootimage;
+	int bootimage_size;
+	int n_bytes, n_words;
+	short existing_data[N_INFO];
+	int i;
+
 	/*
-	** Save the program name for error messages
-	*/
-	progname = strrchr( av[ 0 ], '/' );
-	if( progname != NULL ){
+  ** Save the program name for error messages
+  */
+	progname = strrchr(av[0], '/');
+	if (progname != NULL) {
 		progname++;
 	} else {
-		progname = av[ 0 ];
+		progname = av[0];
 	}
 
 	/*
-	** Process arguments
-	*/
-	process_args( ac, av );
+  ** Process arguments
+  */
+	process_args(ac, av);
 
 	/*
-	** Open the output file
-	*/
+  ** Open the output file
+  */
 
-	out = fopen( output_filename, "wb+" );
-	if( out == NULL ){
-		quit( output_filename, TRUE );
+	out = fopen(output_filename, "wb+");
+	if (out == NULL) {
+		quit(output_filename, TRUE);
 	}
 
 	/*
-	** Open the bootstrap file and copy it to the output image.
-	*/
-	bootimage = fopen( bootstrap_filename, "rb" );
-	if( bootimage == NULL ){
-		quit( bootstrap_filename, TRUE );
+  ** Open the bootstrap file and copy it to the output image.
+  */
+	bootimage = fopen(bootstrap_filename, "rb");
+	if (bootimage == NULL) {
+		quit(bootstrap_filename, TRUE);
 	}
 
 	/*
-	** Remember the size of the bootstrap for later, as we
-	** need to patch some things into it
-	*/
-	int n_sectors = copy_file( bootimage );
-	fclose( bootimage );
+  ** Remember the size of the bootstrap for later, as we
+  ** need to patch some things into it
+  */
+	int n_sectors = copy_file(bootimage);
+	fclose(bootimage);
 
 	bootimage_size = n_sectors * SECT_SIZE;
-	fprintf( stderr, "  %s: %d sectors\n", bootstrap_filename, n_sectors );
+	fprintf(stderr, "  %s: %d sectors\n", bootstrap_filename, n_sectors);
 
 	/*
-	** Process the programs one by one
-	*/
+  ** Process the programs one by one
+  */
 	ac -= optind;
 	av += optind;
-	while( ac >= 2 ){
-		process_file( av[ 0 ], av[ 1 ] );
-		ac -= 2; av += 2;
+	while (ac >= 2) {
+		process_file(av[0], av[1]);
+		ac -= 2;
+		av += 2;
 	}
 
 	/*
-	** Check for oddball leftover argument
-	*/
-	if( ac > 0 ){
+  ** Check for oddball leftover argument
+  */
+	if (ac > 0) {
 		usage_error();
 	}
 
 	/*
-	** Seek to where the array of module data  must begin and read
-	** what's already there.
-	*/
-	n_words = ( N_INFO - n_info );
-	n_bytes = n_words * sizeof( info[ 0 ] );
-	fseek( out, bootimage_size - n_bytes, SEEK_SET );
-	if( fread( existing_data, sizeof(info[0]), n_words, out ) != n_words ){
-		quit( "Read from boot image failed or was too short", FALSE );
+  ** Seek to where the array of module data  must begin and read
+  ** what's already there.
+  */
+	n_words = (N_INFO - n_info);
+	n_bytes = n_words * sizeof(info[0]);
+	fseek(out, bootimage_size - n_bytes, SEEK_SET);
+	if (fread(existing_data, sizeof(info[0]), n_words, out) != n_words) {
+		quit("Read from boot image failed or was too short", FALSE);
 	}
 
 	/*
-	** If that space is non-zero, we have a problem
-	*/
-	for( i = 0; i < n_words; i += 1 ){
-		if( existing_data[ i ] != 0 ){
-			quit( "Too many programs to load!", FALSE );
+  ** If that space is non-zero, we have a problem
+  */
+	for (i = 0; i < n_words; i += 1) {
+		if (existing_data[i] != 0) {
+			quit("Too many programs to load!", FALSE);
 		}
 	}
 
 	/*
-	** We know that we're only overwriting zeros at the end of
-	** the bootstrap image, so it is ok to go ahead and do it.
-	*/
-	fseek( out, bootimage_size - n_bytes, SEEK_SET );
-	if( fwrite( info + n_info, sizeof( info[ 0 ] ), n_words, out ) != n_words ){
-		quit( "Write to boot image failed or was too short", FALSE );
+  ** We know that we're only overwriting zeros at the end of
+  ** the bootstrap image, so it is ok to go ahead and do it.
+  */
+	fseek(out, bootimage_size - n_bytes, SEEK_SET);
+	if (fwrite(info + n_info, sizeof(info[0]), n_words, out) != n_words) {
+		quit("Write to boot image failed or was too short", FALSE);
 	}
 
 	/*
-	** Write the drive index to the image.
-	*/
-	fseek( out, 508, SEEK_SET );
-	fwrite( (void *)&drive, sizeof(drive), 1, out );
+  ** Write the drive index to the image.
+  */
+	fseek(out, 508, SEEK_SET);
+	fwrite((void *)&drive, sizeof(drive), 1, out);
 
-	fclose( out );
+	fclose(out);
 
 	return EXIT_SUCCESS;
-
 }
diff --git a/util/listblob.c b/util/listblob.c
index 07523a6..f756a05 100644
--- a/util/listblob.c
+++ b/util/listblob.c
@@ -5,17 +5,17 @@
 **
 ** Examine a binary blob of ELF files.
 */
-#define	_DEFAULT_SOURCE
-#include <stdio.h>
+#define _DEFAULT_SOURCE
+#include <ctype.h>
+#include <elf.h>
+#include <fcntl.h>
+#include <stdbool.h>
 #include <stdint.h>
+#include <stdio.h>
 #include <stdlib.h>
-#include <stdbool.h>
 #include <string.h>
-#include <unistd.h>
 #include <sys/stat.h>
-#include <fcntl.h>
-#include <elf.h>
-#include <ctype.h>
+#include <unistd.h>
 
 /*
 ** Blob file organization
@@ -52,21 +52,21 @@ typedef struct header_s {
 //
 // If that field is made longer, it should be incremented in multiples
 // of four to avoid the insertion of padding bytes.
-#define NAMELEN      20
+#define NAMELEN 20
 
 // program descriptor: 32 bytes
 typedef struct prog_s {
-	char name[NAMELEN];  // truncated name (19 chars plus NUL)
-	uint32_t offset;     // offset from the beginning of the blob
-	uint32_t size;       // size of this ELF module
-	uint32_t flags;      // miscellaneous flags
+	char name[NAMELEN]; // truncated name (19 chars plus NUL)
+	uint32_t offset; // offset from the beginning of the blob
+	uint32_t size; // size of this ELF module
+	uint32_t flags; // miscellaneous flags
 } prog_t;
 
 // modules must be written as multiples of eight bytes
-#define FL_ROUNDUP     0x00000001
+#define FL_ROUNDUP 0x00000001
 
 // mask for mod 8 checking
-#define FSIZE_MASK     0x00000007
+#define FSIZE_MASK 0x00000007
 
 // program list entry
 typedef struct node_s {
@@ -74,48 +74,45 @@ typedef struct node_s {
 	struct node_s *next;
 } node_t;
 
-node_t *progs, *last_prog;   // list pointers
-uint32_t n_progs;            // number of files being copied
-uint32_t offset;             // current file area offset
-bool defs  = false;          // print CPP #defines?
-bool enums = false;          // print C enums?
+node_t *progs, *last_prog; // list pointers
+uint32_t n_progs; // number of files being copied
+uint32_t offset; // current file area offset
+bool defs = false; // print CPP #defines?
+bool enums = false; // print C enums?
 
 // header string for the userids.h file
 const char header[] =
-"/**\n"
-"** @file	userids.h\n"
-"**\n"
-"** @author	Warren R. Carithers\n"
-"**\n"
-"** @brief	IDs for user-level programs\n"
-"**\n"
-"** NOTE: this file is automatically generated when the user.img file\n"
-"** is created. Do not edit this manually!\n"
-"*/\n"
-"\n"
-"#ifndef USERIDS_H_\n"
-"#define USERIDS_H_\n"
-"\n"
-"#ifndef ASM_SRC\n"
-"/*\n"
-"** These IDs are used to identify the various user programs.\n"
-"** Each call to exec() will provide one of these as the first\n"
-"** argument.\n"
-"**\n"
-"** This list should be updated if/when the collection of\n"
-"** user processes changes.\n"
-"*/\n"
-"enum users_e {"
-;
+	"/**\n"
+	"** @file	userids.h\n"
+	"**\n"
+	"** @author	Warren R. Carithers\n"
+	"**\n"
+	"** @brief	IDs for user-level programs\n"
+	"**\n"
+	"** NOTE: this file is automatically generated when the user.img file\n"
+	"** is created. Do not edit this manually!\n"
+	"*/\n"
+	"\n"
+	"#ifndef USERIDS_H_\n"
+	"#define USERIDS_H_\n"
+	"\n"
+	"#ifndef ASM_SRC\n"
+	"/*\n"
+	"** These IDs are used to identify the various user programs.\n"
+	"** Each call to exec() will provide one of these as the first\n"
+	"** argument.\n"
+	"**\n"
+	"** This list should be updated if/when the collection of\n"
+	"** user processes changes.\n"
+	"*/\n"
+	"enum users_e {";
 
 // trailer string for the userids.h file
-const char trailer[] =
-"\n\t// sentinel\n\t, N_USERS\n"
-"};\n"
-"#endif  /* !ASM_SRC */\n"
-"\n"
-"#endif"
-;
+const char trailer[] = "\n\t// sentinel\n\t, N_USERS\n"
+					   "};\n"
+					   "#endif  /* !ASM_SRC */\n"
+					   "\n"
+					   "#endif";
 
 /**
 ** Name:	process
@@ -125,12 +122,11 @@ const char trailer[] =
 ** @param num   Program list index
 ** @param prog  Pointer to the program list entry
 */
-void process( uint32_t num, prog_t *prog ) {
-
-	if( defs || enums ) {
-
-		char *slash = strrchr( prog->name, '/' );
-		if( slash == NULL ) {
+void process(uint32_t num, prog_t *prog)
+{
+	if (defs || enums) {
+		char *slash = strrchr(prog->name, '/');
+		if (slash == NULL) {
 			slash = prog->name;
 		} else {
 			++slash;
@@ -138,111 +134,107 @@ void process( uint32_t num, prog_t *prog ) {
 
 		slash[0] = toupper(slash[0]);
 
-		if( defs ) {
-
+		if (defs) {
 			// just printing #define statements
-			printf( "#define %-15s %2d\n", prog->name, num );
+			printf("#define %-15s %2d\n", prog->name, num);
 
 		} else {
-
 			// printing a new userids.h file
-			if( num == 0 ) {
+			if (num == 0) {
 				// first one, so print the file header
-				puts( header );
-				putchar( '\t' );
+				puts(header);
+				putchar('\t');
 			} else {
 				// second or later entry; limit to 8 per line
-				fputs( ((num & 0x7) == 0 ) ?  ",\n\t" : ", ", stdout );
+				fputs(((num & 0x7) == 0) ? ",\n\t" : ", ", stdout);
 			}
-			printf( "%s", prog->name );
+			printf("%s", prog->name);
 		}
 
 	} else {
-
 		// just printing information
-		printf( "Entry %2d:  ", num );
-		printf( "%-s,", prog->name );
-		printf( " offset 0x%x, size 0x%x, flags %08x\n",
-				prog->offset, prog->size, prog->flags );
+		printf("Entry %2d:  ", num);
+		printf("%-s,", prog->name);
+		printf(" offset 0x%x, size 0x%x, flags %08x\n", prog->offset,
+			   prog->size, prog->flags);
 	}
 }
 
-void usage( char *name ) {
-	fprintf( stderr, "usage: %s [-d | -e] blob_name\n", name );
+void usage(char *name)
+{
+	fprintf(stderr, "usage: %s [-d | -e] blob_name\n", name);
 }
 
-int main( int argc, char *argv[] ) {
-
-	if( argc < 2 || argc > 3) {
-		usage( argv[0] );
-		exit( 1 );
+int main(int argc, char *argv[])
+{
+	if (argc < 2 || argc > 3) {
+		usage(argv[0]);
+		exit(1);
 	}
-	
+
 	int nameix = 1;
 
 	// could use getopt() for this, but this is easy enough
-	if( argc == 3 ) {
-		if( strcmp(argv[1],"-d") == 0 ) {
+	if (argc == 3) {
+		if (strcmp(argv[1], "-d") == 0) {
 			defs = true;
-		} else if( strcmp(argv[1],"-e") == 0 ) {
+		} else if (strcmp(argv[1], "-e") == 0) {
 			enums = true;
 		} else {
-			usage( argv[0] );
-			exit( 1 );
+			usage(argv[0]);
+			exit(1);
 		}
 		nameix = 2;
 	}
 
 	char *name = argv[nameix];
 
-	int fd = open( name, O_RDONLY );
-	if( fd < 0 ) {
-		perror( name );
-		exit( 1 );
+	int fd = open(name, O_RDONLY);
+	if (fd < 0) {
+		perror(name);
+		exit(1);
 	}
 
 	header_t hdr;
 
-	int n = read( fd, &hdr, sizeof(header_t) );
-	if( n != sizeof(header_t) ) {
-		fprintf( stderr, "%s: header read returned only %d bytes\n", name, n );
-		close( fd );
-		exit( 1 );
+	int n = read(fd, &hdr, sizeof(header_t));
+	if (n != sizeof(header_t)) {
+		fprintf(stderr, "%s: header read returned only %d bytes\n", name, n);
+		close(fd);
+		exit(1);
 	}
 
-	if( strcmp(hdr.magic,"BLB") != 0 ) {
-		fprintf( stderr, "%s: bad magic number\n", name );
-		close( fd );
-		exit( 1 );
+	if (strcmp(hdr.magic, "BLB") != 0) {
+		fprintf(stderr, "%s: bad magic number\n", name);
+		close(fd);
+		exit(1);
 	}
 
-	if( hdr.num < 1 ) {
-		fprintf( stderr, "%s: no programs in blob?\n", name );
-		close( fd );
-		exit( 1 );
+	if (hdr.num < 1) {
+		fprintf(stderr, "%s: no programs in blob?\n", name);
+		close(fd);
+		exit(1);
 	}
 
 	prog_t progs[hdr.num];
 
-	n = read( fd, progs, hdr.num * sizeof(prog_t) );
-	if( n != (int) (hdr.num * sizeof(prog_t)) ) {
-
-		fprintf( stderr, "%s: prog table only %d bytes, expected %lu\n",
-				name, n, hdr.num * sizeof(prog_t) );
-		close( fd );
-		exit( 1 );
+	n = read(fd, progs, hdr.num * sizeof(prog_t));
+	if (n != (int)(hdr.num * sizeof(prog_t))) {
+		fprintf(stderr, "%s: prog table only %d bytes, expected %lu\n", name, n,
+				hdr.num * sizeof(prog_t));
+		close(fd);
+		exit(1);
 	}
 
-	for( uint32_t i = 0; i < hdr.num; ++i ) {
-		process( i, &progs[i] );
+	for (uint32_t i = 0; i < hdr.num; ++i) {
+		process(i, &progs[i]);
 	}
 
-	if( enums ) {
+	if (enums) {
 		// print the file trailer
-		puts( trailer );
+		puts(trailer);
 	}
 
-	close( fd );
+	close(fd);
 	return 0;
-
 }
diff --git a/util/mkblob.c b/util/mkblob.c
index 32c67dd..db7bfc4 100644
--- a/util/mkblob.c
+++ b/util/mkblob.c
@@ -5,16 +5,16 @@
 **
 ** Create a binary blob from a collection of ELF files.
 */
-#define	_DEFAULT_SOURCE
+#define _DEFAULT_SOURCE
 
-#include <stdio.h>
+#include <elf.h>
+#include <fcntl.h>
 #include <stdint.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <unistd.h>
 #include <sys/stat.h>
-#include <fcntl.h>
-#include <elf.h>
+#include <unistd.h>
 
 /*
 ** Blob file organization
@@ -46,21 +46,21 @@ typedef struct header_s {
 } header_t;
 
 // length of the file name field
-#define NAMELEN      20
+#define NAMELEN 20
 
 // program descriptor
 typedef struct prog_s {
-	char name[NAMELEN];  // truncated name (15 chars)
-	uint32_t offset;     // offset from the beginning of the blob
-	uint32_t size;       // size of this ELF module
-	uint32_t flags;      // miscellaneous flags
+	char name[NAMELEN]; // truncated name (15 chars)
+	uint32_t offset; // offset from the beginning of the blob
+	uint32_t size; // size of this ELF module
+	uint32_t flags; // miscellaneous flags
 } prog_t;
 
 // modules must be written as multiples of eight bytes
-#define FL_ROUNDUP     0x00000001
+#define FL_ROUNDUP 0x00000001
 
 // mask for mod 8 checking
-#define FSIZE_MASK     0x00000007
+#define FSIZE_MASK 0x00000007
 
 // program list entry
 typedef struct node_s {
@@ -69,9 +69,9 @@ typedef struct node_s {
 	struct node_s *next;
 } node_t;
 
-node_t *progs, *last_prog;   // list pointers
-uint32_t n_progs;            // number of files being copied
-uint32_t offset;             // current file area offset
+node_t *progs, *last_prog; // list pointers
+uint32_t n_progs; // number of files being copied
+uint32_t offset; // current file area offset
 
 /**
 ** Name:	process
@@ -80,75 +80,74 @@ uint32_t offset;             // current file area offset
 **
 ** @param name  The name of the file
 */
-void process( const char *name ) {
+void process(const char *name)
+{
 	struct stat info;
 
 	// check the name length
-	if( strlen(name) >= NAMELEN ) {
-		fprintf( stderr, "%s: name exceeds length limit (%d)\n",
-				name, NAMELEN-1 );
+	if (strlen(name) >= NAMELEN) {
+		fprintf(stderr, "%s: name exceeds length limit (%d)\n", name,
+				NAMELEN - 1);
 		return;
 	}
 
 	// does it exist?
-	if( stat(name,&info) < 0 ) {
-		perror( name );
+	if (stat(name, &info) < 0) {
+		perror(name);
 		return;
 	}
 
 	// is it a regular file?
-	if( !S_ISREG(info.st_mode) ) {
-		fprintf( stderr, "%s: not a regular file\n", name );
+	if (!S_ISREG(info.st_mode)) {
+		fprintf(stderr, "%s: not a regular file\n", name);
 		return;
 	}
 
 	// open it and check the file header
-	int fd = open( name, O_RDONLY );
-	if( fd < 0 ) {
-		perror( name );
+	int fd = open(name, O_RDONLY);
+	if (fd < 0) {
+		perror(name);
 		return;
 	}
 
 	// read and check the ELF header
 	Elf32_Ehdr hdr;
-	int n = read( fd, &hdr, sizeof(Elf32_Ehdr) );
-	close( fd );
+	int n = read(fd, &hdr, sizeof(Elf32_Ehdr));
+	close(fd);
 
-	if( n != sizeof(Elf32_Ehdr) ) {
-		fprintf( stderr, "%s: header read was short - only %d\n", name, n );
+	if (n != sizeof(Elf32_Ehdr)) {
+		fprintf(stderr, "%s: header read was short - only %d\n", name, n);
 		return;
 	}
 
-	if( hdr.e_ident[EI_MAG0] != ELFMAG0 ||
-		hdr.e_ident[EI_MAG1] != ELFMAG1 ||
-		hdr.e_ident[EI_MAG2] != ELFMAG2 ||
-		hdr.e_ident[EI_MAG3] != ELFMAG3   ) {
-		fprintf( stderr, "%s: bad ELF magic number\n", name );
+	if (hdr.e_ident[EI_MAG0] != ELFMAG0 || hdr.e_ident[EI_MAG1] != ELFMAG1 ||
+		hdr.e_ident[EI_MAG2] != ELFMAG2 || hdr.e_ident[EI_MAG3] != ELFMAG3) {
+		fprintf(stderr, "%s: bad ELF magic number\n", name);
 		return;
 	}
 
 	// ok, it's a valid ELF file - create the prog list entry
-	prog_t *new = calloc( 1, sizeof(prog_t) );
-	if( new == NULL ) {
-		fprintf( stderr, "%s: calloc prog returned NULL\n", name );
+	prog_t *new = calloc(1, sizeof(prog_t));
+	if (new == NULL) {
+		fprintf(stderr, "%s: calloc prog returned NULL\n", name);
 		return;
 	}
 
-	node_t *node = calloc( 1, sizeof(node_t) );
-	if( node == NULL ) {
-		free( new );
-		fprintf( stderr, "%s: calloc node returned NULL\n", name );
+	node_t *node = calloc(1, sizeof(node_t));
+	if (node == NULL) {
+		free(new);
+		fprintf(stderr, "%s: calloc node returned NULL\n", name);
 		return;
 	}
 
 	node->data = new;
-	node->fullname = strdup( name );
+	node->fullname = strdup(name);
 
 	// copy in the name
 
 	// only want the last component
-	const char *slash = strrchr( name, '/' );
-	if( slash == NULL ) {
+	const char *slash = strrchr(name, '/');
+	if (slash == NULL) {
 		// only the file name
 		slash = name;
 	} else {
@@ -156,7 +155,7 @@ void process( const char *name ) {
 		++slash;
 	}
 
-	strncpy( new->name, slash, sizeof(new->name)-1 );
+	strncpy(new->name, slash, sizeof(new->name) - 1);
 	new->offset = offset;
 	new->size = info.st_size;
 
@@ -165,24 +164,24 @@ void process( const char *name ) {
 	offset += info.st_size;
 
 	// make sure it's a multiple of eight bytes long
-	if( (info.st_size & FSIZE_MASK) != 0 ) {
+	if ((info.st_size & FSIZE_MASK) != 0) {
 		// nope, so we must round it up when we write it out
 		new->flags |= FL_ROUNDUP;
 		// increases the offset to the next file
 		offset += 8 - (info.st_size & FSIZE_MASK);
 	}
-	
+
 	// add to the list
-	if( progs == NULL ) {
+	if (progs == NULL) {
 		// first entry
 		progs = node;
 	} else {
 		// add to the end
-		if( last_prog == NULL ) {
-			fprintf( stderr, "%s: progs ! NULL, last_prog is NULL\n", name );
-			free( new );
-			free( node->fullname );
-			free( node );
+		if (last_prog == NULL) {
+			fprintf(stderr, "%s: progs ! NULL, last_prog is NULL\n", name);
+			free(new);
+			free(node->fullname);
+			free(node);
 			return;
 		}
 		last_prog->next = node;
@@ -198,14 +197,14 @@ void process( const char *name ) {
 ** @param ofd   The output FILE* to be written
 ** @param prog  Pointer to the program list entry for the file
 */
-void copy( FILE *ofd, node_t *node ) {
-
+void copy(FILE *ofd, node_t *node)
+{
 	prog_t *prog = node->data;
 
 	// open it so we can copy it
-	int fd = open( node->fullname, O_RDONLY );
-	if( fd < 0 ) {
-		perror( node->fullname );
+	int fd = open(node->fullname, O_RDONLY);
+	if (fd < 0) {
+		perror(node->fullname);
 		return;
 	}
 
@@ -213,24 +212,22 @@ void copy( FILE *ofd, node_t *node ) {
 
 	// copy it block-by-block
 	do {
-		int n = read( fd, buf, 512);
+		int n = read(fd, buf, 512);
 		// no bytes --> we're done
-		if( n < 1 ) {
+		if (n < 1) {
 			break;
 		}
 		// copy it, and verify the copy count
-		int k = fwrite( buf, 1, n, ofd );
-		if( k != n ) {
-			fprintf( stderr, "%s: write of %d returned %d\n", 
-					prog->name, n, k );
+		int k = fwrite(buf, 1, n, ofd);
+		if (k != n) {
+			fprintf(stderr, "%s: write of %d returned %d\n", prog->name, n, k);
 		}
-	} while( 1 );
+	} while (1);
 
-	printf( "%s: copied %d", prog->name, prog->size );
+	printf("%s: copied %d", prog->name, prog->size);
 
 	// do we need to round up?
-	if( (prog->flags & FL_ROUNDUP) != 0 ) {
-
+	if ((prog->flags & FL_ROUNDUP) != 0) {
 		// we'll fill with NUL bytes
 		uint64_t filler = 0;
 
@@ -238,87 +235,87 @@ void copy( FILE *ofd, node_t *node ) {
 		int nbytes = 8 - (prog->size & FSIZE_MASK);
 
 		// do it, and check the transfer count to be sure
-		int n = fwrite( &filler, 1, nbytes, ofd );
-		if( n != nbytes ) {
-			fprintf( stderr, "%s: fill write of %d returned %d\n",
-					prog->name, nbytes, n );
+		int n = fwrite(&filler, 1, nbytes, ofd);
+		if (n != nbytes) {
+			fprintf(stderr, "%s: fill write of %d returned %d\n", prog->name,
+					nbytes, n);
 		}
 
 		// report that we added some filler bytes
-		printf( "(+%d)", n );
+		printf("(+%d)", n);
 	}
-	puts( " bytes" );
+	puts(" bytes");
 
 	// all done!
-	close( fd );
+	close(fd);
 }
 
-int main( int argc, char *argv[] ) {
-
+int main(int argc, char *argv[])
+{
 	// construct program list
-	for( int i = 1; i < argc; ++i ) {
-		process( argv[i] );
+	for (int i = 1; i < argc; ++i) {
+		process(argv[i]);
 	}
 
-	if( n_progs < 1 ) {
-		fputs( "Nothing to do... exiting.", stderr );
-		exit( 0 );
+	if (n_progs < 1) {
+		fputs("Nothing to do... exiting.", stderr);
+		exit(0);
 	}
 
 	// create the output file
 	FILE *ofd;
-	ofd = fopen( "user.img", "wb" );
-	if( ofd == NULL ) {
-		perror( "user.img" );
-		exit( 1 );
+	ofd = fopen("user.img", "wb");
+	if (ofd == NULL) {
+		perror("user.img");
+		exit(1);
 	}
 
-	printf( "Processing %d ELF files\n", n_progs );
+	printf("Processing %d ELF files\n", n_progs);
 
 	// we need to adjust the offset values so they are relative to the
 	// start of the blob, not relative to the start of the file area.
 	// do this by adding the sum of the file header and program entries
 	// to each offset field.
-	
+
 	uint32_t hlen = sizeof(header_t) + n_progs * sizeof(prog_t);
 	node_t *curr = progs;
-	while( curr != NULL ) {
+	while (curr != NULL) {
 		curr->data->offset += hlen;
 		curr = curr->next;
 	}
 
 	// write out the blob header
 	header_t hdr = { "BLB", n_progs };
-	if( fwrite(&hdr,sizeof(header_t),1,ofd) != 1 ) {
-		perror( "blob header" );
-		fclose( ofd );
-		exit( 1 );
+	if (fwrite(&hdr, sizeof(header_t), 1, ofd) != 1) {
+		perror("blob header");
+		fclose(ofd);
+		exit(1);
 	}
 
 	// next, the program entries
 	curr = progs;
-	while( curr != NULL ) {
-		if( fwrite(curr->data,sizeof(prog_t),1,ofd) != 1 ) {
-			perror( "blob prog entry write" );
-			fclose( ofd );
-			exit( 1 );
+	while (curr != NULL) {
+		if (fwrite(curr->data, sizeof(prog_t), 1, ofd) != 1) {
+			perror("blob prog entry write");
+			fclose(ofd);
+			exit(1);
 		}
 		curr = curr->next;
 	}
 
 	// finally, copy the files
 	curr = progs;
-	while( curr != NULL ) {
+	while (curr != NULL) {
 		prog_t *prog = curr->data;
-		copy( ofd, curr );
+		copy(ofd, curr);
 		node_t *tmp = curr;
 		curr = curr->next;
-		free( tmp->data );
-		free( tmp->fullname );
-		free( tmp );
+		free(tmp->data);
+		free(tmp->fullname);
+		free(tmp);
 	}
 
-	fclose( ofd );
+	fclose(ofd);
 
 	return 0;
 }