fsck.minix: clean up coding style

$ indent -linux -psl -blf disk-utils/fsck.minix.c

Signed-off-by: Sami Kerola <kerolasa@iki.fi>

1 files changed, 342 insertions, 360 deletions

diff --git a/disk-utils/fsck.minix.c b/disk-utils/fsck.minix.c
index 84d638519..5765013d0 100644
--- a/disk-utils/fsck.minix.c
+++ b/disk-utils/fsck.minix.c
@@ -114,13 +114,10 @@
 #define ROOT_INO 1
 #define YESNO_LENGTH 64
 
-/*
- * Global variables used in minix_programs.h inline fuctions
- */
+/* Global variables used in minix_programs.h inline fuctions */
 int fs_version = 1;
 char *super_block_buffer;
 
-
 static char *inode_buffer;
 
 #define Inode (((struct minix_inode *) inode_buffer) - 1)
@@ -131,8 +128,8 @@ static int IN;
 static int repair, automatic, verbose, list, show, warn_mode, force;
 static int directory, regular, blockdev, chardev, links, symlinks, total;
 
-static int changed; /* flags if the filesystem has been changed */
-static int errors_uncorrected; /* flag if some error was not corrected */
+static int changed;		/* flags if the filesystem has been changed */
+static int errors_uncorrected;	/* flag if some error was not corrected */
 static size_t dirsize = 16;
 static size_t namelen = 14;
 static struct termios termios;
@@ -143,8 +140,8 @@ static volatile sig_atomic_t termios_set;
 static int name_depth;
 static char name_list[MAX_DEPTH][MINIX_NAME_MAX + 1];
 
-/* Copy of the previous, just for error reporting - see get_current_name */
-/* This is a waste of 12kB or so. */
+/* Copy of the previous, just for error reporting - see get_current_name.  This
+ * is a waste of 12kB or so.  */
 static char current_name[MAX_DEPTH * (MINIX_NAME_MAX + 1) + 1];
 
 #define MAGIC (Super.s_magic)
@@ -173,14 +170,11 @@ reset(void) {
 		tcsetattr(0, TCSANOW, &termios);
 }
 
