Many files:

  badblocks.c, e2fsck.h, ehandler.c, emptydir.c, extend.c, flushb.c,
  	iscan.c, message.c, pass1.c, pass1b.c, pass3.c pass4.c, pass5.c,
  	problem.c, scantest.c, swapfs.c, unix.c, util.c: Add
  	Internationalization support as suggested by Marco d'Itri
  	<md@linux.it>.

19 files changed, 473 insertions, 397 deletions

diff --git a/e2fsck/ChangeLog b/e2fsck/ChangeLog
index d48ae4d4..90ef4341 100644
--- a/e2fsck/ChangeLog
+++ b/e2fsck/ChangeLog
@@ -1,3 +1,11 @@
+2000-02-06  Theodore Ts'o  <tytso@valinux.com>
+
+	* badblocks.c, e2fsck.h, ehandler.c, emptydir.c, extend.c,
+		flushb.c, iscan.c, message.c, pass1.c, pass1b.c, pass3.c
+		pass4.c, pass5.c, problem.c, scantest.c, swapfs.c, 
+		unix.c, util.c: Add Internationalization support as 
+		suggested by Marco d'Itri <md@linux.it>.
+
 2000-02-02  Theodore Ts'o  <tytso@valinux.com>
 
 	* e2fsck.h, flushb.c, scantest.c: Remove uneeded include of
diff --git a/e2fsck/badblocks.c b/e2fsck/badblocks.c
index bd7cafa2..f4357929 100644
--- a/e2fsck/badblocks.c
+++ b/e2fsck/badblocks.c
@@ -19,7 +19,7 @@ static int check_bb_inode_blocks(ext2_filsys fs, blk_t *block_nr, int blockcnt,
 
 static void invalid_block(ext2_filsys fs, blk_t blk)
 {
-	printf("Bad block %u out of range; ignored.\n", blk);
+	printf(_("Bad block %u out of range; ignored.\n"), blk);
 	return;
 }
 
@@ -42,7 +42,7 @@ void read_bad_blocks_file(e2fsck_t ctx, const char *bad_blocks_file,
 				      check_bb_inode_blocks, 0);
 	if (retval) {
 		com_err("ext2fs_block_iterate", retval,
-			"while sanity checking the bad blocks inode");
+			_("while sanity checking the bad blocks inode"));
 		goto fatal;
 	}
 	
@@ -54,7 +54,7 @@ void read_bad_blocks_file(e2fsck_t ctx, const char *bad_blocks_file,
 		retval = ext2fs_read_bb_inode(fs, &bb_list);
 		if (retval) {
 			com_err("ext2fs_read_bb_inode", retval,
-				"while reading the bad blocks inode");
+				_("while reading the bad blocks inode"));
 			goto fatal;
 		}
 	}
@@ -68,7 +68,7 @@ void read_bad_blocks_file(e2fsck_t ctx, const char *bad_blocks_file,
 		f = fopen(bad_blocks_file, "r");
 		if (!f) {
 			com_err("read_bad_blocks_file", errno,
-				"while trying to open %s", bad_blocks_file);
+				_("while trying to open %s"), bad_blocks_file);
 			goto fatal;
 		}
 	} else {
@@ -78,7 +78,7 @@ void read_bad_blocks_file(e2fsck_t ctx, const char *bad_blocks_file,
 		f = popen(buf, "r");
 		if (!f) {
 			com_err("read_bad_blocks_file", errno,
-				"while trying popen '%s'", buf);
+				_("while trying popen '%s'"), buf);
 			goto fatal;
 		}
 	}
@@ -89,7 +89,7 @@ void read_bad_blocks_file(e2fsck_t ctx, const char *bad_blocks_file,
 		pclose(f);
 	if (retval) {
 		com_err("ext2fs_read_bb_FILE", retval,
-			"while reading in list of bad blocks from file");
+			_("while reading in list of bad blocks from file"));
 		goto fatal;
 	}
 	
@@ -99,7 +99,7 @@ void read_bad_blocks_file(e2fsck_t ctx, const char *bad_blocks_file,
 	retval = ext2fs_update_bb_inode(fs, bb_list);
 	if (retval) {
 		com_err("ext2fs_update_bb_inode", retval,
-			"while updating bad block inode");
+			_("while updating bad block inode"));
 		goto fatal;
 	}
 
@@ -128,7 +128,7 @@ static int check_bb_inode_blocks(ext2_filsys fs, blk_t *block_nr, int blockcnt,
 	 */
 	if (*block_nr >= fs->super->s_blocks_count ||
 	    *block_nr < fs->super->s_first_data_block) {
-		printf("Warning illegal block %u found in bad block inode.  Cleared.\n", *block_nr);
+		printf(_("Warning illegal block %u found in bad block inode.  Cleared.\n"), *block_nr);
 		*block_nr = 0;
 		return BLOCK_CHANGED;
 	}
diff --git a/e2fsck/e2fsck.h b/e2fsck/e2fsck.h
index 9ee43c87..cd648ab0 100644
--- a/e2fsck/e2fsck.h
+++ b/e2fsck/e2fsck.h
@@ -31,6 +31,24 @@
 #include "ext2fs/ext2fs.h"
 #endif
 
+#ifdef ENABLE_NLS
+#include <libintl.h>
+#include <locale.h>
+#define _(a) (gettext (a))
+#ifdef gettext_noop
+#define N_(a) gettext_noop (a)
+#else
+#define N_(a) (a)
+#endif
+/* FIXME */
+#define NLS_CAT_NAME "e2fsprogs"
+#define LOCALEDIR "/usr/share/locale"
+/* FIXME */
+#else
+#define _(a) (a)
+#define N_(a) a
+#endif
+
 
 /* Everything is STDC, these days */
 #define NOARGS void
diff --git a/e2fsck/ehandler.c b/e2fsck/ehandler.c
index 9f1a0bc6..bd1643e7 100644
--- a/e2fsck/ehandler.c
+++ b/e2fsck/ehandler.c
@@ -50,13 +50,13 @@ static errcode_t e2fsck_handle_read_error(io_channel channel,
 		return 0;
 	}
 	if (operation)
-		printf("Error reading block %lu (%s) while %s.  ", block,
+		printf(_("Error reading block %lu (%s) while %s.  "), block,
 		       error_message(error), operation);
 	else
-		printf("Error reading block %lu (%s).  ", block,
+		printf(_("Error reading block %lu (%s).  "), block,
 		       error_message(error));
 	preenhalt(ctx);
-	if (ask(ctx, "Ignore error", 1))
+	if (ask(ctx, _("Ignore error"), 1))
 		return 0;
 
 	return error;
@@ -94,13 +94,13 @@ static errcode_t e2fsck_handle_write_error(io_channel channel,
 	}
 	
 	if (operation)
-		printf("Error writing block %lu (%s) while %s.  ", block,
+		printf(_("Error writing block %lu (%s) while %s.  "), block,
 		       error_message(error), operation);
 	else
-		printf("Error writing block %lu (%s).  ", block,
+		printf(_("Error writing block %lu (%s).  "), block,
 		       error_message(error));
 	preenhalt(ctx);
-	if (ask(ctx, "Ignore error", 1))
+	if (ask(ctx, _("Ignore error"), 1))
 		return 0;
 
 	return error;
diff --git a/e2fsck/emptydir.c b/e2fsck/emptydir.c
index 6229a6bf..04278297 100644
--- a/e2fsck/emptydir.c
+++ b/e2fsck/emptydir.c
@@ -53,12 +53,12 @@ empty_dir_info init_empty_dir(e2fsck_t ctx)
 	if (retval)
 		goto errout;
 	
-	retval = ext2fs_allocate_block_bitmap(ctx->fs, "empty dirblocks",
+	retval = ext2fs_allocate_block_bitmap(ctx->fs, _("empty dirblocks"),
 					      &edi->empty_dir_blocks);
 	if (retval)
 		goto errout;
 
-	retval = ext2fs_allocate_inode_bitmap(ctx->fs, "empty dir map",
+	retval = ext2fs_allocate_inode_bitmap(ctx->fs, _("empty dir map"),
 					      &edi->dir_map);
 	if (retval)
 		goto errout;
@@ -94,7 +94,7 @@ void add_empty_dirblock(empty_dir_info edi,
 	if (db->ino == 11)
 		return;		/* Inode number 11 is usually lost+found */
 
-	printf("Empty directory block %d (#%d) in inode %d\n",
+	printf(_("Empty directory block %d (#%d) in inode %d\n"),
 	       db->blk, db->blockcnt, db->ino);
 
 	ext2fs_mark_block_bitmap(edi->empty_dir_blocks, db->blk);
diff --git a/e2fsck/extend.c b/e2fsck/extend.c
index 646348d4..a1a45573 100644
--- a/e2fsck/extend.c
+++ b/e2fsck/extend.c
@@ -17,7 +17,7 @@
 
 static void usage(char *progname)
 {
-	fprintf(stderr, "%s: %s filename nblocks blocksize\n",
+	fprintf(stderr, _("%s: %s filename nblocks blocksize\n"),
 		progname, progname);
 	exit(1);
 }
@@ -39,13 +39,13 @@ int main(int argc, char **argv)
 	blocksize = strtoul(argv[3], 0, 0);
 
 	if (nblocks < 0) {
-		fprintf(stderr, "Illegal number of blocks!\n");
+		fprintf(stderr, _("Illegal number of blocks!\n"));
 		exit(1);
 	}
 
 	block = malloc(blocksize);
 	if (block == 0) {
-		fprintf(stderr, "Couldn't allocate block buffer(size=%d)\n",
+		fprintf(stderr, _("Couldn't allocate block buffer (size=%d)\n"),
 			blocksize);
 		exit(1);
 	}
diff --git a/e2fsck/flushb.c b/e2fsck/flushb.c
index 34ebe6da..6da1c229 100644
--- a/e2fsck/flushb.c
+++ b/e2fsck/flushb.c
@@ -20,7 +20,7 @@ const char *progname;
 
 static void usage(NOARGS)
 {
-	fprintf(stderr, "Usage: %s disk\n", progname);
+	fprintf(stderr, _("Usage: %s disk\n"), progname);
 	exit(1);
 }	
 	
@@ -49,7 +49,7 @@ int main(int argc, char **argv)
 	return 0;
 #else
 	fprintf(stderr,
-		"BLKFLSBUF ioctl not supported!  Can't flush buffers.\n");
+		_("BLKFLSBUF ioctl not supported!  Can't flush buffers.\n"));
 	return 1;
 #endif
 }
diff --git a/e2fsck/iscan.c b/e2fsck/iscan.c
index 72acb016..16fb5911 100644
--- a/e2fsck/iscan.c
+++ b/e2fsck/iscan.c
@@ -41,7 +41,7 @@ struct resource_track	global_rtrack;
 static void usage(NOARGS)
 {
 	fprintf(stderr,
-		"Usage: %s [-F] [-I inode_buffer_blocks] device\n",
+		_("Usage: %s [-F] [-I inode_buffer_blocks] device\n"),
 		program_name);
 	exit(1);
 }
@@ -66,7 +66,7 @@ static void PRS(int argc, char *argv[])
 #ifdef BLKFLSBUF
 			flush = 1;
 #else
-			fprintf(stderr, "-F not supported");
+			fprintf(stderr, _("-F not supported"));
 			exit(1);
 #endif
 			break;
@@ -82,18 +82,18 @@ static void PRS(int argc, char *argv[])
 		int	fd = open(device_name, O_RDONLY, 0);
 
 		if (fd < 0) {
-			com_err("open", errno, "while opening %s for flushing",
-				device_name);
+			com_err("open", errno,
+			    _("while opening %s for flushing"), device_name);
 			exit(FSCK_ERROR);
 		}
 		if (ioctl(fd, BLKFLSBUF, 0) < 0) {
-			com_err("BLKFLSBUF", errno, "while trying to flush %s",
-				device_name);
+			com_err("BLKFLSBUF", errno,
+				_("while trying to flush %s"), device_name);
 			exit(FSCK_ERROR);
 		}
 		close(fd);
 #else
-		fprintf(stderr, "BLKFLSBUF not supported");
+		fprintf(stderr, _("BLKFLSBUF not supported"));
 		exit(1);
 #endif /* BLKFLSBUF */
 	}
@@ -116,7 +116,7 @@ int main (int argc, char *argv[])
 	retval = ext2fs_open(device_name, 0,
 			     0, 0, unix_io_manager, &fs);
 	if (retval) {
-		com_err(program_name, retval, "while trying to open %s",
+		com_err(program_name, retval, _("while trying to open %s"),
 			device_name);
 		exit(1);
 	}
@@ -125,7 +125,7 @@ int main (int argc, char *argv[])
 	
 	retval = ext2fs_open_inode_scan(fs, inode_buffer_blocks, &scan);
 	if (retval) {
-		com_err(program_name, retval, "while opening inode scan");
+		com_err(program_name, retval, _("while opening inode scan"));
 		exit(1);
 	}
 
@@ -133,7 +133,7 @@ int main (int argc, char *argv[])
 		retval = ext2fs_get_next_inode(scan, &ino, &inode);
 		if (retval) {
 			com_err(program_name, retval,
-				"while getting next inode");
+				_("while getting next inode"));
 			exit(1);
 		}
 		if (ino == 0)
@@ -142,7 +142,7 @@ int main (int argc, char *argv[])
 	}
 	
 	print_resource_track(NULL, &global_rtrack);
-	printf("%d inodes scanned.\n", num_inodes);
+	printf(_("%d inodes scanned.\n"), num_inodes);
 	
 	exit(0);
 }
diff --git a/e2fsck/message.c b/e2fsck/message.c
index cf0bc7b6..bace3c51 100644
--- a/e2fsck/message.c
+++ b/e2fsck/message.c
@@ -92,26 +92,26 @@
  * letter <i> in the table below.
  */
 static const char *abbrevs[] = {
-	"Aerror allocating",
-	"bblock",
-	"Bbitmap",
-	"Cconflicts with some other fs @b",
-	"iinode",
-	"Iillegal",
-	"Ddeleted",
-	"ddirectory",
-	"eentry",
-	"E@e '%Dn' in %p (%i)",
-	"ffilesystem",
-	"Ffor @i %i (%Q) is",
-	"ggroup",
-	"llost+found",
-	"Lis a link",
-	"uunattached",
-	"rroot @i",
-	"sshould be",
-	"Ssuper@b",
-	"zzero-length",
+	N_("Aerror allocating"),
+	N_("bblock"),
+	N_("Bbitmap"),
+	N_("Cconflicts with some other fs @b"),
+	N_("iinode"),
+	N_("Iillegal"),
+	N_("Ddeleted"),
+	N_("ddirectory"),
+	N_("eentry"),
+	N_("E@e '%Dn' in %p (%i)"),
+	N_("ffilesystem"),
+	N_("Ffor @i %i (%Q) is"),
+	N_("ggroup"),
+	N_("llost+found"),
+	N_("Lis a link"),
+	N_("uunattached"),
+	N_("rroot @i"),
+	N_("sshould be"),
+	N_("Ssuper@b"),
+	N_("zzero-length"),
 	"@@",
 	0
 	};
@@ -122,13 +122,13 @@ static const char *abbrevs[] = {
 #define num_special_inodes	7
 static const char *special_inode_name[] =
 {
-	"<The NULL inode>",			/* 0 */
-	"<The bad blocks inode>", 		/* 1 */
+	N_("<The NULL inode>"),			/* 0 */
+	N_("<The bad blocks inode>"),		/* 1 */
 	"/",					/* 2 */
-	"<The ACL index inode>",		/* 3 */
-	"<The ACL data inode>",			/* 4 */
-	"<The boot loader inode>",		/* 5 */
-	"<The undelete directory inode>"	/* 6 */
+	N_("<The ACL index inode>"),		/* 3 */
+	N_("<The ACL data inode>"),		/* 4 */
+	N_("<The boot loader inode>"),		/* 5 */
+	N_("<The undelete directory inode>")	/* 6 */
 };
 
 /*
@@ -167,7 +167,7 @@ static void print_pathname(ext2_filsys fs, ino_t dir, ino_t ino)
 	char		*path;
 
 	if (!dir && (ino < num_special_inodes)) {
-		fputs(special_inode_name[ino], stdout);
+		fputs(_(special_inode_name[ino]), stdout);
 		return;
 	}
 	
@@ -202,7 +202,7 @@ static _INLINE_ void expand_at_expression(e2fsck_t ctx, char ch,
 			*first = 0;
 			fputc(toupper(*str++), stdout);
 		}
-		print_e2fsck_message(ctx, str, pctx, *first);
+		print_e2fsck_message(ctx, _(str), pctx, *first);
 	} else
 		printf("@%c", ch);
 }
diff --git a/e2fsck/pass1.c b/e2fsck/pass1.c
index e80fb566..25dd09dc 100644
--- a/e2fsck/pass1.c
+++ b/e2fsck/pass1.c
@@ -206,7 +206,7 @@ void e2fsck_pass1(e2fsck_t ctx)
 	/*
 	 * Allocate bitmaps structures
 	 */
-	pctx.errcode = ext2fs_allocate_inode_bitmap(fs, "in-use inode map",
+	pctx.errcode = ext2fs_allocate_inode_bitmap(fs, _("in-use inode map"),
 					      &ctx->inode_used_map);
 	if (pctx.errcode) {
 		pctx.num = 1;
@@ -214,8 +214,8 @@ void e2fsck_pass1(e2fsck_t ctx)
 		ctx->flags |= E2F_FLAG_ABORT;
 		return;
 	}
-	pctx.errcode = ext2fs_allocate_inode_bitmap(fs, "directory inode map",
-					      &ctx->inode_dir_map);
+	pctx.errcode = ext2fs_allocate_inode_bitmap(fs,
+				_("directory inode map"), &ctx->inode_dir_map);
 	if (pctx.errcode) {
 		pctx.num = 2;
 		fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
@@ -223,15 +223,14 @@ void e2fsck_pass1(e2fsck_t ctx)
 		return;
 	}
 	pctx.errcode = ext2fs_allocate_inode_bitmap(fs,
-						    "regular file inode map",
-					      &ctx->inode_reg_map);
+			_("regular file inode map"), &ctx->inode_reg_map);
 	if (pctx.errcode) {
 		pctx.num = 6;
 		fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
 		ctx->flags |= E2F_FLAG_ABORT;
 		return;
 	}
-	pctx.errcode = ext2fs_allocate_block_bitmap(fs, "in-use block map",
+	pctx.errcode = ext2fs_allocate_block_bitmap(fs, _("in-use block map"),
 					      &ctx->block_found_map);
 	if (pctx.errcode) {
 		pctx.num = 1;
@@ -239,7 +238,7 @@ void e2fsck_pass1(e2fsck_t ctx)
 		ctx->flags |= E2F_FLAG_ABORT;
 		return;
 	}
-	pctx.errcode = ext2fs_allocate_block_bitmap(fs, "illegal block map",
+	pctx.errcode = ext2fs_allocate_block_bitmap(fs, _("illegal block map"),
 					      &ctx->block_illegal_map);
 	if (pctx.errcode) {
 		pctx.num = 2;
@@ -272,7 +271,7 @@ void e2fsck_pass1(e2fsck_t ctx)
 	block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 3,
 						    "block interate buffer");
 	e2fsck_use_inode_shortcuts(ctx, 1);
-	ehandler_operation("doing inode scan");
+	ehandler_operation(_("doing inode scan"));
 	pctx.errcode = ext2fs_open_inode_scan(fs, ctx->inode_buffer_blocks, 
 					      &scan);
 	if (pctx.errcode) {
@@ -583,7 +582,7 @@ endit:
 #ifdef RESOURCE_TRACK
 	if (ctx->options & E2F_OPT_TIME2) {
 		e2fsck_clear_progbar(ctx);
-		print_resource_track("Pass 1", &rtrack);
+		print_resource_track(_("Pass 1"), &rtrack);
 	}
 #endif
 }
@@ -641,7 +640,8 @@ static void process_inodes(e2fsck_t ctx, char *block_buf)
 #if 0
 		printf("%u ", pctx.ino);
 #endif
-		sprintf(buf, "reading indirect blocks of inode %lu", pctx.ino);
+		sprintf(buf, _("reading indirect blocks of inode %lu"),
+			pctx.ino);
 		ehandler_operation(buf);
 		check_blocks(ctx, &pctx, block_buf);
 		if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
@@ -676,7 +676,7 @@ static void alloc_bad_map(e2fsck_t ctx)
 	
 	clear_problem_context(&pctx);
 	
-	pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs, "bad inode map",
+	pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs, _("bad inode map"),
 					      &ctx->inode_bad_map);
 	if (pctx.errcode) {
 		pctx.num = 3;
@@ -696,7 +696,7 @@ static void alloc_bb_map(e2fsck_t ctx)
 	
 	clear_problem_context(&pctx);
 	pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
-					      "inode in bad block map",
+					      _("inode in bad block map"),
 					      &ctx->inode_bb_map);
 	if (pctx.errcode) {
 		pctx.num = 4;
@@ -716,7 +716,7 @@ static void alloc_imagic_map(e2fsck_t ctx)
 	
 	clear_problem_context(&pctx);
 	pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
-					      "imagic inode map",
+					      _("imagic inode map"),
 					      &ctx->inode_imagic_map);
 	if (pctx.errcode) {
 		pctx.num = 5;
@@ -743,7 +743,7 @@ static _INLINE_ void mark_block_used(e2fsck_t ctx, blk_t block)
 	if (ext2fs_fast_test_block_bitmap(ctx->block_found_map, block)) {
 		if (!ctx->block_dup_map) {
 			pctx.errcode = ext2fs_allocate_block_bitmap(ctx->fs,
-			      "multiply claimed block map",
+			      _("multiply claimed block map"),
 			      &ctx->block_dup_map);
 			if (pctx.errcode) {
 				pctx.num = 3;
@@ -1270,15 +1270,15 @@ static void handle_fs_bad_blocks(e2fsck_t ctx)
 
 	for (i = 0; i < fs->group_desc_count; i++) {
 		if (ctx->invalid_block_bitmap_flag[i]) {
-			new_table_block(ctx, first_block, i, "block bitmap", 
+			new_table_block(ctx, first_block, i, _("block bitmap"),
 					1, &fs->group_desc[i].bg_block_bitmap);
 		}
 		if (ctx->invalid_inode_bitmap_flag[i]) {
-			new_table_block(ctx, first_block, i, "inode bitmap", 
+			new_table_block(ctx, first_block, i, _("inode bitmap"),
 					1, &fs->group_desc[i].bg_inode_bitmap);
 		}
 		if (ctx->invalid_inode_table_flag[i]) {
-			new_table_block(ctx, first_block, i, "inode table",
+			new_table_block(ctx, first_block, i, _("inode table"),
 					fs->inode_blocks_per_group, 
 					&fs->group_desc[i].bg_inode_table);
 			ctx->flags |= E2F_FLAG_RESTART;
diff --git a/e2fsck/pass1b.c b/e2fsck/pass1b.c
index 957a9eeb..03e3b726 100644
--- a/e2fsck/pass1b.c
+++ b/e2fsck/pass1b.c
@@ -115,7 +115,7 @@ void e2fsck_pass1_dupblocks(e2fsck_t ctx, char *block_buf)
 	clear_problem_context(&pctx);
 	
 	pctx.errcode = ext2fs_allocate_inode_bitmap(fs,
-		      "multiply claimed inode map", &inode_dup_map);
+		      _("multiply claimed inode map"), &inode_dup_map);
 	if (pctx.errcode) {
 		fix_problem(ctx, PR_1B_ALLOCATE_IBITMAP_ERROR, &pctx);
 		ctx->flags |= E2F_FLAG_ABORT;
@@ -212,7 +212,7 @@ static void pass1b(e2fsck_t ctx, char *block_buf)
 		}
 		if (retval)
 			com_err(ctx->program_name, retval,
-				"while calling ext2fs_block_iterate in pass1b");
+			    _("while calling ext2fs_block_iterate in pass1b"));
 		
 	next:
 		pctx.errcode = ext2fs_get_next_inode(scan, &ino, &inode);
@@ -506,7 +506,7 @@ static int delete_file_block(ext2_filsys fs,
 							   *block_nr);
 		} else
 			com_err("delete_file_block", 0,
-				"internal error; can't find dup_blk for %d\n",
+			    _("internal error; can't find dup_blk for %d\n"),
 				*block_nr);
 	} else {
 		ext2fs_unmark_block_bitmap(ctx->block_found_map, *block_nr);
@@ -531,7 +531,7 @@ static void delete_file(e2fsck_t ctx, struct dup_inode *dp, char* block_buf)
 				      delete_file_block, &pb);
 	if (retval)
 		com_err("delete_file", retval,
-			"while calling ext2fs_block_iterate for inode %d",
+			_("while calling ext2fs_block_iterate for inode %d"),
 			dp->ino);
 	ext2fs_unmark_inode_bitmap(ctx->inode_used_map, dp->ino);
 	ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, dp->ino);
@@ -613,7 +613,7 @@ static int clone_file_block(ext2_filsys fs,
 			return BLOCK_CHANGED;
 		} else
 			com_err("clone_file_block", 0,
-				"internal error; can't find dup_blk for %d\n",
+			    _("internal error; can't find dup_blk for %d\n"),
 				*block_nr);
 	}
 	return 0;
@@ -641,13 +641,13 @@ static int clone_file(e2fsck_t ctx, struct dup_inode *dp, char* block_buf)
 	ext2fs_free_mem((void **) &cs.buf);
 	if (retval) {
 		com_err("clone_file", retval,
-			"while calling ext2fs_block_iterate for inode %d",
+			_("while calling ext2fs_block_iterate for inode %d"),
 			dp->ino);
 		return retval;
 	}
 	if (cs.errcode) {
 		com_err("clone_file", cs.errcode,
-			"returned from clone_file_block");
+			_("returned from clone_file_block"));
 		return retval;
 	}
 	return 0;
diff --git a/e2fsck/pass3.c b/e2fsck/pass3.c
index 949e4889..2202d17b 100644
--- a/e2fsck/pass3.c
+++ b/e2fsck/pass3.c
@@ -83,14 +83,14 @@ void e2fsck_pass3(e2fsck_t ctx)
 	 * Allocate some bitmaps to do loop detection.
 	 */
 	pctx.errcode = ext2fs_allocate_inode_bitmap(fs,
-		    "inode loop detection bitmap", &inode_loop_detect);
+		    _("inode loop detection bitmap"), &inode_loop_detect);
 	if (pctx.errcode) {
 		pctx.num = 1;
 		fix_problem(ctx, PR_3_ALLOCATE_IBITMAP_ERROR, &pctx);
 		ctx->flags |= E2F_FLAG_ABORT;
 		goto abort_exit;
 	}
-	pctx.errcode = ext2fs_allocate_inode_bitmap(fs, "inode done bitmap",
+	pctx.errcode = ext2fs_allocate_inode_bitmap(fs, _("inode done bitmap"),
 						    &inode_done_map);
 	if (pctx.errcode) {
 		pctx.num = 2;
@@ -101,7 +101,7 @@ void e2fsck_pass3(e2fsck_t ctx)
 #ifdef RESOURCE_TRACK
 	if (ctx->options & E2F_OPT_TIME) {
 		e2fsck_clear_progbar(ctx);
-		print_resource_track("Peak memory", &ctx->global_rtrack);
+		print_resource_track(_("Peak memory"), &ctx->global_rtrack);
 	}
 #endif
 
@@ -141,7 +141,7 @@ abort_exit:
 #ifdef RESOURCE_TRACK
 	if (ctx->options & E2F_OPT_TIME2) {
 		e2fsck_clear_progbar(ctx);
-		print_resource_track("Pass 3", &rtrack);
+		print_resource_track(_("Pass 3"), &rtrack);
 	}
 #endif
 }
@@ -556,8 +556,8 @@ static errcode_t adjust_inode_count(e2fsck_t ctx, ino_t ino, int adj)
 		inode.i_links_count--;
 	} else {
 		/* Should never happen */
-		printf("Debug error in e2fsck adjust_inode_count, "
-		       "should never happen.\n");
+		printf(_("Debug error in e2fsck adjust_inode_count, "
+		       "should never happen.\n"));
 		exit(1);
 	}
 	
diff --git a/e2fsck/pass4.c b/e2fsck/pass4.c
index ebc6fc48..8f70f058 100644
--- a/e2fsck/pass4.c
+++ b/e2fsck/pass4.c
@@ -160,7 +160,7 @@ void e2fsck_pass4(e2fsck_t ctx)
 #ifdef RESOURCE_TRACK
 	if (ctx->options & E2F_OPT_TIME2) {
 		e2fsck_clear_progbar(ctx);
-		print_resource_track("Pass 4", &rtrack);
+		print_resource_track(_("Pass 4"), &rtrack);
 	}
 #endif
 }
diff --git a/e2fsck/pass5.c b/e2fsck/pass5.c
index b39b3134..d074d002 100644
--- a/e2fsck/pass5.c
+++ b/e2fsck/pass5.c
@@ -67,7 +67,7 @@ void e2fsck_pass5(e2fsck_t ctx)
 #ifdef RESOURCE_TRACK
 	if (ctx->options & E2F_OPT_TIME2) {
 		e2fsck_clear_progbar(ctx);
-		print_resource_track("Pass 5", &rtrack);
+		print_resource_track(_("Pass 5"), &rtrack);
 	}
 #endif
 }
diff --git a/e2fsck/problem.c b/e2fsck/problem.c
index 1a663cfe..96509d8d 100644
--- a/e2fsck/problem.c
+++ b/e2fsck/problem.c
@@ -44,24 +44,24 @@
  * to fix a problem.
  */
 static const char *prompt[] = {
-	"(no prompt)",		/* 0 */
-	"Fix",			/* 1 */
-	"Clear",		/* 2 */
-	"Relocate",		/* 3 */
-	"Allocate",		/* 4 */
-	"Expand",		/* 5 */
-	"Connect to /lost+found", /* 6 */
-	"Create",		/* 7 */	
-	"Salvage",		/* 8 */
-	"Truncate",		/* 9 */
-	"Clear inode",		/* 10 */
-	"Abort",		/* 11 */
-	"Split",		/* 12 */
-	"Continue",		/* 13 */
-	"Clone duplicate/bad blocks", /* 14 */
-	"Delete file",		/* 15 */
-	"Suppress messages",	/* 16 */
-	"Unlink",		/* 17 */
+	N_("(no prompt)"),	/* 0 */
+	N_("Fix"),		/* 1 */
+	N_("Clear"),		/* 2 */
+	N_("Relocate"),		/* 3 */
+	N_("Allocate"),		/* 4 */
+	N_("Expand"),		/* 5 */
+	N_("Connect to /lost+found"), /* 6 */
+	N_("Create"),		/* 7 */	
+	N_("Salvage"),		/* 8 */
+	N_("Truncate"),		/* 9 */
+	N_("Clear inode"),	/* 10 */
+	N_("Abort"),		/* 11 */
+	N_("Split"),		/* 12 */
+	N_("Continue"),		/* 13 */
+	N_("Clone duplicate/bad blocks"), /* 14 */
+	N_("Delete file"),	/* 15 */
+	N_("Suppress messages"),/* 16 */
+	N_("Unlink"),		/* 17 */
 };
 
 /*
@@ -69,24 +69,24 @@ static const char *prompt[] = {
  * automatically fixing the problem.
  */
 static const char *preen_msg[] = {
-	"(NONE)",		/* 0 */
-	"FIXED",		/* 1 */
-	"CLEARED",		/* 2 */
-	"RELOCATED",		/* 3 */
-	"ALLOCATED",		/* 4 */
-	"EXPANDED",		/* 5 */
-	"RECONNECTED",		/* 6 */
-	"CREATED",		/* 7 */
-	"SALVAGED",		/* 8 */
-	"TRUNCATED",		/* 9 */
-	"INODE CLEARED",	/* 10 */
-	"ABORTED",		/* 11 */
-	"SPLIT",		/* 12 */
-	"CONTINUING",		/* 13 */
-	"DUPLICATE/BAD BLOCKS CLONED", /* 14 */
-	"FILE DELETED",		/* 15 */
-	"SUPPRESSED",		/* 16 */
-	"UNLINKED",		/* 17 */
+	N_("(NONE)"),		/* 0 */
+	N_("FIXED"),		/* 1 */
+	N_("CLEARED"),		/* 2 */
+	N_("RELOCATED"),	/* 3 */
+	N_("ALLOCATED"),	/* 4 */
+	N_("EXPANDED"),		/* 5 */
+	N_("RECONNECTED"),	/* 6 */
+	N_("CREATED"),		/* 7 */
+	N_("SALVAGED"),		/* 8 */
+	N_("TRUNCATED"),	/* 9 */
+	N_("INODE CLEARED"),	/* 10 */
+	N_("ABORTED"),		/* 11 */
+	N_("SPLIT"),		/* 12 */
+	N_("CONTINUING"),	/* 13 */
+	N_("DUPLICATE/BAD BLOCKS CLONED"), /* 14 */
+	N_("FILE DELETED"),	/* 15 */
+	N_("SUPPRESSED"),	/* 16 */
+	N_("UNLINKED"),		/* 17 */
 };
 
 static const struct e2fsck_problem problem_table[] = {
@@ -94,269 +94,269 @@ static const struct e2fsck_problem problem_table[] = {
 	/* Pre-Pass 1 errors */
 
 	/* Block bitmap not in group */
-	{ PR_0_BB_NOT_GROUP, "@b @B for @g %g is not in @g.  (@b %b)\n",
+	{ PR_0_BB_NOT_GROUP, N_("@b @B for @g %g is not in @g.  (@b %b)\n"),
 	  PROMPT_RELOCATE, PR_LATCH_RELOC }, 
 
 	/* Inode bitmap not in group */
-	{ PR_0_IB_NOT_GROUP, "@i @B for @g %g is not in @g.  (@b %b)\n",
+	{ PR_0_IB_NOT_GROUP, N_("@i @B for @g %g is not in @g.  (@b %b)\n"),
 	  PROMPT_RELOCATE, PR_LATCH_RELOC }, 
 
 	/* Inode table not in group */
 	{ PR_0_ITABLE_NOT_GROUP,
-	  "@i table for @g %g is not in @g.  (@b %b)\n"
-	  "WARNING: SEVERE DATA LOSS POSSIBLE.\n",
+	  N_("@i table for @g %g is not in @g.  (@b %b)\n"
+	  "WARNING: SEVERE DATA LOSS POSSIBLE.\n"),
 	  PROMPT_RELOCATE, PR_LATCH_RELOC },
 
 	/* Superblock corrupt */
 	{ PR_0_SB_CORRUPT,
-	  "\nThe @S could not be read or does not describe a correct ext2\n"
+	  N_("\nThe @S could not be read or does not describe a correct ext2\n"
 	  "@f.  If the device is valid and it really contains an ext2\n"
 	  "@f (and not swap or ufs or something else), then the @S\n"
   "is corrupt, and you might try running e2fsck with an alternate @S:\n"
-	  "    e2fsck -b %S <device>\n\n",
+	  "    e2fsck -b %S <device>\n\n"),
 	  PROMPT_NONE, PR_FATAL },
 
 	/* Filesystem size is wrong */
 	{ PR_0_FS_SIZE_WRONG,
-	  "The @f size (according to the @S) is %b @bs\n"
+	  N_("The @f size (according to the @S) is %b @bs\n"
 	  "The physical size of the device is %c @bs\n"
-	  "Either the @S or the partition table is likely to be corrupt!\n",
+	  "Either the @S or the partition table is likely to be corrupt!\n"),
 	  PROMPT_ABORT, 0 },
 
 	/* Fragments not supported */		  
 	{ PR_0_NO_FRAGMENTS,
-	  "@S @b_size = %b, fragsize = %c.\n"
+	  N_("@S @b_size = %b, fragsize = %c.\n"
 	  "This version of e2fsck does not support fragment sizes different\n"
-	  "from the @b size.\n",
+	  "from the @b size.\n"),
 	  PROMPT_NONE, PR_FATAL },
 
 	  /* Bad blocks_per_group */
 	{ PR_0_BLOCKS_PER_GROUP,
-	  "@S @bs_per_group = %b, should have been %c\n",
+	  N_("@S @bs_per_group = %b, should have been %c\n"),
 	  PROMPT_NONE, PR_AFTER_CODE, PR_0_SB_CORRUPT },
 
 	/* Bad first_data_block */
 	{ PR_0_FIRST_DATA_BLOCK,
-	  "@S first_data_@b = %b, should have been %c\n",
+	  N_("@S first_data_@b = %b, should have been %c\n"),
 	  PROMPT_NONE, PR_AFTER_CODE, PR_0_SB_CORRUPT },
 	
 	/* Adding UUID to filesystem */
 	{ PR_0_ADD_UUID,
-	  "@f did not have a UUID; generating one.\n\n",
+	  N_("@f did not have a UUID; generating one.\n\n"),
 	  PROMPT_NONE, 0 },
 
 	/* Relocate hint */
 	{ PR_0_RELOCATE_HINT,
-	  "Note: if there is several inode or block bitmap blocks\n"
+	  N_("Note: if there is several inode or block bitmap blocks\n"
 	  "which require relocation, or one part of the inode table\n"
 	  "which must be moved, you may wish to try running e2fsck\n"
 	  "with the '-b %S' option first.  The problem may lie only\n"
 	  "with the primary block group descriptor, and the backup\n"
-	  "block group descriptor may be OK.\n\n",
+	  "block group descriptor may be OK.\n\n"),
 	  PROMPT_NONE, PR_PREEN_OK | PR_NOCOLLATE },
 
 	/* Miscellaneous superblock corruption */
 	{ PR_0_MISC_CORRUPT_SUPER,
-	  "Corruption found in @S.  (%s = %N).\n",	  
+	  N_("Corruption found in @S.  (%s = %N).\n"),
 	  PROMPT_NONE, PR_AFTER_CODE, PR_0_SB_CORRUPT },
 
 	/* Error determing physical device size of filesystem */
 	{ PR_0_GETSIZE_ERROR,	  
-	  "Error determining size of the physical device: %m\n",
+	  N_("Error determining size of the physical device: %m\n"),
 	  PROMPT_NONE, PR_FATAL },
 
 	/* Inode count in superblock is incorrect */
 	{ PR_0_INODE_COUNT_WRONG,
-	  "@i count in @S is %i, should be %j\n",
+	  N_("@i count in @S is %i, should be %j\n"),
 	  PROMPT_FIX, 0 },
 		  
 	/* Pass 1 errors */
 	
 	/* Pass 1: Checking inodes, blocks, and sizes */
 	{ PR_1_PASS_HEADER,
-	  "Pass 1: Checking @is, @bs, and sizes\n",
+	  N_("Pass 1: Checking @is, @bs, and sizes\n"),
 	  PROMPT_NONE, 0 },
 		  
 	/* Root directory is not an inode */
-	{ PR_1_ROOT_NO_DIR, "@r is not a @d.  ",
+	{ PR_1_ROOT_NO_DIR, N_("@r is not a @d.  "),
 	  PROMPT_CLEAR, 0 }, 
 
 	/* Root directory has dtime set */
 	{ PR_1_ROOT_DTIME,
-	  "@r has dtime set (probably due to old mke2fs).  ",
+	  N_("@r has dtime set (probably due to old mke2fs).  "),
 	  PROMPT_FIX, PR_PREEN_OK },
 
 	/* Reserved inode has bad mode */
 	{ PR_1_RESERVED_BAD_MODE,
-	  "Reserved @i %i has bad mode.  ",
+	  N_("Reserved @i %i has bad mode.  "),
 	  PROMPT_CLEAR, PR_PREEN_OK },
 
 	/* Deleted inode has zero dtime */
 	{ PR_1_ZERO_DTIME,
-	  "@D @i %i has zero dtime.  ",
+	  N_("@D @i %i has zero dtime.  "),
 	  PROMPT_FIX, PR_PREEN_OK },
 
 	/* Inode in use, but dtime set */
 	{ PR_1_SET_DTIME,
-	  "@i %i is in use, but has dtime set.  ",
+	  N_("@i %i is in use, but has dtime set.  "),
 	  PROMPT_FIX, PR_PREEN_OK },
 
 	/* Zero-length directory */
 	{ PR_1_ZERO_LENGTH_DIR,
-	  "@i %i is a @z @d.  ",
+	  N_("@i %i is a @z @d.  "),
 	  PROMPT_CLEAR, PR_PREEN_OK },
 
 	/* Block bitmap conflicts with some other fs block */
 	{ PR_1_BB_CONFLICT,
-	  "@g %g's @b @B at %b @C.\n",
+	  N_("@g %g's @b @B at %b @C.\n"),
 	  PROMPT_RELOCATE, 0 },
 
 	/* Inode bitmap conflicts with some other fs block */
 	{ PR_1_IB_CONFLICT,
-	  "@g %g's @i @B at %b @C.\n",
+	  N_("@g %g's @i @B at %b @C.\n"),
 	  PROMPT_RELOCATE, 0 },
 
 	/* Inode table conflicts with some other fs block */
 	{ PR_1_ITABLE_CONFLICT,
-	  "@g %g's @i table at %b @C.\n",
+	  N_("@g %g's @i table at %b @C.\n"),
 	  PROMPT_RELOCATE, 0 },
 
 	/* Block bitmap is on a bad block */
 	{ PR_1_BB_BAD_BLOCK,
-	  "@g %g's @b @B (%b) is bad.  ",
+	  N_("@g %g's @b @B (%b) is bad.  "),
 	  PROMPT_RELOCATE, 0 },
 
 	/* Inode bitmap is on a bad block */
 	{ PR_1_IB_BAD_BLOCK,
-	  "@g %g's @i @B (%b) is bad.  ",
+	  N_("@g %g's @i @B (%b) is bad.  "),
 	  PROMPT_RELOCATE, 0 },
 
 	/* Inode has incorrect i_size */
 	{ PR_1_BAD_I_SIZE,
-	  "@i %i, i_size is %Is, @s %N.  ",
+	  N_("@i %i, i_size is %Is, @s %N.  "),
 	  PROMPT_FIX, PR_PREEN_OK },
 		  
 	/* Inode has incorrect i_blocks */
 	{ PR_1_BAD_I_BLOCKS,
-	  "@i %i, i_@bs is %Ib, @s %N.  ",
+	  N_("@i %i, i_@bs is %Ib, @s %N.  "),
 	  PROMPT_FIX, PR_PREEN_OK },
 
 	/* Illegal block number in inode */
 	{ PR_1_ILLEGAL_BLOCK_NUM,
-	  "@I @b #%B (%b) in @i %i.  ",
+	  N_("@I @b #%B (%b) in @i %i.  "),
 	  PROMPT_CLEAR, PR_LATCH_BLOCK },
 
 	/* Block number overlaps fs metadata */
 	{ PR_1_BLOCK_OVERLAPS_METADATA,
-	  "@b #%B (%b) overlaps @f metadata in @i %i.  ",
+	  N_("@b #%B (%b) overlaps @f metadata in @i %i.  "),
 	  PROMPT_CLEAR, PR_LATCH_BLOCK },
 
 	/* Inode has illegal blocks (latch question) */
 	{ PR_1_INODE_BLOCK_LATCH,
-	  "@i %i has illegal @b(s).  ",
+	  N_("@i %i has illegal @b(s).  "),
 	  PROMPT_CLEAR, 0 },
 
 	/* Too many bad blocks in inode */
 	{ PR_1_TOO_MANY_BAD_BLOCKS,
-	  "Too many illegal @bs in @i %i.\n",
+	  N_("Too many illegal @bs in @i %i.\n"),
 	  PROMPT_CLEAR_INODE, PR_NO_OK }, 	
 
 	/* Illegal block number in bad block inode */
 	{ PR_1_BB_ILLEGAL_BLOCK_NUM,
-	  "@I @b #%B (%b) in bad @b @i.  ",
+	  N_("@I @b #%B (%b) in bad @b @i.  "),
 	  PROMPT_CLEAR, PR_LATCH_BBLOCK },
 
 	/* Bad block inode has illegal blocks (latch question) */
 	{ PR_1_INODE_BBLOCK_LATCH,
-	  "Bad @b @i has illegal @b(s).  ",
+	  N_("Bad @b @i has illegal @b(s).  "),
 	  PROMPT_CLEAR, 0 },
 
 	/* Duplicate or bad blocks in use! */
 	{ PR_1_DUP_BLOCKS_PREENSTOP,
-	  "Duplicate or bad @b in use!\n",
+	  N_("Duplicate or bad @b in use!\n"),
 	  PROMPT_NONE, 0 },
 
 	/* Bad block used as bad block indirect block */	  
 	{ PR_1_BBINODE_BAD_METABLOCK,
-	  "Bad @b %b used as bad @b indirect @b?!?\n",
+	  N_("Bad @b %b used as bad @b indirect @b?!?\n"),
 	  PROMPT_NONE, PR_AFTER_CODE, PR_1_BBINODE_BAD_METABLOCK_PROMPT },
 
 	/* Inconsistency can't be fixed prompt */	  
 	{ PR_1_BBINODE_BAD_METABLOCK_PROMPT,
-	  "\nThis inconsistency can not be fixed with e2fsck; to fix it, use\n"
+	  N_("\nThis inconsistency can not be fixed with e2fsck; to fix it, use\n"
 	  """dumpe2fs -b"" to dump out the bad @b "
 	  "list and ""e2fsck -L filename""\n"
-	  "to read it back in again.\n",
+	  "to read it back in again.\n"),
 	  PROMPT_CONTINUE, PR_PREEN_NOMSG },
 
 	/* Bad primary block */
 	{ PR_1_BAD_PRIMARY_BLOCK,  
-	  "\nIf the @b is really bad, the @f can not be fixed.\n",
+	  N_("\nIf the @b is really bad, the @f can not be fixed.\n"),
 	  PROMPT_NONE, PR_AFTER_CODE, PR_1_BAD_PRIMARY_BLOCK_PROMPT },
 		  
 	/* Bad primary block prompt */
 	{ PR_1_BAD_PRIMARY_BLOCK_PROMPT,	  
-	  "You can clear the this @b (and hope for the best) from the\n"
+	  N_("You can clear the this @b (and hope for the best) from the\n"
 	  "bad @b list and hope that @b is really OK, but there are no\n"
-	  "guarantees.\n\n",
+	  "guarantees.\n\n"),
 	  PROMPT_CLEAR, PR_PREEN_NOMSG },
 
 	/* Bad primary superblock */
 	{ PR_1_BAD_PRIMARY_SUPERBLOCK,
-	  "The primary @S (%b) is on the bad @b list.\n",
+	  N_("The primary @S (%b) is on the bad @b list.\n"),
 	  PROMPT_NONE, PR_AFTER_CODE, PR_1_BAD_PRIMARY_BLOCK },
 		  
 	/* Bad primary block group descriptors */
 	{ PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR,
-	  "Block %b in the primary @g descriptors "
-	  "is on the bad @b list\n",
+	  N_("Block %b in the primary @g descriptors "
+	  "is on the bad @b list\n"),
 	  PROMPT_NONE, PR_AFTER_CODE, PR_1_BAD_PRIMARY_BLOCK },
 		  
 	/* Bad superblock in group */
 	{ PR_1_BAD_SUPERBLOCK,
-	  "Warning: Group %g's @S (%b) is bad.\n",
+	  N_("Warning: Group %g's @S (%b) is bad.\n"),
 	  PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG },
 		  
 	/* Bad block group descriptors in group */
 	{ PR_1_BAD_GROUP_DESCRIPTORS,
-	  "Warning: Group %g's copy of the @g descriptors has a bad "
-	  "@b (%b).\n",
+	  N_("Warning: Group %g's copy of the @g descriptors has a bad "
+	  "@b (%b).\n"),
 	  PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG },
 
 	/* Block claimed for no reason */	  
 	{ PR_1_PROGERR_CLAIMED_BLOCK,
-	  "Programming error?  @b #%b claimed for no reason in "
-	  "process_bad_@b.\n",
+	  N_("Programming error?  @b #%b claimed for no reason in "
+	  "process_bad_@b.\n"),
 	  PROMPT_NONE, PR_PREEN_OK },
 
 	/* Error allocating blocks for relocating metadata */
 	{ PR_1_RELOC_BLOCK_ALLOCATE,
-	  "@A %N @b(s) for %s: %m\n",
+	  N_("@A %N @b(s) for %s: %m\n"),
 	  PROMPT_NONE, PR_PREEN_OK },
 		
 	/* Error allocating block buffer during relocation process */
 	{ PR_1_RELOC_MEMORY_ALLOCATE,
-	  "@A @b buffer for relocating %s\n",
+	  N_("@A @b buffer for relocating %s\n"),
 	  PROMPT_NONE, PR_PREEN_OK },
 		
 	/* Relocating metadata group information from X to Y */	
 	{ PR_1_RELOC_FROM_TO,
-	  "Relocating @g %g's %s from %b to %c...\n",
+	  N_("Relocating @g %g's %s from %b to %c...\n"),
 	  PROMPT_NONE, PR_PREEN_OK },
 		
 	/* Relocating metatdata group information to X */
 	{ PR_1_RELOC_TO,
-	  "Relocating @g %g's %s to %c...\n",
+	  N_("Relocating @g %g's %s to %c...\n"),
 	  PROMPT_NONE, PR_PREEN_OK },
 		
 	/* Block read error during relocation process */
 	{ PR_1_RELOC_READ_ERR,
-	  "Warning: could not read @b %b of %s: %m\n",
+	  N_("Warning: could not read @b %b of %s: %m\n"),
 	  PROMPT_NONE, PR_PREEN_OK },
 		
 	/* Block write error during relocation process */
 	{ PR_1_RELOC_WRITE_ERR,
-	  "Warning: could not write @b %b for %s: %m\n",
+	  N_("Warning: could not write @b %b for %s: %m\n"),
 	  PROMPT_NONE, PR_PREEN_OK },
 
 	/* Error allocating inode bitmap */
@@ -371,38 +371,38 @@ static const struct e2fsck_problem problem_table[] = {
 
 	/* Error allocating icount structure */
 	{ PR_1_ALLOCATE_ICOUNT,
-	  "@A icount link information: %m\n",
+	  N_("@A icount link information: %m\n"),
 	  PROMPT_NONE, PR_FATAL },
 
 	/* Error allocating dbcount */
 	{ PR_1_ALLOCATE_DBCOUNT,
-	  "@A @d @b array: %m\n",
+	  N_("@A @d @b array: %m\n"),
 	  PROMPT_NONE, PR_FATAL },
 
 	/* Error while scanning inodes */
 	{ PR_1_ISCAN_ERROR,
-	  "Error while scanning @is (%i): %m\n",
+	  N_("Error while scanning @is (%i): %m\n"),
 	  PROMPT_NONE, PR_FATAL },
 
 	/* Error while iterating over blocks */
 	{ PR_1_BLOCK_ITERATE,
-	  "Error while iterating over blocks in @i %i: %m\n",
+	  N_("Error while iterating over blocks in @i %i: %m\n"),
 	  PROMPT_NONE, PR_FATAL },
 
 	/* Error while storing inode count information */	  
 	{ PR_1_ICOUNT_STORE,
-	  "Error storing @i count information (inode=%i, count=%N): %m\n",
+	  N_("Error storing @i count information (inode=%i, count=%N): %m\n"),
 	  PROMPT_NONE, PR_FATAL },
 
 	/* Error while storing directory block information */	  
 	{ PR_1_ADD_DBLOCK,
-	  "Error storing @d @b information "
-	  "(inode=%i, block=%b, num=%N): %m\n",
+	  N_("Error storing @d @b information "
+	  "(inode=%i, block=%b, num=%N): %m\n"),
 	  PROMPT_NONE, PR_FATAL },
 
 	/* Error while reading inode (for clearing) */	  
 	{ PR_1_READ_INODE,
-	  "Error reading @i %i: %m\n",
+	  N_("Error reading @i %i: %m\n"),
 	  PROMPT_NONE, PR_FATAL },
 
 	/* Suppress messages prompt */
@@ -410,30 +410,30 @@ static const struct e2fsck_problem problem_table[] = {
 		  
 	/* Filesystem contains large files, but has no such flag in sb */
 	{ PR_1_FEATURE_LARGE_FILES,
-	  "@f contains large files, but lacks LARGE_FILE flag in @S.\n",
+	  N_("@f contains large files, but lacks LARGE_FILE flag in @S.\n"),
 	  PROMPT_FIX, 0 },
 	  
 	/* Imagic flag set on an inode when filesystem doesn't support it */
 	{ PR_1_SET_IMAGIC,
-	  "@i %i has imagic flag set.  ",
+	  N_("@i %i has imagic flag set.  "),
 	  PROMPT_CLEAR, 0 },
 
 	/* Immutable flag set on a device or socket inode */
 	{ PR_1_SET_IMMUTABLE,
-	  "Special (device/socket/fifo) @i %i has immutable flag set.  ",
+	  N_("Special (device/socket/fifo) @i %i has immutable flag set.  "),
 	  PROMPT_CLEAR, PR_PREEN_OK | PR_PREEN_NO | PR_NO_OK },
 
 	/* Pass 1b errors */
 
 	/* Pass 1B: Rescan for duplicate/bad blocks */
 	{ PR_1B_PASS_HEADER,
-	  "Duplicate @bs found... invoking duplicate @b passes.\n"
-	  "Pass 1B: Rescan for duplicate/bad @bs\n",
+	  N_("Duplicate @bs found... invoking duplicate @b passes.\n"
+	  "Pass 1B: Rescan for duplicate/bad @bs\n"),
 	  PROMPT_NONE, 0 },
 
 	/* Duplicate/bad block(s) header */
 	{ PR_1B_DUP_BLOCK_HEADER,	  
-	  "Duplicate/bad @b(s) in @i %i:",
+	  N_("Duplicate/bad @b(s) in @i %i:"),
 	  PROMPT_NONE, 0 },
 
 	/* Duplicate/bad block(s) in inode */
@@ -448,50 +448,50 @@ static const struct e2fsck_problem problem_table[] = {
 		  
 	/* Error while scanning inodes */
 	{ PR_1B_ISCAN_ERROR,
-	  "Error while scanning inodes (%i): %m\n",
+	  N_("Error while scanning inodes (%i): %m\n"),
 	  PROMPT_NONE, PR_FATAL },
 
 	/* Error allocating inode bitmap */
 	{ PR_1B_ALLOCATE_IBITMAP_ERROR,
-	  "@A @i @B (inode_dup_map): %m\n",
+	  N_("@A @i @B (inode_dup_map): %m\n"),
 	  PROMPT_NONE, PR_FATAL },
 
 
 	/* Pass 1C: Scan directories for inodes with dup blocks. */
 	{ PR_1C_PASS_HEADER,
-	  "Pass 1C: Scan directories for @is with dup @bs.\n",
+	  N_("Pass 1C: Scan directories for @is with dup @bs.\n"),
 	  PROMPT_NONE, 0 },
 
 		  
 	/* Pass 1D: Reconciling duplicate blocks */
 	{ PR_1D_PASS_HEADER,
-	  "Pass 1D: Reconciling duplicate @bs\n",
+	  N_("Pass 1D: Reconciling duplicate @bs\n"),
 	  PROMPT_NONE, 0 },
 		  
 	/* File has duplicate blocks */
 	{ PR_1D_DUP_FILE,
-	  "File %Q (@i #%i, mod time %IM) \n"
-	  "  has %B duplicate @b(s), shared with %N file(s):\n",
+	  N_("File %Q (@i #%i, mod time %IM) \n"
+	  "  has %B duplicate @b(s), shared with %N file(s):\n"),
 	  PROMPT_NONE, 0 },
 		  
 	/* List of files sharing duplicate blocks */	
 	{ PR_1D_DUP_FILE_LIST,
-	  "\t%Q (@i #%i, mod time %IM)\n",
+	  N_("\t%Q (@i #%i, mod time %IM)\n"),
 	  PROMPT_NONE, 0 },
 	  
 	/* File sharing blocks with filesystem metadata  */	
 	{ PR_1D_SHARE_METADATA,
-	  "\t<@f metadata>\n",
+	  N_("\t<@f metadata>\n"),
 	  PROMPT_NONE, 0 },
 
 	/* Report of how many duplicate/bad inodes */	
 	{ PR_1D_NUM_DUP_INODES,
-	  "(There are %N @is containing duplicate/bad @bs.)\n\n",
+	  N_("(There are %N @is containing duplicate/bad @bs.)\n\n"),
 	  PROMPT_NONE, 0 },
 
 	/* Duplicated blocks already reassigned or cloned. */
 	{ PR_1D_DUP_BLOCKS_DEALT,
-	  "Duplicated @bs already reassigned or cloned.\n\n",
+	  N_("Duplicated @bs already reassigned or cloned.\n\n"),
 	  PROMPT_NONE, 0 },
 
 	/* Clone duplicate/bad blocks? */
@@ -504,352 +504,352 @@ static const struct e2fsck_problem problem_table[] = {
 
 	/* Couldn't clone file (error) */
 	{ PR_1D_CLONE_ERROR,
-	  "Couldn't clone file: %m\n", PROMPT_NONE, 0 },
+	  N_("Couldn't clone file: %m\n"), PROMPT_NONE, 0 },
 
 	/* Pass 2 errors */
 
 	/* Pass 2: Checking directory structure */
 	{ PR_2_PASS_HEADER,
-	  "Pass 2: Checking @d structure\n",
+	  N_("Pass 2: Checking @d structure\n"),
 	  PROMPT_NONE, 0 },
 		  
 	/* Bad inode number for '.' */
 	{ PR_2_BAD_INODE_DOT,
-	  "Bad @i number for '.' in @d @i %i.\n",
+	  N_("Bad @i number for '.' in @d @i %i.\n"),
 	  PROMPT_FIX, 0 },
 
 	/* Directory entry has bad inode number */
 	{ PR_2_BAD_INO, 
-	  "@E has bad @i #: %Di.\n",
+	  N_("@E has bad @i #: %Di.\n"),
 	  PROMPT_CLEAR, 0 },
 
 	/* Directory entry has deleted or unused inode */
 	{ PR_2_UNUSED_INODE, 
-	  "@E has @D/unused @i %Di.  ",
+	  N_("@E has @D/unused @i %Di.  "),
 	  PROMPT_CLEAR, PR_PREEN_OK },
 
 	/* Directry entry is link to '.' */
 	{ PR_2_LINK_DOT, 
-	  "@E @L to '.'  ",
+	  N_("@E @L to '.'  "),
 	  PROMPT_CLEAR, 0 },
 
 	/* Directory entry points to inode now located in a bad block */
 	{ PR_2_BB_INODE,
-	  "@E points to @i (%Di) located in a bad @b.\n",
+	  N_("@E points to @i (%Di) located in a bad @b.\n"),
 	  PROMPT_CLEAR, 0 },
 
 	/* Directory entry contains a link to a directory */
 	{ PR_2_LINK_DIR, 
-	  "@E @L to @d %P (%Di).\n",
+	  N_("@E @L to @d %P (%Di).\n"),
 	  PROMPT_CLEAR, 0 },
 
 	/* Directory entry contains a link to the root directry */
 	{ PR_2_LINK_ROOT, 
-	  "@E @L to the @r.\n",
+	  N_("@E @L to the @r.\n"),
 	  PROMPT_CLEAR, 0 },
 
 	/* Directory entry has illegal characters in its name */
 	{ PR_2_BAD_NAME, 
-	  "@E has illegal characters in its name.\n",
+	  N_("@E has illegal characters in its name.\n"),
 	  PROMPT_FIX, 0 },
 
 	/* Missing '.' in directory inode */	  
 	{ PR_2_MISSING_DOT,
-	  "Missing '.' in @d @i %i.\n",
+	  N_("Missing '.' in @d @i %i.\n"),
 	  PROMPT_FIX, 0 },
 
 	/* Missing '..' in directory inode */	  
 	{ PR_2_MISSING_DOT_DOT,
-	  "Missing '..' in @d @i %i.\n",
+	  N_("Missing '..' in @d @i %i.\n"),
 	  PROMPT_FIX, 0 },
 
 	/* First entry in directory inode doesn't contain '.' */
 	{ PR_2_1ST_NOT_DOT,
-	  "First @e '%Dn' (inode=%Di) in @d @i %i (%p) @s '.'\n",
+	  N_("First @e '%Dn' (inode=%Di) in @d @i %i (%p) @s '.'\n"),
 	  PROMPT_FIX, 0 },
 
 	/* Second entry in directory inode doesn't contain '..' */
 	{ PR_2_2ND_NOT_DOT_DOT,
-	  "Second @e '%Dn' (inode=%Di) in @d @i %i @s '..'\n",
+	  N_("Second @e '%Dn' (inode=%Di) in @d @i %i @s '..'\n"),
 	  PROMPT_FIX, 0 },
 		  
 	/* i_faddr should be zero */
 	{ PR_2_FADDR_ZERO,
-	  "i_faddr @F %IF, @s zero.\n",
+	  N_("i_faddr @F %IF, @s zero.\n"),
 	  PROMPT_CLEAR, 0 },
 
   	/* i_file_acl should be zero */
 	{ PR_2_FILE_ACL_ZERO,
-	  "i_file_acl @F %If, @s zero.\n",
+	  N_("i_file_acl @F %If, @s zero.\n"),
 	  PROMPT_CLEAR, 0 },
 
   	/* i_dir_acl should be zero */
 	{ PR_2_DIR_ACL_ZERO,
-	  "i_dir_acl @F %Id, @s zero.\n",
+	  N_("i_dir_acl @F %Id, @s zero.\n"),
 	  PROMPT_CLEAR, 0 },
 
   	/* i_frag should be zero */
 	{ PR_2_FRAG_ZERO,
-	  "i_frag @F %N, @s zero.\n",
+	  N_("i_frag @F %N, @s zero.\n"),
 	  PROMPT_CLEAR, 0 },
 
   	/* i_fsize should be zero */
 	{ PR_2_FSIZE_ZERO,
-	  "i_fsize @F %N, @s zero.\n",
+	  N_("i_fsize @F %N, @s zero.\n"),
 	  PROMPT_CLEAR, 0 },
 
 	/* inode has bad mode */
 	{ PR_2_BAD_MODE,
-	  "@i %i (%Q) has a bad mode (%Im).\n",
+	  N_("@i %i (%Q) has a bad mode (%Im).\n"),
 	  PROMPT_CLEAR, 0 },
 
 	/* directory corrupted */
 	{ PR_2_DIR_CORRUPTED,	  
-	  "@d @i %i, @b %B, offset %N: @d corrupted\n",
+	  N_("@d @i %i, @b %B, offset %N: @d corrupted\n"),
 	  PROMPT_SALVAGE, 0 },
 		  
 	/* filename too long */
 	{ PR_2_FILENAME_LONG,	  
-	  "@d @i %i, @b %B, offset %N: filename too long\n",
+	  N_("@d @i %i, @b %B, offset %N: filename too long\n"),
 	  PROMPT_TRUNCATE, 0 },
 
 	/* Directory inode has a missing block (hole) */
 	{ PR_2_DIRECTORY_HOLE,	  
-	  "@d @i %i has an unallocated @b #%B.  ",
+	  N_("@d @i %i has an unallocated @b #%B.  "),
 	  PROMPT_ALLOCATE, 0 },
 
 	/* '.' is not NULL terminated */
 	{ PR_2_DOT_NULL_TERM,
-	  "'.' @d @e in @d @i %i is not NULL terminated\n",
+	  N_("'.' @d @e in @d @i %i is not NULL terminated\n"),
 	  PROMPT_FIX, 0 },
 
 	/* '..' is not NULL terminated */
 	{ PR_2_DOT_DOT_NULL_TERM,
-	  "'..' @d @e in @d @i %i is not NULL terminated\n",
+	  N_("'..' @d @e in @d @i %i is not NULL terminated\n"),
 	  PROMPT_FIX, 0 },
 
 	/* Illegal character device inode */
 	{ PR_2_BAD_CHAR_DEV,
-	  "@i %i (%Q) is an @I character device.\n",
+	  N_("@i %i (%Q) is an @I character device.\n"),
 	  PROMPT_CLEAR, 0 },
 
 	/* Illegal block device inode */
 	{ PR_2_BAD_BLOCK_DEV,
-	  "@i %i (%Q) is an @I @b device.\n",
+	  N_("@i %i (%Q) is an @I @b device.\n"),
 	  PROMPT_CLEAR, 0 },
 
 	/* Duplicate '.' entry */
 	{ PR_2_DUP_DOT,
-	  "@E is duplicate '.' @e.\n",
+	  N_("@E is duplicate '.' @e.\n"),
 	  PROMPT_FIX, 0 },	  
 
 	/* Duplicate '..' entry */
 	{ PR_2_DUP_DOT_DOT,
-	  "@E is duplicate '..' @e.\n",
+	  N_("@E is duplicate '..' @e.\n"),
 	  PROMPT_FIX, 0 },
 
 	/* Internal error: couldn't find dir_info */
 	{ PR_2_NO_DIRINFO,
-	  "Internal error: couldn't find dir_info for %i.\n",
+	  N_("Internal error: couldn't find dir_info for %i.\n"),
 	  PROMPT_NONE, PR_FATAL },
 
 	/* Final rec_len is wrong */
 	{ PR_2_FINAL_RECLEN,
-	  "@E has rec_len of %dr, should be %N.\n",
+	  N_("@E has rec_len of %dr, should be %N.\n"),
 	  PROMPT_FIX, 0 },
 		  
 	/* Error allocating icount structure */
 	{ PR_2_ALLOCATE_ICOUNT,
-	  "@A icount structure: %m\n",
+	  N_("@A icount structure: %m\n"),
 	  PROMPT_NONE, PR_FATAL },
 
 	/* Error iterating over directory blocks */
 	{ PR_2_DBLIST_ITERATE,
-	  "Error interating over @d @bs: %m\n",
+	  N_("Error interating over @d @bs: %m\n"),
 	  PROMPT_NONE, PR_FATAL },
 
 	/* Error reading directory block */
 	{ PR_2_READ_DIRBLOCK,
-	  "Error reading @d @b %b (@i %i): %m\n",
+	  N_("Error reading @d @b %b (@i %i): %m\n"),
 	  PROMPT_CONTINUE, 0 },
 
 	/* Error writing directory block */
 	{ PR_2_WRITE_DIRBLOCK,
-	  "Error writing @d @b %b (@i %i): %m\n",
+	  N_("Error writing @d @b %b (@i %i): %m\n"),
 	  PROMPT_CONTINUE, 0 },
 
 	/* Error allocating new directory block */
 	{ PR_2_ALLOC_DIRBOCK,
-	  "@A new @d @b for @i %i (%s): %m\n",
+	  N_("@A new @d @b for @i %i (%s): %m\n"),
 	  PROMPT_NONE, 0 },
 
 	/* Error deallocating inode */
 	{ PR_2_DEALLOC_INODE,
-	  "Error deallocating @i %i: %m\n",
+	  N_("Error deallocating @i %i: %m\n"),
 	  PROMPT_NONE, PR_FATAL },
 
 	/* Directory entry for '.' is big.  Split? */
 	{ PR_2_SPLIT_DOT,
-	  "@d @e for '.' is big.  ",
+	  N_("@d @e for '.' is big.  "),
 	  PROMPT_SPLIT, PR_NO_OK },
 
 	/* Illegal FIFO inode */
 	{ PR_2_BAD_FIFO,
-	  "@i %i (%Q) is an @I FIFO.\n",
+	  N_("@i %i (%Q) is an @I FIFO.\n"),
 	  PROMPT_CLEAR, 0 },
 
 	/* Illegal socket inode */
 	{ PR_2_BAD_SOCKET,
-	  "@i %i (%Q) is an @I socket.\n",
+	  N_("@i %i (%Q) is an @I socket.\n"),
 	  PROMPT_CLEAR, 0 },
 
 	/* Directory filetype not set */
 	{ PR_2_SET_FILETYPE,
-	  "Setting filetype for @E to %N.\n",
+	  N_("Setting filetype for @E to %N.\n"),
 	  PROMPT_NONE, PR_PREEN_OK | PR_NO_OK | PR_NO_NOMSG },
 
 	/* Directory filetype incorrect */
 	{ PR_2_BAD_FILETYPE,
-	  "@E has an incorrect filetype (was %dt, should be %N)\n",
+	  N_("@E has an incorrect filetype (was %dt, should be %N)\n"),
 	  PROMPT_FIX, 0 },
 
 	/* Directory filetype set on filesystem */
 	{ PR_2_CLEAR_FILETYPE,
-	  "@E has filetype set\n",
+	  N_("@E has filetype set\n"),
 	  PROMPT_CLEAR, PR_PREEN_OK },
 
 	/* Directory filename is null */
 	{ PR_2_NULL_NAME,
-	  "@E has a zero-length name\n",
+	  N_("@E has a zero-length name\n"),
 	  PROMPT_CLEAR, 0 },
 
 	/* Pass 3 errors */
 
 	/* Pass 3: Checking directory connectivity */
 	{ PR_3_PASS_HEADER,
-	  "Pass 3: Checking @d connectivity\n",
+	  N_("Pass 3: Checking @d connectivity\n"),
 	  PROMPT_NONE, 0 },
 		  
 	/* Root inode not allocated */
 	{ PR_3_NO_ROOT_INODE,
-	  "@r not allocated.  ",
+	  N_("@r not allocated.  "),
 	  PROMPT_ALLOCATE, 0 },	
 		  
 	/* No room in lost+found */
 	{ PR_3_EXPAND_LF_DIR,
-	  "No room in @l @d.  ",
+	  N_("No room in @l @d.  "),
 	  PROMPT_EXPAND, 0 },
 
 	/* Unconnected directory inode */
 	{ PR_3_UNCONNECTED_DIR,
-	  "Unconnected @d @i %i (%p)\n",
+	  N_("Unconnected @d @i %i (%p)\n"),
 	  PROMPT_CONNECT, 0 },
 
 	/* /lost+found not found */
 	{ PR_3_NO_LF_DIR,
-	  "/@l not found.  ",
+	  N_("/@l not found.  "),
 	  PROMPT_CREATE, PR_PREEN_OK },
 
 	/* .. entry is incorrect */
 	{ PR_3_BAD_DOT_DOT,
-	  "'..' in %Q (%i) is %P (%j), @s %q (%d).\n",
+	  N_("'..' in %Q (%i) is %P (%j), @s %q (%d).\n"),
 	  PROMPT_FIX, 0 },
 
 	/* Bad or non-existent /lost+found.  Cannot reconnect */
 	{ PR_3_NO_LPF,
-	  "Bad or non-existent /@l.  Cannot reconnect\n",
+	  N_("Bad or non-existent /@l.  Cannot reconnect\n"),
 	  PROMPT_NONE, 0 },
 
 	/* Could not expand /lost+found */
 	{ PR_3_CANT_EXPAND_LPF,
-	  "Could not expand /@l: %m\n",
+	  N_("Could not expand /@l: %m\n"),
 	  PROMPT_NONE, 0 },
 
 	/* Could not reconnect inode */
 	{ PR_3_CANT_RECONNECT,
-	  "Could not reconnect %i: %m\n",
+	  N_("Could not reconnect %i: %m\n"),
 	  PROMPT_NONE, 0 },
 
 	/* Error while trying to find /lost+found */
 	{ PR_3_ERR_FIND_LPF,
-	  "Error while trying to find /@l: %m\n",
+	  N_("Error while trying to find /@l: %m\n"),
 	  PROMPT_NONE, 0 },
 
 	/* Error in ext2fs_new_block while creating /lost+found */
 	{ PR_3_ERR_LPF_NEW_BLOCK, 
-	  "ext2fs_new_@b: %m while trying to create /@l @d\n",
+	  N_("ext2fs_new_@b: %m while trying to create /@l @d\n"),
 	  PROMPT_NONE, 0 },
 		  
 	/* Error in ext2fs_new_inode while creating /lost+found */
 	{ PR_3_ERR_LPF_NEW_INODE,
-	  "ext2fs_new_@i: %m while trying to create /@l @d\n",
+	  N_("ext2fs_new_@i: %m while trying to create /@l @d\n"),
 	  PROMPT_NONE, 0 },
 
 	/* Error in ext2fs_new_dir_block while creating /lost+found */	  
 	{ PR_3_ERR_LPF_NEW_DIR_BLOCK,
-	  "ext2fs_new_dir_@b: %m while creating new @d @b\n",
+	  N_("ext2fs_new_dir_@b: %m while creating new @d @b\n"),
 	  PROMPT_NONE, 0 },
 		  
 	/* Error while writing directory block for /lost+found */
 	{ PR_3_ERR_LPF_WRITE_BLOCK,
-	  "ext2fs_write_dir_@b: %m while writing the @d @b for /@l\n",
+	  N_("ext2fs_write_dir_@b: %m while writing the @d @b for /@l\n"),
 	  PROMPT_NONE, 0 },
 
 	/* Error while adjusting inode count */
 	{ PR_3_ADJUST_INODE,
-	  "Error while adjusting @i count on @i %i\n",
+	  N_("Error while adjusting @i count on @i %i\n"),
 	  PROMPT_NONE, 0 },
 
 	/* Couldn't fix parent directory -- error */
 	{ PR_3_FIX_PARENT_ERR,
-	  "Couldn't fix parent of @i %i: %m\n\n",
+	  N_("Couldn't fix parent of @i %i: %m\n\n"),
 	  PROMPT_NONE, 0 },
 
 	/* Couldn't fix parent directory -- couldn't find it */	  
 	{ PR_3_FIX_PARENT_NOFIND,
-	  "Couldn't fix parent of @i %i: Couldn't find parent @d entry\n\n",
+	  N_("Couldn't fix parent of @i %i: Couldn't find parent @d entry\n\n"),
 	  PROMPT_NONE, 0 },
 
 	/* Error allocating inode bitmap */
 	{ PR_3_ALLOCATE_IBITMAP_ERROR,
-	  "@A @i @B (%N): %m\n",
+	  N_("@A @i @B (%N): %m\n"),
 	  PROMPT_NONE, PR_FATAL },
 
 	/* Error creating root directory */
 	{ PR_3_CREATE_ROOT_ERROR,
-	  "Error creating root @d (%s): %m\n",
+	  N_("Error creating root @d (%s): %m\n"),
 	  PROMPT_NONE, PR_FATAL },	  
 
 	/* Error creating lost and found directory */
 	{ PR_3_CREATE_LPF_ERROR,
-	  "Error creating /@l @d (%s): %m\n",
+	  N_("Error creating /@l @d (%s): %m\n"),
 	  PROMPT_NONE, PR_FATAL },  
 
 	/* Root inode is not directory; aborting */
 	{ PR_3_ROOT_NOT_DIR_ABORT,
-	  "@r is not a @d; aborting.\n",
+	  N_("@r is not a @d; aborting.\n"),
 	  PROMPT_NONE, PR_FATAL },  
 
 	/* Cannot proceed without a root inode. */
 	{ PR_3_NO_ROOT_INODE_ABORT,
-	  "Cannot proceed without a @r.\n",
+	  N_("Cannot proceed without a @r.\n"),
 	  PROMPT_NONE, PR_FATAL },  
 
 	/* Internal error: couldn't find dir_info */
 	{ PR_3_NO_DIRINFO,
-	  "Internal error: couldn't find dir_info for %i.\n",
+	  N_("Internal error: couldn't find dir_info for %i.\n"),
 	  PROMPT_NONE, PR_FATAL },
 
 	/* Lost+found not a directory */
 	{ PR_3_LPF_NOTDIR,
-	  "/@l is not a @d (ino=%i)\n",
+	  N_("/@l is not a @d (ino=%i)\n"),
 	  PROMPT_UNLINK, 0 }, 
 
 	/* Pass 4 errors */
 	
 	/* Pass 4: Checking reference counts */
 	{ PR_4_PASS_HEADER,
-	  "Pass 4: Checking reference counts\n",
+	  N_("Pass 4: Checking reference counts\n"),
 	  PROMPT_NONE, 0 },
 		  
 	/* Unattached zero-length inode */
@@ -864,36 +864,36 @@ static const struct e2fsck_problem problem_table[] = {
 
 	/* Inode ref count wrong */
 	{ PR_4_BAD_REF_COUNT,
-	  "@i %i ref count is %Il, @s %N.  ",
+	  N_("@i %i ref count is %Il, @s %N.  "),
 	  PROMPT_FIX, PR_PREEN_OK },
 
 	{ PR_4_INCONSISTENT_COUNT,
-	  "WARNING: PROGRAMMING BUG IN E2FSCK!\n"
+	  N_("WARNING: PROGRAMMING BUG IN E2FSCK!\n"
 	  "\tOR SOME BONEHEAD (YOU) IS CHECKING A MOUNTED (LIVE) FILESYSTEM.\n"
 	  "@i_link_info[%i] is %N, @i.i_links_count is %Il.  "
-	  "They should be the same!\n",
+	  "They should be the same!\n"),
 	  PROMPT_NONE, 0 },
 
 	/* Pass 5 errors */
 		  
 	/* Pass 5: Checking group summary information */
 	{ PR_5_PASS_HEADER,
-	  "Pass 5: Checking @g summary information\n",
+	  N_("Pass 5: Checking @g summary information\n"),
 	  PROMPT_NONE, 0 },
 		  
 	/* Padding at end of inode bitmap is not set. */
 	{ PR_5_INODE_BMAP_PADDING,
-	  "Padding at end of @i @B is not set. ",
+	  N_("Padding at end of @i @B is not set. "),
 	  PROMPT_FIX, PR_PREEN_OK },
 		  
 	/* Padding at end of block bitmap is not set. */
 	{ PR_5_BLOCK_BMAP_PADDING,
-	  "Padding at end of @b @B is not set. ",
+	  N_("Padding at end of @b @B is not set. "),
 	  PROMPT_FIX, PR_PREEN_OK },
 		
 	/* Block bitmap differences header */
 	{ PR_5_BLOCK_BITMAP_HEADER,
-	  "@b @B differences: ",
+	  N_("@b @B differences: "),
 	  PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG},
 
 	/* Block not used, but marked in bitmap */
@@ -913,7 +913,7 @@ static const struct e2fsck_problem problem_table[] = {
 
 	/* Inode bitmap differences header */
 	{ PR_5_INODE_BITMAP_HEADER,
-	  "@i @B differences: ",
+	  N_("@i @B differences: "),
 	  PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG },
 
 	/* Inode not used, but marked in bitmap */
@@ -933,38 +933,38 @@ static const struct e2fsck_problem problem_table[] = {
 
 	/* Free inodes count for group wrong */
 	{ PR_5_FREE_INODE_COUNT_GROUP,
-	  "Free @is count wrong for @g #%g (%i, counted=%j).\n",
+	  N_("Free @is count wrong for @g #%g (%i, counted=%j).\n"),
 	  PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG },
 
 	/* Directories count for group wrong */
 	{ PR_5_FREE_DIR_COUNT_GROUP,
-	  "Directories count wrong for @g #%g (%i, counted=%j).\n",
+	  N_("Directories count wrong for @g #%g (%i, counted=%j).\n"),
 	  PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG },
 
 	/* Free inodes count wrong */
 	{ PR_5_FREE_INODE_COUNT,
-	  "Free @is count wrong (%i, counted=%j).\n",
+	  N_("Free @is count wrong (%i, counted=%j).\n"),
 	  PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG },
 
 	/* Free blocks count for group wrong */
 	{ PR_5_FREE_BLOCK_COUNT_GROUP,
-	  "Free @bs count wrong for @g #%g (%b, counted=%c).\n",
+	  N_("Free @bs count wrong for @g #%g (%b, counted=%c).\n"),
 	  PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG },
 
 	/* Free blocks count wrong */
 	{ PR_5_FREE_BLOCK_COUNT,
-	  "Free @bs count wrong (%b, counted=%c).\n",
+	  N_("Free @bs count wrong (%b, counted=%c).\n"),
 	  PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG },
 
 	/* Programming error: bitmap endpoints don't match */
 	{ PR_5_BMAP_ENDPOINTS,
-	  "PROGRAMMING ERROR: @f (#%N) @B endpoints (%b, %c) don't "
-	  "match calculated @B endpoints (%i, %j)\n",
+	  N_("PROGRAMMING ERROR: @f (#%N) @B endpoints (%b, %c) don't "
+	  "match calculated @B endpoints (%i, %j)\n"),
 	  PROMPT_NONE, PR_FATAL },
 
 	/* Internal error: fudging end of bitmap */
 	{ PR_5_FUDGE_BITMAP_ERROR,
-	  "Internal error: fudging end of bitmap (%N)\n",
+	  N_("Internal error: fudging end of bitmap (%N)\n"),
 	  PROMPT_NONE, PR_FATAL },	  
 	  
 	{ 0 }
@@ -1065,7 +1065,7 @@ int fix_problem(e2fsck_t ctx, problem_t code, struct problem_context *pctx)
 
 	ptr = find_problem(code);
 	if (!ptr) {
-		printf("Unhandled error code (%d)!\n", code);
+		printf(_("Unhandled error code (%d)!\n"), code);
 		return 0;
 	}
 	def_yn = 1;
@@ -1106,7 +1106,7 @@ int fix_problem(e2fsck_t ctx, problem_t code, struct problem_context *pctx)
 				message = ptr->e2p_preen_msg;
 #endif
 		}
-		print_e2fsck_message(ctx, message, pctx, 1);
+		print_e2fsck_message(ctx, _(message), pctx, 1);
 	}
 	if (!(ptr->flags & PR_PREEN_OK) && (ptr->prompt != PROMPT_NONE))
 		preenhalt(ctx);
@@ -1133,13 +1133,13 @@ int fix_problem(e2fsck_t ctx, problem_t code, struct problem_context *pctx)
 			else
 				answer = 0;
 		} else
-			answer = ask(ctx, prompt[(int) ptr->prompt], def_yn);
+			answer = ask(ctx, _(prompt[(int) ptr->prompt]), def_yn);
 		if (!answer && !(ptr->flags & PR_NO_OK))
 			ext2fs_unmark_valid(fs);
 	
 		if (print_answer)
 			printf("%s.\n", answer ?
-			       preen_msg[(int) ptr->prompt] : "IGNORED");
+			       _(preen_msg[(int) ptr->prompt]) : _("IGNORED"));
 	
 	}
 
diff --git a/e2fsck/scantest.c b/e2fsck/scantest.c
index 1a37dc43..47acfff5 100644
--- a/e2fsck/scantest.c
+++ b/e2fsck/scantest.c
@@ -77,7 +77,7 @@ static void print_resource_track(struct resource_track *track)
 	gettimeofday(&time_end, 0);
 	getrusage(RUSAGE_SELF, &r);
 
-	printf("Memory used: %d, elapsed time: %6.3f/%6.3f/%6.3f\n",
+	printf(_("Memory used: %d, elapsed time: %6.3f/%6.3f/%6.3f\n"),
 	       (int) (((char *) sbrk(0)) - ((char *) track->brk_start)),
 	       timeval_subtract(&time_end, &track->time_start),
 	       timeval_subtract(&r.ru_utime, &track->user_start),
@@ -96,7 +96,7 @@ int main (int argc, char *argv[])
 	ino_t	ino;
 	struct ext2_inode inode;
 
-	printf("size of inode=%d\n", sizeof(inode));
+	printf(_("size of inode=%d\n"), sizeof(inode));
 
 	device_name = "/dev/hda3";
 	
@@ -105,19 +105,19 @@ int main (int argc, char *argv[])
 	retval = ext2fs_open(device_name, 0,
 			     0, 0, unix_io_manager, &fs);
 	if (retval) {
-		com_err(argv[0], retval, "while trying to open %s",
+		com_err(argv[0], retval, _("while trying to open %s"),
 			device_name);
 		exit(1);
 	}
 
 	retval = ext2fs_open_inode_scan(fs, 0, &scan);
 	if (retval) {
-		com_err(argv[0], retval, "while opening inode scan");
+		com_err(argv[0], retval, _("while opening inode scan"));
 		exit(1);
 	}
 	retval = ext2fs_get_next_inode(scan, &ino, &inode);
 	if (retval) {
-		com_err(argv[0], retval, "while starting inode scan");
+		com_err(argv[0], retval, _("while starting inode scan"));
 		exit(1);
 	}
 	while (ino) {
@@ -128,7 +128,7 @@ int main (int argc, char *argv[])
 		retval = ext2fs_get_next_inode(scan, &ino, &inode);
 		if (retval) {
 			com_err(argv[0], retval,
-				"while doing inode scan");
+				_("while doing inode scan"));
 			exit(1);
 		}
 	}
diff --git a/e2fsck/swapfs.c b/e2fsck/swapfs.c
index 3a8a8786..b251e9e7 100644
--- a/e2fsck/swapfs.c
+++ b/e2fsck/swapfs.c
@@ -93,13 +93,13 @@ static void swap_inode_blocks(e2fsck_t ctx, ino_t ino, char *block_buf,
 				      swap_block, &sb);
 	if (retval) {
 		com_err("swap_inode_blocks", retval,
-			"while calling ext2fs_block_iterate");
+			_("while calling ext2fs_block_iterate"));
 		ctx->flags |= E2F_FLAG_ABORT;
 		return;
 	}
 	if (sb.errcode) {
 		com_err("swap_inode_blocks", sb.errcode,
-			"while calling iterator function");
+			_("while calling iterator function"));
 		ctx->flags |= E2F_FLAG_ABORT;
 		return;
 	}
@@ -120,7 +120,7 @@ static void swap_inodes(e2fsck_t ctx)
 				(void **) &buf);
 	if (retval) {
 		com_err("swap_inodes", retval,
-			"while allocating inode buffer");
+			_("while allocating inode buffer"));
 		ctx->flags |= E2F_FLAG_ABORT;
 		return;
 	}
@@ -132,7 +132,7 @@ static void swap_inodes(e2fsck_t ctx)
 		      fs->inode_blocks_per_group, buf);
 		if (retval) {
 			com_err("swap_inodes", retval,
-				"while reading inode table (group %d)",
+				_("while reading inode table (group %d)"),
 				group);
 			ctx->flags |= E2F_FLAG_ABORT;
 			return;
@@ -170,7 +170,7 @@ static void swap_inodes(e2fsck_t ctx)
 		      fs->inode_blocks_per_group, buf);
 		if (retval) {
 			com_err("swap_inodes", retval,
-				"while writing inode table (group %d)",
+				_("while writing inode table (group %d)"),
 				group);
 			ctx->flags |= E2F_FLAG_ABORT;
 			return;
@@ -191,17 +191,17 @@ void swap_filesys(e2fsck_t ctx)
 #endif
 
 	if (!(ctx->options & E2F_OPT_PREEN))
-		printf("Pass 0: Doing byte-swap of filesystem\n");
+		printf(_("Pass 0: Doing byte-swap of filesystem\n"));
 	
 #ifdef MTRACE
 	mtrace_print("Byte swap");
 #endif
 
 	if (fs->super->s_mnt_count) {
-		fprintf(stderr, "%s: the filesystem must be freshly "
+		fprintf(stderr, _("%s: the filesystem must be freshly "
 			"checked using fsck\n"
 			"and not mounted before trying to "
-			"byte-swap it.\n", ctx->device_name);
+			"byte-swap it.\n"), ctx->device_name);
 		ctx->flags |= E2F_FLAG_ABORT;
 		return;
 	}
@@ -224,7 +224,7 @@ void swap_filesys(e2fsck_t ctx)
 	
 #ifdef RESOURCE_TRACK
 	if (ctx->options & E2F_OPT_TIME2)
-		print_resource_track("Byte swap", &rtrack);
+		print_resource_track(_("Byte swap"), &rtrack);
 #endif
 }
 
diff --git a/e2fsck/unix.c b/e2fsck/unix.c
index ae5a808d..882e5800 100644
--- a/e2fsck/unix.c
+++ b/e2fsck/unix.c
@@ -58,12 +58,12 @@ static int read_only_root = 0;
 static void usage(e2fsck_t ctx)
 {
 	fprintf(stderr,
-		"Usage: %s [-panyrcdfvstFSV] [-b superblock] [-B blocksize]\n"
+		_("Usage: %s [-panyrcdfvstFSV] [-b superblock] [-B blocksize]\n"
 		"\t\t[-I inode_buffer_blocks] [-P process_inode_size]\n"
-		"\t\t[-l|-L bad_blocks_file] [-C fd] device\n",
+		"\t\t[-l|-L bad_blocks_file] [-C fd] device\n"),
 		ctx->program_name);
 
-	fprintf(stderr, "\nEmergency help:\n"
+	fprintf(stderr, _("\nEmergency help:\n"
 		" -p                   Automatic repair (no questions)\n"
 		" -n                   Make no changes to the filesystem\n"
 		" -y                   Assume \"yes\" to all questions\n"
@@ -74,7 +74,7 @@ static void usage(e2fsck_t ctx)
 		" -B blocksize         Force blocksize when looking for superblock\n"
 		" -l bad_blocks_file   Add to badblocks list\n"
 		" -L bad_blocks_file   Set badblocks list\n"
-		);
+		));
 
 	exit(FSCK_USAGE);
 }
@@ -101,12 +101,51 @@ static void show_stats(e2fsck_t	ctx)
 	frag_percent = (frag_percent + 5) / 10;
 	
 	if (!verbose) {
-		printf("%s: %d/%d files (%0d.%d%% non-contiguous), %d/%d blocks\n",
+		printf(_("%s: %d/%d files (%0d.%d%% non-contiguous), %d/%d blocks\n"),
 		       ctx->device_name, inodes_used, inodes,
 		       frag_percent / 10, frag_percent % 10,
 		       blocks_used, blocks);
 		return;
 	}
+	/*
+	 * This is a bit ugly. But I think there will nearly always be more
+	 * than one "thing" to report about, so I won't try writing complex
+	 * code to handle one/two/many forms of all words.
+	 * Some languages (Italian, at least) never uses the plural form
+	 * of foreign words, so in real life this could not be a problem.
+	 * md@linux.it - 2000-1-15
+	 */
+#ifdef ENABLE_NLS
+	printf (_("\n%8d inodes used (%d%%)\n"), inodes_used,
+		(inodes_used != 1), 100 * inodes_used / inodes);
+	printf (_("%8d non-contiguous inodes (%0d.%d%%)\n"),
+		ctx->fs_fragmented, frag_percent / 10, frag_percent % 10);
+	printf (_("         # of inodes with ind/dind/tind blocks: %d/%d/%d\n"),
+		ctx->fs_ind_count, ctx->fs_dind_count, ctx->fs_tind_count);
+	printf (_("%8d blocks used (%d%%)\n"
+		"%8d bad blocks\n"), blocks_used,
+		100 * blocks_used / blocks, ctx->fs_badblocks_count);
+	printf (_("\n%8d regular files\n"
+		"%8d directories\n"
+		"%8d character device files\n"
+		"%8d block device files\n"
+		"%8d fifos\n"
+		"%8d links\n"
+		"%8d symbolic links (%d fast symbolic links)\n"
+		"%8d sockets\n"
+		"--------\n"
+		"%8d files\n"),
+		ctx->fs_regular_count,
+		ctx->fs_directory_count,
+		ctx->fs_chardev_count,
+		ctx->fs_blockdev_count,
+		ctx->fs_fifo_count,
+		ctx->fs_links_count - dir_links,
+		ctx->fs_symlinks_count,
+		ctx->fs_fast_symlinks_count,
+		ctx->fs_sockets_count,
+		ctx->fs_total_count - dir_links);
+#else
 	printf ("\n%8d inode%s used (%d%%)\n", inodes_used,
 		(inodes_used != 1) ? "s" : "",
 		100 * inodes_used / inodes);
@@ -148,6 +187,7 @@ static void show_stats(e2fsck_t	ctx)
 		ctx->fs_sockets_count, (ctx->fs_sockets_count != 1) ? "s" : "",
 		ctx->fs_total_count - dir_links,
 		((ctx->fs_total_count - dir_links) != 1) ? "s" : "");
+#endif
 }
 
 static void check_mount(e2fsck_t ctx)
@@ -158,7 +198,7 @@ static void check_mount(e2fsck_t ctx)
 	retval = ext2fs_check_if_mounted(ctx->filesystem_name, &mount_flags);
 	if (retval) {
 		com_err("ext2fs_check_if_mount", retval,
-			"while determining whether %s is mounted.",
+			_("while determining whether %s is mounted."),
 			ctx->filesystem_name);
 		return;
 	}
@@ -180,21 +220,21 @@ static void check_mount(e2fsck_t ctx)
 #endif
 	
 	if (ctx->options & E2F_OPT_READONLY) {
-		printf("Warning!  %s is mounted.\n", ctx->filesystem_name);
+		printf(_("Warning!  %s is mounted.\n"), ctx->filesystem_name);
 		return;
 	}
 
-	printf("%s is mounted.  ", ctx->filesystem_name);
+	printf(_("%s is mounted.  "), ctx->filesystem_name);
 	if (!isatty(0) || !isatty(1)) {
-		printf("Cannot continue, aborting.\n\n");
+		printf(_("Cannot continue, aborting.\n\n"));
 		exit(FSCK_ERROR);
 	}
-	printf("\n\n\007\007\007\007WARNING!!!  "
+	printf(_("\n\n\007\007\007\007WARNING!!!  "
 	       "Running e2fsck on a mounted filesystem may cause\n"
-	       "SEVERE filesystem damage.\007\007\007\n\n");
-	cont = ask_yn("Do you really want to continue", -1);
+	       "SEVERE filesystem damage.\007\007\007\n\n"));
+	cont = ask_yn(_("Do you really want to continue"), -1);
 	if (!cont) {
-		printf ("check aborted.\n");
+		printf (_("check aborted.\n"));
 		exit (0);
 	}
 	return;
@@ -214,21 +254,21 @@ static void check_if_skip(e2fsck_t ctx)
 		return;
 	
 	if (fs->super->s_state & EXT2_ERROR_FS)
-		reason = "contains a file system with errors";
+		reason = _("contains a file system with errors");
 	else if ((fs->super->s_state & EXT2_VALID_FS) == 0)
-		reason = "was not cleanly unmounted";
+		reason = _("was not cleanly unmounted");
 	else if (fs->super->s_mnt_count >=
 		 (unsigned) fs->super->s_max_mnt_count)
-		reason = "has reached maximal mount count";
+		reason = _("has reached maximal mount count");
 	else if (fs->super->s_checkinterval &&
 		 time(0) >= (fs->super->s_lastcheck +
 			     fs->super->s_checkinterval))
-		reason = "has gone too long without being checked";
+		reason = _("has gone too long without being checked");
 	if (reason) {
-		printf("%s %s, check forced.\n", ctx->device_name, reason);
+		printf(_("%s %s, check forced.\n"), ctx->device_name, reason);
 		return;
 	}
-	printf("%s: clean, %d/%d files, %d/%d blocks\n", ctx->device_name,
+	printf(_("%s: clean, %d/%d files, %d/%d blocks\n"), ctx->device_name,
 	       fs->super->s_inodes_count - fs->super->s_free_inodes_count,
 	       fs->super->s_inodes_count,
 	       fs->super->s_blocks_count - fs->super->s_free_blocks_count,
@@ -328,8 +368,8 @@ static void reserve_stdio_fds(NOARGS)
 		if (fd > 2)
 			break;
 		if (fd < 0) {
-			fprintf(stderr, "ERROR: Couldn't open "
-				"/dev/null (%s)\n",
+			fprintf(stderr, _("ERROR: Couldn't open "
+				"/dev/null (%s)\n"),
 				strerror(errno));
 			break;
 		}
@@ -432,8 +472,8 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx)
 			else
 				ctx->options |= E2F_OPT_TIME;
 #else
-			fprintf(stderr, "The -t option is not "
-				"supported on this version of e2fsck.\n");
+			fprintf(stderr, _("The -t option is not "
+				"supported on this version of e2fsck.\n"));
 #endif
 			break;
 		case 'c':
@@ -474,7 +514,7 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx)
 #ifdef BLKFLSBUF
 			flush = 1;
 #else
-			fatal_error(ctx, "-F not supported");
+			fatal_error(ctx, _("-F not supported"));
 #endif
 			break;
 		case 'v':
@@ -512,24 +552,26 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx)
 		int	fd = open(ctx->filesystem_name, O_RDONLY, 0);
 
 		if (fd < 0) {
-			com_err("open", errno, "while opening %s for flushing",
+			com_err("open", errno,
+				_("while opening %s for flushing"),
 				ctx->filesystem_name);
 			exit(FSCK_ERROR);
 		}
 		if (ioctl(fd, BLKFLSBUF, 0) < 0) {
-			com_err("BLKFLSBUF", errno, "while trying to flush %s",
+			com_err("BLKFLSBUF", errno,
+				_("while trying to flush %s"),
 				ctx->filesystem_name);
 			exit(FSCK_ERROR);
 		}
 		close(fd);
 #else
-		fatal_error(ctx, "BLKFLSBUF not supported");
+		fatal_error(ctx, _("BLKFLSBUF not supported"));
 #endif /* BLKFLSBUF */
 	}
 	if (swapfs) {
 		if (cflag || bad_blocks_file) {
-			fprintf(stderr, "Incompatible options not "
-				"allowed when byte-swapping.\n");
+			fprintf(stderr, _("Incompatible options not "
+				"allowed when byte-swapping.\n"));
 			exit(FSCK_ERROR);
 		}
 	}
@@ -574,18 +616,23 @@ int main (int argc, char *argv[])
 #ifdef MCHECK
 	mcheck(0);
 #endif
+#ifdef ENABLE_NLS
+	setlocale(LC_MESSAGES, "");
+	bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
+	textdomain(NLS_CAT_NAME);
+#endif
 	my_ver = ext2fs_parse_version_string(my_ver_string);
 	lib_ver = ext2fs_get_library_version(0, &lib_ver_date);
 	if (my_ver > lib_ver) {
-		fprintf( stderr, "Error: ext2fs library version "
-			"out of date!\n");
+		fprintf( stderr, _("Error: ext2fs library version "
+			"out of date!\n"));
 		show_version_only++;
 	}
 	
 	retval = PRS(argc, argv, &ctx);
 	if (retval) {
 		com_err("e2fsck", retval,
-			"while trying to initialize program");
+			_("while trying to initialize program"));
 		exit(1);
 	}
 	reserve_stdio_fds();
@@ -595,12 +642,12 @@ int main (int argc, char *argv[])
 #endif
 
 	if (!(ctx->options & E2F_OPT_PREEN) || show_version_only)
-		fprintf (stderr, "e2fsck %s, %s for EXT2 FS %s, %s\n",
+		fprintf (stderr, _("e2fsck %s, %s for EXT2 FS %s, %s\n"),
 			 my_ver_string, my_ver_date, EXT2FS_VERSION,
 			 EXT2FS_DATE);
 
 	if (show_version_only) {
-		fprintf(stderr, "\tUsing %s, %s\n",
+		fprintf(stderr, _("\tUsing %s, %s\n"),
 			error_message(EXT2_ET_BASE), lib_ver_date);
 		exit(0);
 	}
@@ -612,7 +659,7 @@ int main (int argc, char *argv[])
 	    !(ctx->options & E2F_OPT_YES)) {
 		if (!isatty (0) || !isatty (1))
 			fatal_error(ctx,
-				    "need terminal for interactive repairs");
+				    _("need terminal for interactive repairs"));
 	}
 	ctx->superblock = ctx->use_superblock;
 restart:
@@ -642,9 +689,9 @@ restart:
 	    ((retval == EXT2_ET_BAD_MAGIC) ||
 	     ((retval == 0) && ext2fs_check_desc(fs)))) {
 		if (!fs || (fs->group_desc_count > 1)) {
-			printf("%s trying backup blocks...\n",
-			       retval ? "Couldn't find ext2 superblock," :
-			       "Group descriptors look bad...");
+			printf(_("%s trying backup blocks...\n"),
+			       retval ? _("Couldn't find ext2 superblock,") :
+			       _("Group descriptors look bad..."));
 			ctx->superblock = get_backup_sb(fs);
 			if (fs)
 				ext2fs_close(fs);
@@ -652,28 +699,28 @@ restart:
 		}
 	}
 	if (retval) {
-		com_err(ctx->program_name, retval, "while trying to open %s",
+		com_err(ctx->program_name, retval, _("while trying to open %s"),
 			ctx->filesystem_name);
 		if (retval == EXT2_ET_REV_TOO_HIGH) {
-			printf("The filesystem revision is apparently "
+			printf(_("The filesystem revision is apparently "
 			       "too high for this version of e2fsck.\n"
 			       "(Or the filesystem superblock "
-			       "is corrupt)\n\n");
+			       "is corrupt)\n\n"));
 			fix_problem(ctx, PR_0_SB_CORRUPT, &pctx);
 		} else if (retval == EXT2_ET_SHORT_READ)
-			printf("Could this be a zero-length partition?\n");
+			printf(_("Could this be a zero-length partition?\n"));
 		else if ((retval == EPERM) || (retval == EACCES))
-			printf("You must have %s access to the "
-			       "filesystem or be root\n",
+			printf(_("You must have %s access to the "
+			       "filesystem or be root\n"),
 			       (ctx->options & E2F_OPT_READONLY) ?
 			       "r/o" : "r/w");
 		else if (retval == ENXIO)
-			printf("Possibly non-existent or swap device?\n");
+			printf(_("Possibly non-existent or swap device?\n"));
 #ifdef EROFS
 		else if (retval == EROFS)
-			printf("Disk write-protected; use the -n option "
+			printf(_("Disk write-protected; use the -n option "
 			       "to do a read-only\n"
-			       "check of the device.\n");
+			       "check of the device.\n"));
 #endif
 		else
 			fix_problem(ctx, PR_0_SB_CORRUPT, &pctx);
@@ -684,10 +731,10 @@ restart:
 #ifdef	EXT2_CURRENT_REV
 	if (fs->super->s_rev_level > E2FSCK_CURRENT_REV) {
 		com_err(ctx->program_name, EXT2_ET_REV_TOO_HIGH,
-			"while trying to open %s",
+			_("while trying to open %s"),
 			ctx->filesystem_name);
 	get_newer:
-		fatal_error(ctx, "Get a newer version of e2fsck!");
+		fatal_error(ctx, _("Get a newer version of e2fsck!"));
 	}
 #endif
 	/*
@@ -752,8 +799,8 @@ restart:
 	if (normalize_swapfs) {
 		if ((fs->flags & EXT2_FLAG_SWAP_BYTES) ==
 		    ext2fs_native_flag()) {
-			fprintf(stderr, "%s: Filesystem byte order "
-				"already normalized.\n", ctx->device_name);
+			fprintf(stderr, _("%s: Filesystem byte order "
+				"already normalized.\n"), ctx->device_name);
 			exit(FSCK_ERROR);
 		}
 	}
@@ -771,19 +818,20 @@ restart:
 	retval = ext2fs_read_bb_inode(fs, &fs->badblocks);
 	if (retval) {
 		com_err(ctx->program_name, retval,
-			"while reading bad blocks inode");
+			_("while reading bad blocks inode"));
 		preenhalt(ctx);
-		printf("This doesn't bode well, but we'll try to go on...\n");
+		printf(_("This doesn't bode well,"
+			 " but we'll try to go on...\n"));
 	}
 
 	run_result = e2fsck_run(ctx);
 	e2fsck_clear_progbar(ctx);
 	if (run_result == E2F_FLAG_RESTART) {
-		printf("Restarting e2fsck from the beginning...\n");
+		printf(_("Restarting e2fsck from the beginning...\n"));
 		retval = e2fsck_reset_context(ctx);
 		if (retval) {
 			com_err(ctx->program_name, retval,
-				"while resetting context");
+				_("while resetting context"));
 			exit(1);
 		}
 		ext2fs_close(fs);
@@ -800,10 +848,10 @@ restart:
 	if (ext2fs_test_changed(fs)) {
 		exit_value = FSCK_NONDESTRUCT;
 		if (!(ctx->options & E2F_OPT_PREEN))
-			printf("\n%s: ***** FILE SYSTEM WAS MODIFIED *****\n",
+		    printf(_("\n%s: ***** FILE SYSTEM WAS MODIFIED *****\n"),
 			       ctx->device_name);
 		if (root_filesystem && !read_only_root) {
-			printf("%s: ***** REBOOT LINUX *****\n",
+			printf(_("%s: ***** REBOOT LINUX *****\n"),
 			       ctx->device_name);
 			exit_value = FSCK_REBOOT;
 		}
diff --git a/e2fsck/util.c b/e2fsck/util.c
index 74320b87..d525ba68 100644
--- a/e2fsck/util.c
+++ b/e2fsck/util.c
@@ -67,6 +67,8 @@ int ask_yn(const char * string, int def)
 {
 	int		c;
 	const char	*defstr;
+	char		*short_yes = _("yY");
+	char		*short_no = _("nN");
 
 #ifdef HAVE_TERMIOS_H
 	struct termios	termios, tmp;
@@ -80,22 +82,21 @@ int ask_yn(const char * string, int def)
 #endif
 
 	if (def == 1)
-		defstr = "<y>";
+		defstr = _("<y>");
 	else if (def == 0)
-		defstr = "<n>";
+		defstr = _("<n>");
 	else
-		defstr = " (y/n)";
+		defstr = _(" (y/n)");
 	printf("%s%s? ", string, defstr);
 	while (1) {
 		fflush (stdout);
 		if ((c = read_a_char()) == EOF)
 			break;
-		c = toupper(c);
-		if (c == 'Y') {
+		if (strchr(short_yes, (char) c)) {
 			def = 1;
 			break;
 		}
-		else if (c == 'N') {
+		else if (strchr(short_no, (char) c)) {
 			def = 0;
 			break;
 		}
@@ -115,15 +116,15 @@ int ask_yn(const char * string, int def)
 int ask (e2fsck_t ctx, const char * string, int def)
 {
 	if (ctx->options & E2F_OPT_NO) {
-		printf ("%s? no\n\n", string);
+		printf (_("%s? no\n\n"), string);
 		return 0;
 	}
 	if (ctx->options & E2F_OPT_YES) {
-		printf ("%s? yes\n\n", string);
+		printf (_("%s? yes\n\n"), string);
 		return 1;
 	}
 	if (ctx->options & E2F_OPT_PREEN) {
-		printf ("%s? %s\n\n", string, def ? "yes" : "no");
+		printf ("%s? %s\n\n", string, def ? _("yes") : _("no"));
 		return def;
 	}
 	return ask_yn(string, def);
@@ -136,17 +137,17 @@ void e2fsck_read_bitmaps(e2fsck_t ctx)
 
 	if (ctx->invalid_bitmaps) {
 		com_err(ctx->program_name, 0,
-			"e2fsck_read_bitmaps: illegal bitmap block(s) for %s",
+		    _("e2fsck_read_bitmaps: illegal bitmap block(s) for %s"),
 			ctx->device_name);
 		fatal_error(ctx, 0);
 	}
 
-	ehandler_operation("reading inode and block bitmaps");
+	ehandler_operation(_("reading inode and block bitmaps"));
 	retval = ext2fs_read_bitmaps(fs);
 	ehandler_operation(0);
 	if (retval) {
 		com_err(ctx->program_name, retval,
-			"while retrying to read bitmaps for %s",
+			_("while retrying to read bitmaps for %s"),
 			ctx->device_name);
 		fatal_error(ctx, 0);
 	}
@@ -158,24 +159,24 @@ void e2fsck_write_bitmaps(e2fsck_t ctx)
 	errcode_t	retval;
 
 	if (ext2fs_test_bb_dirty(fs)) {
-		ehandler_operation("writing block bitmaps");
+		ehandler_operation(_("writing block bitmaps"));
 		retval = ext2fs_write_block_bitmap(fs);
 		ehandler_operation(0);
 		if (retval) {
 			com_err(ctx->program_name, retval,
-				"while retrying to write block bitmaps for %s",
+			    _("while retrying to write block bitmaps for %s"),
 				ctx->device_name);
 			fatal_error(ctx, 0);
 		}
 	}
 
 	if (ext2fs_test_ib_dirty(fs)) {
-		ehandler_operation("writing inode bitmaps");
+		ehandler_operation(_("writing inode bitmaps"));
 		retval = ext2fs_write_inode_bitmap(fs);
 		ehandler_operation(0);
 		if (retval) {
 			com_err(ctx->program_name, retval,
-				"while retrying to write inode bitmaps for %s",
+			    _("while retrying to write inode bitmaps for %s"),
 				ctx->device_name);
 			fatal_error(ctx, 0);
 		}
@@ -188,8 +189,8 @@ void preenhalt(e2fsck_t ctx)
 
 	if (!(ctx->options & E2F_OPT_PREEN))
 		return;
-	fprintf(stderr, "\n\n%s: UNEXPECTED INCONSISTENCY; "
-		"RUN fsck MANUALLY.\n\t(i.e., without -a or -p options)\n",
+	fprintf(stderr, _("\n\n%s: UNEXPECTED INCONSISTENCY; "
+		"RUN fsck MANUALLY.\n\t(i.e., without -a or -p options)\n"),
 	       ctx->device_name);
 	if (fs != NULL) {
 		fs->super->s_state |= EXT2_ERROR_FS;
@@ -251,20 +252,21 @@ void print_resource_track(const char *desc, struct resource_track *track)
 
 #ifdef HAVE_MALLINFO
 	malloc_info = mallinfo();
-	printf("Memory used: %d/%d, ", malloc_info.arena, malloc_info.hblkhd);
+	printf(_("Memory used: %d/%d, "),
+		malloc_info.arena, malloc_info.hblkhd);
 #else
-	printf("Memory used: %d, ",
+	printf(_("Memory used: %d, "),
 	       (int) (((char *) sbrk(0)) - ((char *) track->brk_start)));
 #endif	
 #ifdef HAVE_GETRUSAGE
 	getrusage(RUSAGE_SELF, &r);
 
-	printf("elapsed time: %6.3f/%6.3f/%6.3f\n",
+	printf(_("elapsed time: %6.3f/%6.3f/%6.3f\n"),
 	       timeval_subtract(&time_end, &track->time_start),
 	       timeval_subtract(&r.ru_utime, &track->user_start),
 	       timeval_subtract(&r.ru_stime, &track->system_start));
 #else
-	printf("elapsed time: %6.3f\n",
+	printf(_("elapsed time: %6.3f\n"),
 	       timeval_subtract(&time_end, &track->time_start));
 #endif
 }
@@ -278,7 +280,7 @@ void e2fsck_read_inode(e2fsck_t ctx, unsigned long ino,
 	retval = ext2fs_read_inode(ctx->fs, ino, inode);
 	if (retval) {
 		com_err("ext2fs_read_inode", retval,
-			"while reading inode %ld in %s", ino, proc);
+			_("while reading inode %ld in %s"), ino, proc);
 		fatal_error(ctx, 0);
 	}
 }
@@ -291,7 +293,7 @@ extern void e2fsck_write_inode(e2fsck_t ctx, unsigned long ino,
 	retval = ext2fs_write_inode(ctx->fs, ino, inode);
 	if (retval) {
 		com_err("ext2fs_write_inode", retval,
-			"while writing inode %ld in %s", ino, proc);
+			_("while writing inode %ld in %s"), ino, proc);
 		fatal_error(ctx, 0);
 	}
 }