-
 static void
 fatalsig(int sig) {
-	/* We received a fatal signal.  Reset the terminal.
-	 * Also reset the signal handler and re-send the signal,
-	 * so that the parent process knows which signal actually
-	 * caused our death.
-	 */
+	/* We received a fatal signal.  Reset the terminal.  Also reset the
+	 * signal handler and re-send the signal, so that the parent process
+	 * knows which signal actually caused our death.  */
 	signal(sig, SIG_DFL);
 	reset();
 	raise(sig);
@@ -188,7 +182,7 @@ fatalsig(int sig) {
 
 static void
 leave(int status) {
-        reset();
+	reset();
 	exit(status);
 }
 
@@ -212,7 +206,7 @@ usage(void) {
 }
 
 static void die(const char *fmt, ...)
-	__attribute__ ((__format__ (__printf__, 1, 2)));
+    __attribute__ ((__format__(__printf__, 1, 2)));
 
 static void
 die(const char *fmt, ...) {
@@ -221,15 +215,12 @@ die(const char *fmt, ...) {
 	fprintf(stderr, "%s: ", program_invocation_short_name);
 	va_start(ap, fmt);
 	vfprintf(stderr, fmt, ap);
-	va_end (ap);
+	va_end(ap);
 	fputc('\n', stderr);
 	leave(FSCK_EX_ERROR);
 }
 
-/*
- * This simply goes through the file-name data and prints out the
- * current file.
- */
+/* This simply goes through the file-name data and prints out the current file.  */
 static void
 get_current_name(void) {
 	int i = 0, ct;
@@ -249,7 +240,7 @@ get_current_name(void) {
 }
 
 static int
-ask(const char * string, int def) {
+ask(const char *string, int def) {
 	int resp;
 	char input[YESNO_LENGTH];
 
@@ -261,7 +252,7 @@ ask(const char * string, int def) {
 	if (automatic) {
 		printf("\n");
 		if (!def)
-		      errors_uncorrected = 1;
+			errors_uncorrected = 1;
 		return def;
 	}
 	/* TRANSLATORS: these yes no questions uses rpmatch(), and should be
@@ -291,54 +282,46 @@ ask(const char * string, int def) {
 	return def;
 }
 
-/*
- * Make certain that we aren't checking a filesystem that is on a
- * mounted partition.  Code adapted from e2fsck, Copyright (C) 1993,
- * 1994 Theodore Ts'o.  Also licensed under GPL.
- */
+/* Make certain that we aren't checking a filesystem that is on a mounted
+ * partition.  Code adapted from e2fsck, Copyright (C) 1993, 1994 Theodore
+ * Ts'o.  Also licensed under GPL.  */
 static void
-check_mount(void)
-{
+check_mount(void) {
 	int cont;
 
 	if (!is_mounted(device_name))
 		return;
 
-	printf (_("%s is mounted.	 "), device_name);
+	printf(_("%s is mounted.	 "), device_name);
 	if (isatty(0) && isatty(1))
 		cont = ask(_("Do you really want to continue"), 0);
 	else
 		cont = 0;
 	if (!cont) {
-		printf (_("check aborted.\n"));
-		exit (FSCK_EX_OK);
+		printf(_("check aborted.\n"));
+		exit(FSCK_EX_OK);
 	}
 	return;
 }
 
-/*
- * check_zone_nr checks to see that *nr is a valid zone nr. If it
- * isn't, it will possibly be repaired. Check_zone_nr sets *corrected
- * if an error was corrected, and returns the zone (0 for no zone
- * or a bad zone-number).
- */
+/* check_zone_nr checks to see that *nr is a valid zone nr.  If it isn't, it
+ * will possibly be repaired.  Check_zone_nr sets *corrected if an error was
+ * corrected, and returns the zone (0 for no zone or a bad zone-number).  */
 static int
-check_zone_nr(unsigned short * nr, int * corrected) {
+check_zone_nr(unsigned short *nr, int *corrected) {
 	if (!*nr)
 		return 0;
 
 	if (*nr < get_first_zone()) {
 		get_current_name();
-		printf(_("Zone nr < FIRSTZONE in file `%s'."),
-		       current_name);
+		printf(_("Zone nr < FIRSTZONE in file `%s'."), current_name);
 	} else if (*nr >= get_nzones()) {
 		get_current_name();
-		printf(_("Zone nr >= ZONES in file `%s'."),
-		       current_name);
+		printf(_("Zone nr >= ZONES in file `%s'."), current_name);
 	} else
 		return *nr;
 
-	if (ask(_("Remove block"),1)) {
+	if (ask(_("Remove block"), 1)) {
 		*nr = 0;
 		*corrected = 1;
 	}
@@ -346,66 +329,59 @@ check_zone_nr(unsigned short * nr, int * corrected) {
 }
 
 static int
-check_zone_nr2 (unsigned int *nr, int *corrected) {
+check_zone_nr2(unsigned int *nr, int *corrected) {
 	if (!*nr)
 		return 0;
 
 	if (*nr < get_first_zone()) {
 		get_current_name();
-		printf (_("Zone nr < FIRSTZONE in file `%s'."),
-			current_name);
+		printf(_("Zone nr < FIRSTZONE in file `%s'."), current_name);
 	} else if (*nr >= get_nzones()) {
 		get_current_name();
-		printf (_("Zone nr >= ZONES in file `%s'."),
-			current_name);
+		printf(_("Zone nr >= ZONES in file `%s'."), current_name);
 	} else
 		return *nr;
 
-	if (ask (_("Remove block"), 1)) {
+	if (ask(_("Remove block"), 1)) {
 		*nr = 0;
 		*corrected = 1;
 	}
 	return 0;
 }
 
-/*
- * read-block reads block nr into the buffer at addr.
- */
+/* read-block reads block nr into the buffer at addr.  */
 static void
-read_block(unsigned int nr, char * addr) {
+read_block(unsigned int nr, char *addr) {
 	if (!nr) {
-		memset(addr,0,MINIX_BLOCK_SIZE);
+		memset(addr, 0, MINIX_BLOCK_SIZE);
 		return;
 	}
-	if (MINIX_BLOCK_SIZE*nr != lseek(IN, MINIX_BLOCK_SIZE*nr, SEEK_SET)) {
+	if (MINIX_BLOCK_SIZE * nr != lseek(IN, MINIX_BLOCK_SIZE * nr, SEEK_SET)) {
 		get_current_name();
 		printf(_("Read error: unable to seek to block in file '%s'\n"),
 		       current_name);
-		memset(addr,0,MINIX_BLOCK_SIZE);
+		memset(addr, 0, MINIX_BLOCK_SIZE);
 		errors_uncorrected = 1;
 	} else if (MINIX_BLOCK_SIZE != read(IN, addr, MINIX_BLOCK_SIZE)) {
 		get_current_name();
-		printf(_("Read error: bad block in file '%s'\n"),
-		       current_name);
-		memset(addr,0,MINIX_BLOCK_SIZE);
+		printf(_("Read error: bad block in file '%s'\n"), current_name);
+		memset(addr, 0, MINIX_BLOCK_SIZE);
 		errors_uncorrected = 1;
 	}
 }
 
-/*
- * write_block writes block nr to disk.
- */
+/* write_block writes block nr to disk.  */
 static void
-write_block(unsigned int nr, char * addr) {
+write_block(unsigned int nr, char *addr) {
 	if (!nr)
 		return;
 	if (nr < get_first_zone() || nr >= get_nzones()) {
 		printf(_("Internal error: trying to write bad block\n"
-		"Write request ignored\n"));
+			 "Write request ignored\n"));
 		errors_uncorrected = 1;
 		return;
 	}
-	if (MINIX_BLOCK_SIZE*nr != lseek(IN, MINIX_BLOCK_SIZE*nr, SEEK_SET))
+	if (MINIX_BLOCK_SIZE * nr != lseek(IN, MINIX_BLOCK_SIZE * nr, SEEK_SET))
 		die(_("seek failed in write_block"));
 	if (MINIX_BLOCK_SIZE != write(IN, addr, MINIX_BLOCK_SIZE)) {
 		get_current_name();
@@ -415,111 +391,107 @@ write_block(unsigned int nr, char * addr) {
 	}
 }
 
-/*
- * map-block calculates the absolute block nr of a block in a file.
- * It sets 'changed' if the inode has needed changing, and re-writes
- * any indirect blocks with errors.
- */
+/* map-block calculates the absolute block nr of a block in a file.  It sets
+ * 'changed' if the inode has needed changing, and re-writes any indirect
+ * blocks with errors.  */
 static int
-map_block(struct minix_inode * inode, unsigned int blknr) {
-	unsigned short ind[MINIX_BLOCK_SIZE>>1];
-	unsigned short dind[MINIX_BLOCK_SIZE>>1];
+map_block(struct minix_inode *inode, unsigned int blknr) {
+	unsigned short ind[MINIX_BLOCK_SIZE >> 1];
+	unsigned short dind[MINIX_BLOCK_SIZE >> 1];
 	int blk_chg, block, result;
 
-	if (blknr<7)
+	if (blknr < 7)
 		return check_zone_nr(inode->i_zone + blknr, &changed);
 	blknr -= 7;
-	if (blknr<512) {
+	if (blknr < 512) {
 		block = check_zone_nr(inode->i_zone + 7, &changed);
-		read_block(block, (char *) ind);
+		read_block(block, (char *)ind);
 		blk_chg = 0;
 		result = check_zone_nr(blknr + ind, &blk_chg);
 		if (blk_chg)
-			write_block(block, (char *) ind);
+			write_block(block, (char *)ind);
 		return result;
 	}
 	blknr -= 512;
 	block = check_zone_nr(inode->i_zone + 8, &changed);
-	read_block(block, (char *) dind);
+	read_block(block, (char *)dind);
 	blk_chg = 0;
-	result = check_zone_nr(dind + (blknr/512), &blk_chg);
+	result = check_zone_nr(dind + (blknr / 512), &blk_chg);
 	if (blk_chg)
-		write_block(block, (char *) dind);
+		write_block(block, (char *)dind);
 	block = result;
-	read_block(block, (char *) ind);
+	read_block(block, (char *)ind);
 	blk_chg = 0;
-	result = check_zone_nr(ind + (blknr%512), &blk_chg);
+	result = check_zone_nr(ind + (blknr % 512), &blk_chg);
 	if (blk_chg)
-		write_block(block, (char *) ind);
+		write_block(block, (char *)ind);
 	return result;
 }
 
 static int
-map_block2 (struct minix2_inode *inode, unsigned int blknr) {
+map_block2(struct minix2_inode *inode, unsigned int blknr) {
 	unsigned int ind[MINIX_BLOCK_SIZE >> 2];
 	unsigned int dind[MINIX_BLOCK_SIZE >> 2];
 	unsigned int tind[MINIX_BLOCK_SIZE >> 2];
 	int blk_chg, block, result;
 
 	if (blknr < 7)
-		return check_zone_nr2 (inode->i_zone + blknr, &changed);
+		return check_zone_nr2(inode->i_zone + blknr, &changed);
 	blknr -= 7;
 	if (blknr < 256) {
-		block = check_zone_nr2 (inode->i_zone + 7, &changed);
-		read_block (block, (char *) ind);
+		block = check_zone_nr2(inode->i_zone + 7, &changed);
+		read_block(block, (char *)ind);
 		blk_chg = 0;
-		result = check_zone_nr2 (blknr + ind, &blk_chg);
+		result = check_zone_nr2(blknr + ind, &blk_chg);
 		if (blk_chg)
-			write_block (block, (char *) ind);
+			write_block(block, (char *)ind);
 		return result;
 	}
 	blknr -= 256;
 	if (blknr < 256 * 256) {
-		block = check_zone_nr2 (inode->i_zone + 8, &changed);
-		read_block (block, (char *) dind);
+		block = check_zone_nr2(inode->i_zone + 8, &changed);
+		read_block(block, (char *)dind);
 		blk_chg = 0;
-		result = check_zone_nr2 (dind + blknr / 256, &blk_chg);
+		result = check_zone_nr2(dind + blknr / 256, &blk_chg);
 		if (blk_chg)
-			write_block (block, (char *) dind);
+			write_block(block, (char *)dind);
 		block = result;
-		read_block (block, (char *) ind);
+		read_block(block, (char *)ind);
 		blk_chg = 0;
-		result = check_zone_nr2 (ind + blknr % 256, &blk_chg);
+		result = check_zone_nr2(ind + blknr % 256, &blk_chg);
 		if (blk_chg)
-			write_block (block, (char *) ind);
+			write_block(block, (char *)ind);
 		return result;
 	}
 	blknr -= 256 * 256;
-	block = check_zone_nr2 (inode->i_zone + 9, &changed);
-	read_block (block, (char *) tind);
+	block = check_zone_nr2(inode->i_zone + 9, &changed);
+	read_block(block, (char *)tind);
 	blk_chg = 0;
-	result = check_zone_nr2 (tind + blknr / (256 * 256), &blk_chg);
+	result = check_zone_nr2(tind + blknr / (256 * 256), &blk_chg);
 	if (blk_chg)
-		write_block (block, (char *) tind);
+		write_block(block, (char *)tind);
 	block = result;
-	read_block (block, (char *) dind);
+	read_block(block, (char *)dind);
 	blk_chg = 0;
-	result = check_zone_nr2 (dind + (blknr / 256) % 256, &blk_chg);
+	result = check_zone_nr2(dind + (blknr / 256) % 256, &blk_chg);
 	if (blk_chg)
-		write_block (block, (char *) dind);
+		write_block(block, (char *)dind);
 	block = result;
-	read_block (block, (char *) ind);
+	read_block(block, (char *)ind);
 	blk_chg = 0;
-	result = check_zone_nr2 (ind + blknr % 256, &blk_chg);
+	result = check_zone_nr2(ind + blknr % 256, &blk_chg);
 	if (blk_chg)
-		write_block (block, (char *) ind);
+		write_block(block, (char *)ind);
 	return result;
 }
 
 static void
 write_super_block(void) {
-	/*
-	 * Set the state of the filesystem based on whether or not there
-	 * are uncorrected errors.  The filesystem valid flag is
-	 * unconditionally set if we get this far.
-	 */
+	/* Set the state of the filesystem based on whether or not there are
+	 * uncorrected errors.  The filesystem valid flag is unconditionally
+	 * set if we get this far.  */
 	Super.s_state |= MINIX_VALID_FS;
-	if ( errors_uncorrected )
+	if (errors_uncorrected)
 		Super.s_state |= MINIX_ERROR_FS;
 	else
 		Super.s_state &= ~MINIX_ERROR_FS;
@@ -528,7 +500,6 @@ write_super_block(void) {
 		die(_("seek failed in write_super_block"));
 	if (MINIX_BLOCK_SIZE != write(IN, super_block_buffer, MINIX_BLOCK_SIZE))
 		die(_("unable to write super-block"));
-
 	return;
 }
 
@@ -550,7 +521,7 @@ write_tables(void) {
 }
 
 static void
-get_dirsize (void) {
+get_dirsize(void) {
 	int block;
 	char blk[MINIX_BLOCK_SIZE];
 	size_t size;
@@ -559,7 +530,7 @@ get_dirsize (void) {
 		block = Inode2[ROOT_INO].i_zone[0];
 	else
 		block = Inode[ROOT_INO].i_zone[0];
-	read_block (block, blk);
+	read_block(block, blk);
 
 	for (size = 16; size < MINIX_BLOCK_SIZE; size <<= 1) {
 		if (strcmp(blk + size + 2, "..") == 0) {
@@ -604,7 +575,8 @@ read_superblock(void) {
 		die(_("Only 1k blocks/zones supported"));
 	if (get_nimaps() * MINIX_BLOCK_SIZE * 8 < get_ninodes() + 1)
 		die(_("bad s_imap_blocks field in super-block"));
-	if (get_nzmaps() * MINIX_BLOCK_SIZE * 8 < get_nzones() - get_first_zone() + 1)
+	if (get_nzmaps() * MINIX_BLOCK_SIZE * 8 <
+	    get_nzones() - get_first_zone() + 1)
 		die(_("bad s_zmap_blocks field in super-block"));
 }
 
@@ -643,28 +615,28 @@ read_tables(void) {
 	if (rc < 0 || zmaps * MINIX_BLOCK_SIZE != (size_t) rc)
 		die(_("Unable to read zone map"));
 
-	rc = read(IN,inode_buffer, buffsz);
+	rc = read(IN, inode_buffer, buffsz);
 	if (rc < 0 || buffsz != (size_t) rc)
 		die(_("Unable to read inodes"));
 	if (norm_first_zone != first_zone) {
 		printf(_("Warning: Firstzone != Norm_firstzone\n"));
 		errors_uncorrected = 1;
 	}
-	get_dirsize ();
+	get_dirsize();
 	if (show) {
 		printf(_("%ld inodes\n"), inodes);
 		printf(_("%ld blocks\n"), zones);
 		printf(_("Firstdatazone=%ld (%ld)\n"), first_zone, norm_first_zone);
-		printf(_("Zonesize=%d\n"),MINIX_BLOCK_SIZE<<get_zone_size());
+		printf(_("Zonesize=%d\n"), MINIX_BLOCK_SIZE << get_zone_size());
 		printf(_("Maxsize=%ld\n"), get_max_size());
 		printf(_("Filesystem state=%d\n"), Super.s_state);
-		printf(_("namelen=%zd\n\n"),namelen);
+		printf(_("namelen=%zd\n\n"), namelen);
 	}
 }
 
 static struct minix_inode *
 get_inode(unsigned int nr) {
-	struct minix_inode * inode;
+	struct minix_inode *inode;
 
 	if (!nr || nr > get_ninodes())
 		return NULL;
@@ -674,13 +646,12 @@ get_inode(unsigned int nr) {
 		if (!inode_in_use(nr)) {
 			get_current_name();
 			printf(_("Inode %d marked unused, "
-				 "but used for file '%s'\n"),
-			       nr, current_name);
+				 "but used for file '%s'\n"), nr, current_name);
 			if (repair) {
-				if (ask(_("Mark in use"),1))
+				if (ask(_("Mark in use"), 1))
 					mark_inode(nr);
 			} else {
-			        errors_uncorrected = 1;
+				errors_uncorrected = 1;
 			}
 		}
 		if (S_ISDIR(inode->i_mode))
@@ -698,10 +669,10 @@ get_inode(unsigned int nr) {
 		else if (S_ISFIFO(inode->i_mode))
 			;
 		else {
-                        get_current_name();
-                        printf(_("The file `%s' has mode %05o\n"),
+			get_current_name();
+			printf(_("The file `%s' has mode %05o\n"),
 			       current_name, inode->i_mode);
-                }
+		}
 
 	} else
 		links++;
@@ -714,7 +685,7 @@ get_inode(unsigned int nr) {
 }
 
 static struct minix2_inode *
-get_inode2 (unsigned int nr) {
+get_inode2(unsigned int nr) {
 	struct minix2_inode *inode;
 
 	if (!nr || nr > get_ninodes())
@@ -722,39 +693,38 @@ get_inode2 (unsigned int nr) {
 	total++;
 	inode = Inode2 + nr;
 	if (!inode_count[nr]) {
-		if (!inode_in_use (nr)) {
+		if (!inode_in_use(nr)) {
 			get_current_name();
-			printf (_("Inode %d marked unused, "
-				  "but used for file '%s'\n"),
-				nr, current_name);
+			printf(_("Inode %d marked unused, "
+				 "but used for file '%s'\n"), nr, current_name);
 			if (repair) {
-				if (ask (_("Mark in use"), 1))
-					mark_inode (nr);
+				if (ask(_("Mark in use"), 1))
+					mark_inode(nr);
 				else
 					errors_uncorrected = 1;
 			}
 		}
-		if (S_ISDIR (inode->i_mode))
+		if (S_ISDIR(inode->i_mode))
 			directory++;
-		else if (S_ISREG (inode->i_mode))
+		else if (S_ISREG(inode->i_mode))
 			regular++;
-		else if (S_ISCHR (inode->i_mode))
+		else if (S_ISCHR(inode->i_mode))
 			chardev++;
-		else if (S_ISBLK (inode->i_mode))
+		else if (S_ISBLK(inode->i_mode))
 			blockdev++;
-		else if (S_ISLNK (inode->i_mode))
+		else if (S_ISLNK(inode->i_mode))
 			symlinks++;
-		else if (S_ISSOCK (inode->i_mode));
-		else if (S_ISFIFO (inode->i_mode));
+		else if (S_ISSOCK(inode->i_mode)) ;
+		else if (S_ISFIFO(inode->i_mode)) ;
 		else {
-			get_current_name ();
-			printf (_("The file `%s' has mode %05o\n"),
-				current_name, inode->i_mode);
+			get_current_name();
+			printf(_("The file `%s' has mode %05o\n"),
+			       current_name, inode->i_mode);
 		}
 	} else
 		links++;
 	if (!++inode_count[nr]) {
-		printf (_("Warning: inode count too big.\n"));
+		printf(_("Warning: inode count too big.\n"));
 		inode_count[nr]--;
 		errors_uncorrected = 1;
 	}
@@ -763,22 +733,22 @@ get_inode2 (unsigned int nr) {
 
 static void
 check_root(void) {
-	struct minix_inode * inode = Inode + ROOT_INO;
+	struct minix_inode *inode = Inode + ROOT_INO;
 
 	if (!inode || !S_ISDIR(inode->i_mode))
 		die(_("root inode isn't a directory"));
 }
 
 static void
-check_root2 (void) {
+check_root2(void) {
 	struct minix2_inode *inode = Inode2 + ROOT_INO;
 
-	if (!inode || !S_ISDIR (inode->i_mode))
+	if (!inode || !S_ISDIR(inode->i_mode))
 		die(_("root inode isn't a directory"));
 }
 
 static int
-add_zone(unsigned short * znr, int * corrected) {
+add_zone(unsigned short *znr, int *corrected) {
 	int block;
 
 	block = check_zone_nr(znr, corrected);
@@ -788,7 +758,7 @@ add_zone(unsigned short * znr, int * corrected) {
 		get_current_name();
 		printf(_("Block has been used before. Now in file `%s'."),
 		       current_name);
-		if (ask(_("Clear"),1)) {
+		if (ask(_("Clear"), 1)) {
 			*znr = 0;
 			block = 0;
 			*corrected = 1;
@@ -800,7 +770,7 @@ add_zone(unsigned short * znr, int * corrected) {
 		get_current_name();
 		printf(_("Block %d in file `%s' is marked not in use."),
 		       block, current_name);
-		if (ask(_("Correct"),1))
+		if (ask(_("Correct"), 1))
 			mark_zone(block);
 	}
 	if (!++zone_count[block])
@@ -809,17 +779,17 @@ add_zone(unsigned short * znr, int * corrected) {
 }
 
 static int
-add_zone2 (unsigned int *znr, int *corrected) {
+add_zone2(unsigned int *znr, int *corrected) {
 	int block;
 
-	block = check_zone_nr2 (znr, corrected);
+	block = check_zone_nr2(znr, corrected);
 	if (!block)
 		return 0;
 	if (zone_count[block]) {
 		get_current_name();
-		printf (_("Block has been used before. Now in file `%s'."),
-			current_name);
-		if (ask (_("Clear"), 1)) {
+		printf(_("Block has been used before. Now in file `%s'."),
+		       current_name);
+		if (ask(_("Clear"), 1)) {
 			*znr = 0;
 			block = 0;
 			*corrected = 1;
@@ -827,12 +797,12 @@ add_zone2 (unsigned int *znr, int *corrected) {
 	}
 	if (!block)
 		return 0;
-	if (!zone_in_use (block)) {
+	if (!zone_in_use(block)) {
 		get_current_name();
-		printf (_("Block %d in file `%s' is marked not in use."),
-			block, current_name);
-		if (ask (_("Correct"), 1))
-			mark_zone (block);
+		printf(_("Block %d in file `%s' is marked not in use."),
+		       block, current_name);
+		if (ask(_("Correct"), 1))
+			mark_zone(block);
 	}
 	if (!++zone_count[block])
 		zone_count[block]--;
@@ -840,83 +810,83 @@ add_zone2 (unsigned int *znr, int *corrected) {
 }
 
 static void
-add_zone_ind(unsigned short * znr, int * corrected) {
+add_zone_ind(unsigned short *znr, int *corrected) {
 	static char blk[MINIX_BLOCK_SIZE];
-	int i, chg_blk=0;
+	int i, chg_blk = 0;
 	int block;
 
 	block = add_zone(znr, corrected);
 	if (!block)
 		return;
 	read_block(block, blk);
-	for (i=0 ; i < (MINIX_BLOCK_SIZE>>1) ; i++)
-		add_zone(i + (unsigned short *) blk, &chg_blk);
+	for (i = 0; i < (MINIX_BLOCK_SIZE >> 1); i++)
+		add_zone(i + (unsigned short *)blk, &chg_blk);
 	if (chg_blk)
 		write_block(block, blk);
 }
 
 static void
-add_zone_ind2 (unsigned int *znr, int *corrected) {
+add_zone_ind2(unsigned int *znr, int *corrected) {
 	static char blk[MINIX_BLOCK_SIZE];
 	int i, chg_blk = 0;
 	int block;
 
-	block = add_zone2 (znr, corrected);
+	block = add_zone2(znr, corrected);
 	if (!block)
 		return;
-	read_block (block, blk);
+	read_block(block, blk);
 	for (i = 0; i < MINIX_BLOCK_SIZE >> 2; i++)
-		add_zone2 (i + (unsigned int *) blk, &chg_blk);
+		add_zone2(i + (unsigned int *)blk, &chg_blk);
 	if (chg_blk)
-		write_block (block, blk);
+		write_block(block, blk);
 }
 
 static void
-add_zone_dind(unsigned short * znr, int * corrected) {
+add_zone_dind(unsigned short *znr, int *corrected) {
 	static char blk[MINIX_BLOCK_SIZE];
-	int i, blk_chg=0;
+	int i, blk_chg = 0;
 	int block;
 
 	block = add_zone(znr, corrected);
 	if (!block)
 		return;
 	read_block(block, blk);
-	for (i=0 ; i < (MINIX_BLOCK_SIZE>>1) ; i++)
-		add_zone_ind(i + (unsigned short *) blk, &blk_chg);
+	for (i = 0; i < (MINIX_BLOCK_SIZE >> 1); i++)
+		add_zone_ind(i + (unsigned short *)blk, &blk_chg);
 	if (blk_chg)
 		write_block(block, blk);
 }
 
 static void
-add_zone_dind2 (unsigned int *znr, int *corrected) {
+add_zone_dind2(unsigned int *znr, int *corrected) {
 	static char blk[MINIX_BLOCK_SIZE];
 	int i, blk_chg = 0;
 	int block;
 
-	block = add_zone2 (znr, corrected);
+	block = add_zone2(znr, corrected);
 	if (!block)
 		return;
-	read_block (block, blk);
+	read_block(block, blk);
 	for (i = 0; i < MINIX_BLOCK_SIZE >> 2; i++)
-		add_zone_ind2 (i + (unsigned int *) blk, &blk_chg);
+		add_zone_ind2(i + (unsigned int *)blk, &blk_chg);
 	if (blk_chg)
-		write_block (block, blk);
+		write_block(block, blk);
 }
 
 static void
-add_zone_tind2 (unsigned int *znr, int *corrected) {
+add_zone_tind2(unsigned int *znr, int *corrected) {
 	static char blk[MINIX_BLOCK_SIZE];
 	int i, blk_chg = 0;
 	int block;
 
-	block = add_zone2 (znr, corrected);
+	block = add_zone2(znr, corrected);
 	if (!block)
 		return;
-	read_block (block, blk);
+	read_block(block, blk);
 	for (i = 0; i < MINIX_BLOCK_SIZE >> 2; i++)
-		add_zone_dind2 (i + (unsigned int *) blk, &blk_chg);
+		add_zone_dind2(i + (unsigned int *)blk, &blk_chg);
 	if (blk_chg)
-		write_block (block, blk);
+		write_block(block, blk);
 }
 
 static void
@@ -931,14 +901,14 @@ check_zones(unsigned int i) {
 	if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) &&
 	    !S_ISLNK(inode->i_mode))
 		return;
-	for (i=0 ; i<7 ; i++)
+	for (i = 0; i < 7; i++)
 		add_zone(i + inode->i_zone, &changed);
 	add_zone_ind(7 + inode->i_zone, &changed);
 	add_zone_dind(8 + inode->i_zone, &changed);
 }
 
 static void
-check_zones2 (unsigned int i) {
+check_zones2(unsigned int i) {
 	struct minix2_inode *inode;
 
 	if (!i || i > get_ninodes())
@@ -946,65 +916,66 @@ check_zones2 (unsigned int i) {
 	if (inode_count[i] > 1)	/* have we counted this file already? */
 		return;
 	inode = Inode2 + i;
-	if (!S_ISDIR (inode->i_mode) && !S_ISREG (inode->i_mode)
-	    && !S_ISLNK (inode->i_mode))
+	if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode)
+	    && !S_ISLNK(inode->i_mode))
 		return;
 	for (i = 0; i < 7; i++)
-		add_zone2 (i + inode->i_zone, &changed);
-	add_zone_ind2 (7 + inode->i_zone, &changed);
-	add_zone_dind2 (8 + inode->i_zone, &changed);
-	add_zone_tind2 (9 + inode->i_zone, &changed);
+		add_zone2(i + inode->i_zone, &changed);
+	add_zone_ind2(7 + inode->i_zone, &changed);
+	add_zone_dind2(8 + inode->i_zone, &changed);
+	add_zone_tind2(9 + inode->i_zone, &changed);
 }
 
 static void
-check_file(struct minix_inode * dir, unsigned int offset) {
+check_file(struct minix_inode *dir, unsigned int offset) {
 	static char blk[MINIX_BLOCK_SIZE];
-	struct minix_inode * inode;
+	struct minix_inode *inode;
 	unsigned int ino;
-	char * name;
+	char *name;
 	int block;
 
-	block = map_block(dir,offset/MINIX_BLOCK_SIZE);
+	block = map_block(dir, offset / MINIX_BLOCK_SIZE);
 	read_block(block, blk);
 	name = blk + (offset % MINIX_BLOCK_SIZE) + 2;
-	ino = * (unsigned short *) (name-2);
+	ino = *(unsigned short *)(name - 2);
 	if (ino > get_ninodes()) {
 		get_current_name();
 		printf(_("The directory '%s' contains a bad inode number "
-			 "for file '%.*s'."),
-		       current_name, (int) namelen, name);
-		if (ask(_(" Remove"),1)) {
-			*(unsigned short *)(name-2) = 0;
+			 "for file '%.*s'."), current_name, (int)namelen, name);
+		if (ask(_(" Remove"), 1)) {
+			*(unsigned short *)(name - 2) = 0;
 			write_block(block, blk);
 		}
 		ino = 0;
-	}	
+	}
 	if (name_depth < MAX_DEPTH)
-		strncpy (name_list[name_depth], name, namelen);
+		strncpy(name_list[name_depth], name, namelen);
 	name_depth++;
 	inode = get_inode(ino);
 	name_depth--;
 	if (!offset) {
-		if (!inode || strcmp(".",name)) {
+		if (!inode || strcmp(".", name)) {
 			get_current_name();
 			printf(_("%s: bad directory: '.' isn't first\n"),
 			       current_name);
 			errors_uncorrected = 1;
-		} else return;
+		} else
+			return;
 	}
 	if (offset == dirsize) {
-		if (!inode || strcmp("..",name)) {
+		if (!inode || strcmp("..", name)) {
 			get_current_name();
 			printf(_("%s: bad directory: '..' isn't second\n"),
 			       current_name);
 			errors_uncorrected = 1;
-		} else return;
+		} else
+			return;
 	}
 	if (!inode)
 		return;
 	if (name_depth < MAX_DEPTH)
 		strncpy(name_list[name_depth], name, namelen);
-	name_depth++;	
+	name_depth++;
 	if (list) {
 		if (verbose)
 			printf("%6d %07o %3d ", ino,
@@ -1024,47 +995,46 @@ check_file(struct minix_inode * dir, unsigned int offset) {
 }
 
 static void
-check_file2 (struct minix2_inode *dir, unsigned int offset) {
+check_file2(struct minix2_inode *dir, unsigned int offset) {
 	static char blk[MINIX_BLOCK_SIZE];
 	struct minix2_inode *inode;
 	unsigned long ino;
 	char *name;
 	int block;
 
-	block = map_block2 (dir, offset / MINIX_BLOCK_SIZE);
-	read_block (block, blk);
+	block = map_block2(dir, offset / MINIX_BLOCK_SIZE);
+	read_block(block, blk);
 	name = blk + (offset % MINIX_BLOCK_SIZE) + 2;
-	ino = *(unsigned short *) (name - 2);
+	ino = *(unsigned short *)(name - 2);
 	if (ino > get_ninodes()) {
 		get_current_name();
 		printf(_("The directory '%s' contains a bad inode number "
-			 "for file '%.*s'."),
-			  current_name, (int) namelen, name);
-		if (ask (_(" Remove"), 1)) {
-			*(unsigned short *) (name - 2) = 0;
-			write_block (block, blk);
+			 "for file '%.*s'."), current_name, (int)namelen, name);
+		if (ask(_(" Remove"), 1)) {
+			*(unsigned short *)(name - 2) = 0;
+			write_block(block, blk);
 		}
 		ino = 0;
 	}
 	if (name_depth < MAX_DEPTH)
-		strncpy (name_list[name_depth], name, namelen);
+		strncpy(name_list[name_depth], name, namelen);
 	name_depth++;
-	inode = get_inode2 (ino);
+	inode = get_inode2(ino);
 	name_depth--;
 	if (!offset) {
-		if (!inode || strcmp (".", name)) {
-			get_current_name ();
-			printf (_("%s: bad directory: '.' isn't first\n"),
-				current_name);
+		if (!inode || strcmp(".", name)) {
+			get_current_name();
+			printf(_("%s: bad directory: '.' isn't first\n"),
+			       current_name);
 			errors_uncorrected = 1;
 		} else
 			return;
 	}
 	if (offset == dirsize) {
-		if (!inode || strcmp ("..", name)) {
-			get_current_name ();
-			printf (_("%s: bad directory: '..' isn't second\n"),
-				current_name);
+		if (!inode || strcmp("..", name)) {
+			get_current_name();
+			printf(_("%s: bad directory: '..' isn't second\n"),
+			       current_name);
 			errors_uncorrected = 1;
 		} else
 			return;
@@ -1074,25 +1044,25 @@ check_file2 (struct minix2_inode *dir, unsigned int offset) {
 	name_depth++;
 	if (list) {
 		if (verbose)
-			printf ("%6zd %07o %3d ", ino, inode->i_mode,
-				inode->i_nlinks);
-		get_current_name ();
+			printf("%6zd %07o %3d ", ino, inode->i_mode,
+			       inode->i_nlinks);
+		get_current_name();
 		printf("%s", current_name);
-		if (S_ISDIR (inode->i_mode))
-			printf (":\n");
+		if (S_ISDIR(inode->i_mode))
+			printf(":\n");
 		else
-			printf ("\n");
+			printf("\n");
 	}
-	check_zones2 (ino);
-	if (inode && S_ISDIR (inode->i_mode))
-		recursive_check2 (ino);
+	check_zones2(ino);
+	if (inode && S_ISDIR(inode->i_mode))
+		recursive_check2(ino);
 	name_depth--;
 	return;
 }
 
 static void
 recursive_check(unsigned int ino) {
-	struct minix_inode * dir;
+	struct minix_inode *dir;
 	unsigned int offset;
 
 	dir = Inode + ino;
@@ -1100,37 +1070,35 @@ recursive_check(unsigned int ino) {
 		die(_("internal error"));
 	if (dir->i_size < 2 * dirsize) {
 		get_current_name();
-		printf(_("%s: bad directory: size < 32"),
-		       current_name);
+		printf(_("%s: bad directory: size < 32"), current_name);
 		errors_uncorrected = 1;
 	}
-	for (offset = 0 ; offset < dir->i_size ; offset += dirsize)
-		check_file(dir,offset);
+	for (offset = 0; offset < dir->i_size; offset += dirsize)
+		check_file(dir, offset);
 }
 
 static void
-recursive_check2 (unsigned int ino) {
+recursive_check2(unsigned int ino) {
 	struct minix2_inode *dir;
 	unsigned int offset;
 
 	dir = Inode2 + ino;
-	if (!S_ISDIR (dir->i_mode))
+	if (!S_ISDIR(dir->i_mode))
 		die(_("internal error"));
 	if (dir->i_size < 2 * dirsize) {
-		get_current_name ();
-		printf (_("%s: bad directory: size < 32"),
-			current_name);
+		get_current_name();
+		printf(_("%s: bad directory: size < 32"), current_name);
 		errors_uncorrected = 1;
 	}
 	for (offset = 0; offset < dir->i_size; offset += dirsize)
-		check_file2 (dir, offset);
+		check_file2(dir, offset);
 }
 
 static int
 bad_zone(int i) {
 	char buffer[1024];
 
-	if (MINIX_BLOCK_SIZE*i != lseek(IN, MINIX_BLOCK_SIZE*i, SEEK_SET))
+	if (MINIX_BLOCK_SIZE * i != lseek(IN, MINIX_BLOCK_SIZE * i, SEEK_SET))
 		die(_("seek failed in bad_zone"));
 	return (MINIX_BLOCK_SIZE != read(IN, buffer, MINIX_BLOCK_SIZE));
 }
@@ -1139,10 +1107,10 @@ static void
 check_counts(void) {
 	unsigned long i;
 
-	for (i=1 ; i <= get_ninodes(); i++) {
+	for (i = 1; i <= get_ninodes(); i++) {
 		if (!inode_in_use(i) && Inode[i].i_mode && warn_mode) {
 			printf(_("Inode %lu mode not cleared."), i);
-			if (ask(_("Clear"),1)) {
+			if (ask(_("Clear"), 1)) {
 				Inode[i].i_mode = 0;
 				changed = 1;
 			}
@@ -1150,35 +1118,35 @@ check_counts(void) {
 		if (!inode_count[i]) {
 			if (!inode_in_use(i))
 				continue;
-			printf(_("Inode %lu not used, marked used in the bitmap."),
-				i);
-			if (ask(_("Clear"),1))
+			printf(_("Inode %lu not used, marked used in the bitmap."), i);
+			if (ask(_("Clear"), 1))
 				unmark_inode(i);
 			continue;
 		}
 		if (!inode_in_use(i)) {
-			printf(_("Inode %lu used, marked unused in the bitmap."),
-				i);
-			if (ask(_("Set"),1))
+			printf(_("Inode %lu used, marked unused in the bitmap."), i);
+			if (ask(_("Set"), 1))
 				mark_inode(i);
 		}
 		if (Inode[i].i_nlinks != inode_count[i]) {
 			printf(_("Inode %lu (mode = %07o), i_nlinks=%d, counted=%d."),
-				i,Inode[i].i_mode,Inode[i].i_nlinks,inode_count[i]);
-			if (ask(_("Set i_nlinks to count"),1)) {
-				Inode[i].i_nlinks=inode_count[i];
-				changed=1;
+			       i, Inode[i].i_mode, Inode[i].i_nlinks,
+			       inode_count[i]);
+			if (ask(_("Set i_nlinks to count"), 1)) {
+				Inode[i].i_nlinks = inode_count[i];
+				changed = 1;
 			}
 		}
 	}
-	for (i=get_first_zone() ; i < get_nzones() ; i++) {
+	for (i = get_first_zone(); i < get_nzones(); i++) {
 		if (zone_in_use(i) == zone_count[i])
 			continue;
 		if (!zone_count[i]) {
 			if (bad_zone(i))
 				continue;
-			printf(_("Zone %lu: marked in use, no file uses it."),i);
-			if (ask(_("Unmark"),1))
+			printf(_("Zone %lu: marked in use, no file uses it."),
+			       i);
+			if (ask(_("Unmark"), 1))
 				unmark_zone(i);
 			continue;
 		}
@@ -1192,80 +1160,81 @@ check_counts(void) {
 }
 
 static void
-check_counts2 (void) {
+check_counts2(void) {
 	unsigned long i;
 
 	for (i = 1; i <= get_ninodes(); i++) {
-		if (!inode_in_use (i) && Inode2[i].i_mode && warn_mode) {
-			printf (_("Inode %lu mode not cleared."), i);
-			if (ask (_("Clear"), 1)) {
+		if (!inode_in_use(i) && Inode2[i].i_mode && warn_mode) {
+			printf(_("Inode %lu mode not cleared."), i);
+			if (ask(_("Clear"), 1)) {
 				Inode2[i].i_mode = 0;
 				changed = 1;
 			}
 		}
 		if (!inode_count[i]) {
-			if (!inode_in_use (i))
+			if (!inode_in_use(i))
 				continue;
-			printf (_("Inode %lu not used, marked used in the bitmap."), i);
-			if (ask (_("Clear"), 1))
-				unmark_inode (i);
+			printf(_("Inode %lu not used, marked used in the bitmap."), i);
+			if (ask(_("Clear"), 1))
+				unmark_inode(i);
 			continue;
 		}
-		if (!inode_in_use (i)) {
-			printf (_("Inode %lu used, marked unused in the bitmap."), i);
-			if (ask (_("Set"), 1))
-				mark_inode (i);
+		if (!inode_in_use(i)) {
+			printf(_("Inode %lu used, marked unused in the bitmap."), i);
+			if (ask(_("Set"), 1))
+				mark_inode(i);
 		}
 		if (Inode2[i].i_nlinks != inode_count[i]) {
-			printf (_("Inode %lu (mode = %07o), i_nlinks=%d, counted=%d."),
-				i, Inode2[i].i_mode, Inode2[i].i_nlinks, inode_count[i]);
-			if (ask (_("Set i_nlinks to count"), 1)) {
+			printf(_("Inode %lu (mode = %07o), i_nlinks=%d, counted=%d."),
+			       i, Inode2[i].i_mode, Inode2[i].i_nlinks,
+			       inode_count[i]);
+			if (ask(_("Set i_nlinks to count"), 1)) {
 				Inode2[i].i_nlinks = inode_count[i];
 				changed = 1;
 			}
 		}
 	}
 	for (i = get_first_zone(); i < get_nzones(); i++) {
-		if (zone_in_use (i) == zone_count[i])
+		if (zone_in_use(i) == zone_count[i])
 			continue;
 		if (!zone_count[i]) {
-			if (bad_zone (i))
+			if (bad_zone(i))
 				continue;
-			printf (_("Zone %lu: marked in use, no file uses it."),
-				i);
-			if (ask (_("Unmark"), 1))
-				unmark_zone (i);
+			printf(_("Zone %lu: marked in use, no file uses it."),
+			       i);
+			if (ask(_("Unmark"), 1))
+				unmark_zone(i);
 			continue;
 		}
-		if (zone_in_use (i))
-			printf (_("Zone %lu: in use, counted=%d\n"),
-				i, zone_count[i]);
+		if (zone_in_use(i))
+			printf(_("Zone %lu: in use, counted=%d\n"),
+			       i, zone_count[i]);
 		else
-			printf (_("Zone %lu: not in use, counted=%d\n"),
-				i, zone_count[i]);
+			printf(_("Zone %lu: not in use, counted=%d\n"),
+			       i, zone_count[i]);
 	}
 }
 
 static void
 check(void) {
-	memset(inode_count,0,(get_ninodes() + 1) * sizeof(*inode_count));
-	memset(zone_count,0, get_nzones()*sizeof(*zone_count));
+	memset(inode_count, 0, (get_ninodes() + 1) * sizeof(*inode_count));
+	memset(zone_count, 0, get_nzones() * sizeof(*zone_count));
 	check_zones(ROOT_INO);
 	recursive_check(ROOT_INO);
 	check_counts();
 }
 
 static void
-check2 (void) {
-	memset (inode_count, 0, (get_ninodes() + 1) * sizeof (*inode_count));
-	memset (zone_count, 0, get_nzones() * sizeof (*zone_count));
-	check_zones2 (ROOT_INO);
-	recursive_check2 (ROOT_INO);
-	check_counts2 ();
+check2(void) {
+	memset(inode_count, 0, (get_ninodes() + 1) * sizeof(*inode_count));
+	memset(zone_count, 0, get_nzones() * sizeof(*zone_count));
+	check_zones2(ROOT_INO);
+	recursive_check2(ROOT_INO);
+	check_counts2();
 }
 
 int
-main(int argc, char ** argv) {
+main(int argc, char **argv) {
 	struct termios tmp;
 	int count;
 	int retcode = 0;
@@ -1292,17 +1261,35 @@ main(int argc, char ** argv) {
 				usage();
 			else
 				device_name = argv[0];
-		} else while (*++argv[0])
-			switch (argv[0][0]) {
-				case 'l': list=1; break;
-				case 'a': automatic=1; repair=1; break;
-				case 'r': automatic=0; repair=1; break;
-				case 'v': verbose=1; break;
-				case 's': show=1; break;
-				case 'm': warn_mode=1; break;
-				case 'f': force=1; break;
-				default: usage();
-			}
+		} else
+			while (*++argv[0])
+				switch (argv[0][0]) {
+				case 'l':
+					list = 1;
+					break;
+				case 'a':
+					automatic = 1;
+					repair = 1;
+					break;
+				case 'r':
+					automatic = 0;
+					repair = 1;
+					break;
+				case 'v':
+					verbose = 1;
+					break;
+				case 's':
+					show = 1;
+					break;
+				case 'm':
+					warn_mode = 1;
+					break;
+				case 'f':
+					force = 1;
+					break;
+				default:
+					usage();
+				}
 	}
 	if (!device_name)
 		usage();
@@ -1311,52 +1298,46 @@ main(int argc, char ** argv) {
 		if (!isatty(0) || !isatty(1))
 			die(_("need terminal for interactive repairs"));
 	}
-	IN = open(device_name,repair?O_RDWR:O_RDONLY);
+	IN = open(device_name, repair ? O_RDWR : O_RDONLY);
 	if (IN < 0)
 		die(_("unable to open '%s': %m"), device_name);
-	for (count=0 ; count<3 ; count++)
+	for (count = 0; count < 3; count++)
 		sync();
 	read_superblock();
 
-	/*
-	 * Determine whether or not we should continue with the checking.
-	 * This is based on the status of the filesystem valid and error
-	 * flags and whether or not the -f switch was specified on the 
-	 * command line.
-	 */
-	if ( !(Super.s_state & MINIX_ERROR_FS) && 
-	      (Super.s_state & MINIX_VALID_FS) && 
-	      !force ) {
+	/* Determine whether or not we should continue with the checking.  This
+	 * is based on the status of the filesystem valid and error flags and
+	 * whether or not the -f switch was specified on the command line.  */
+	if (!(Super.s_state & MINIX_ERROR_FS) &&
+	    (Super.s_state & MINIX_VALID_FS) && !force) {
 		if (repair)
 			printf(_("%s is clean, no check.\n"), device_name);
 		return retcode;
-	}
-	else if (force)
+	} else if (force)
 		printf(_("Forcing filesystem check on %s.\n"), device_name);
 	else if (repair)
-		printf(_("Filesystem on %s is dirty, needs checking.\n"),\
-			device_name);
+		printf(_("Filesystem on %s is dirty, needs checking.\n"),
+		       device_name);
 
 	read_tables();
 
-	/* Restore the terminal state on fatal signals.
-	 * We don't do this for SIGALRM, SIGUSR1 or SIGUSR2.
-	 */
+	/* Restore the terminal state on fatal signals.  We don't do this for
+	 * SIGALRM, SIGUSR1 or SIGUSR2.  */
 	signal(SIGINT, fatalsig);
 	signal(SIGQUIT, fatalsig);
 	signal(SIGTERM, fatalsig);
 
 	if (repair && !automatic) {
-		tcgetattr(0,&termios);
+		tcgetattr(0, &termios);
 		tmp = termios;
-		tmp.c_lflag &= ~(ICANON|ECHO);
-		tcsetattr(0,TCSANOW,&tmp);
+		tmp.c_lflag &= ~(ICANON | ECHO);
+		tcsetattr(0, TCSANOW, &tmp);
 		termios_set = 1;
 	}
 
 	if (fs_version == 2) {
-		check_root2 ();
-		check2 ();
+		check_root2();
+		check2();
 	} else {
 		check_root();
 		check();
@@ -1364,44 +1345,45 @@ main(int argc, char ** argv) {
 	if (verbose) {
 		unsigned long i, free;
 
-		for (i=1,free=0 ; i <= get_ninodes() ; i++)
+		for (i = 1, free = 0; i <= get_ninodes(); i++)
 			if (!inode_in_use(i))
 				free++;
-		printf(_("\n%6ld inodes used (%ld%%)\n"),(get_ninodes()-free),
-		       100*(get_ninodes()-free)/get_ninodes());
-		for (i=get_first_zone(),free=0 ; i < get_nzones(); i++)
+		printf(_("\n%6ld inodes used (%ld%%)\n"),
+		       (get_ninodes() - free),
+		       100 * (get_ninodes() - free) / get_ninodes());
+		for (i = get_first_zone(), free = 0; i < get_nzones(); i++)
 			if (!zone_in_use(i))
 				free++;
-		printf(_("%6ld zones used (%ld%%)\n"),(get_nzones()-free),
-		       100*(get_nzones()-free)/get_nzones());
+		printf(_("%6ld zones used (%ld%%)\n"), (get_nzones() - free),
+		       100 * (get_nzones() - free) / get_nzones());
 		printf(_("\n%6d regular files\n"
-		"%6d directories\n"
-		"%6d character device files\n"
-		"%6d block device files\n"
-		"%6d links\n"
-		"%6d symbolic links\n"
-		"------\n"
-		"%6d files\n"),
-		regular,directory,chardev,blockdev,
-		links-2*directory+1,symlinks,total-2*directory+1);
+			 "%6d directories\n"
+			 "%6d character device files\n"
+			 "%6d block device files\n"
+			 "%6d links\n"
+			 "%6d symbolic links\n"
+			 "------\n"
+			 "%6d files\n"),
+		       regular, directory, chardev, blockdev,
+		       links - 2 * directory + 1, symlinks,
+		       total - 2 * directory + 1);
 	}
 	if (changed) {
 		write_tables();
-		printf(_(	"----------------------------\n"
-			"FILE SYSTEM HAS BEEN CHANGED\n"
-			"----------------------------\n"));
-		for (count=0 ; count<3 ; count++)
+		printf(_("----------------------------\n"
+			 "FILE SYSTEM HAS BEEN CHANGED\n"
+			 "----------------------------\n"));
+		for (count = 0; count < 3; count++)
 			sync();
-	}
-	else if ( repair )
+	} else if (repair)
 		write_super_block();
-	
+
 	if (repair && !automatic)
-		tcsetattr(0,TCSANOW,&termios);
+		tcsetattr(0, TCSANOW, &termios);
 
 	if (changed)
-	      retcode += 3;
+		retcode += 3;
 	if (errors_uncorrected)
-	      retcode += 4;
+		retcode += 4;
 	return retcode;
 }