diff --git a/src/cat.c b/src/cat.c
index 1f0f2f2..38a2d72 100644
--- a/src/cat.c
+++ b/src/cat.c
@@ -21,6 +21,7 @@
 #include <string.h>
 
 
+/* cat */
 /* types */
 typedef enum _OutputDelay {
 	OD_NONE,
diff --git a/src/chgrp.c b/src/chgrp.c
index f37ec91..19ac363 100644
--- a/src/chgrp.c
+++ b/src/chgrp.c
@@ -1,5 +1,5 @@
 /* $Id$ */
-/* Copyright (c) 2007 Pierre Pronchery <khorben@defora.org> */
+/* Copyright (c) 2009 Pierre Pronchery <khorben@defora.org> */
 /* This file is part of DeforaOS Unix utils */
 /* utils is not free software; you can redistribute it and/or modify it under
  * the terms of the Creative Commons Attribution-NonCommercial-ShareAlike 3.0
@@ -27,19 +27,23 @@
 #include <string.h>
 
 
+/* chgrp */
 /* types */
-#define OPT_h 1
-#define OPT_R 2
-#define OPT_H 4
-#define OPT_L 8
-#define OPT_P 12
+typedef int Prefs;
+#define CHGRP_PREFS_h 1
+#define CHGRP_PREFS_R 2
+#define CHGRP_PREFS_H 4
+#define CHGRP_PREFS_L 8
+#define CHGRP_PREFS_P 12
 
 
+/* functions */
 /* chgrp */
 static int _chgrp_grp_error(char * group);
 static int _chgrp_do_recursive(int opts, gid_t gid, char * file);
 static int _chgrp_do(int opts, gid_t gid, char * file);
-static int _chgrp(int opts, char * group, int argc, char * argv[])
+
+static int _chgrp(Prefs opts, char * group, int argc, char * argv[])
 {
 	struct group * grp;
 	int res = 0;
@@ -47,14 +51,14 @@ static int _chgrp(int opts, char * group, int argc, char * argv[])
 
 	if((grp = getgrnam(group)) == NULL)
 		return _chgrp_grp_error(group);
-	if((opts & OPT_R) == OPT_R)
+	if((opts & CHGRP_PREFS_R) == CHGRP_PREFS_R)
 	{
 		for(i = 0; i < argc; i++)
-			res +=_chgrp_do_recursive(opts, grp->gr_gid, argv[i]);
+			res += _chgrp_do_recursive(opts, grp->gr_gid, argv[i]);
 		return res;
 	}
 	for(i = 0; i < argc; i++)
-		res +=_chgrp_do(opts, grp->gr_gid, argv[i]);
+		res += _chgrp_do(opts, grp->gr_gid, argv[i]);
 	return res;
 }
 
@@ -104,15 +108,15 @@ static int _chgrp_do_recursive_do(int opts, gid_t gid, char * file)
 	readdir(dir);
 	readdir(dir);
 	len = strlen(file);
-	len += (len && file[len-1] == '/') ? 1 : 2;
+	len += (len && file[len - 1] == '/') ? 1 : 2;
 	if((s = malloc(len)) == NULL)
 	{
 		closedir(dir);
 		return _chgrp_error(file, 1);
 	}
 	strcpy(s, file);
-	s[len-2] = '/';
-	s[len-1] = '\0';
+	s[len - 2] = '/';
+	s[len - 1] = '\0';
 	while((de = readdir(dir)) != NULL)
 	{
 		if((p = realloc(s, len + strlen(de->d_name))) == NULL)
@@ -123,7 +127,7 @@ static int _chgrp_do_recursive_do(int opts, gid_t gid, char * file)
 		s = p;
 		strcat(s, de->d_name);
 		_chgrp_do_recursive(opts, gid, s);
-		s[len-1] = '\0';
+		s[len - 1] = '\0';
 	}
 	free(s);
 	closedir(dir);
@@ -134,7 +138,7 @@ static int _chgrp_do(int opts, gid_t gid, char * file)
 {
 	int res;
 
-	if((opts & OPT_h) == OPT_h)
+	if((opts & CHGRP_PREFS_h) == CHGRP_PREFS_h)
 		res = lchown(file, -1, gid);
 	else
 		res = chown(file, -1, gid);
@@ -154,25 +158,27 @@ static int _usage(void)
 	return 1;
 }
 
+
 /* main */
 int main(int argc, char * argv[])
 {
 	int o;
-	int opts = 0;
+	Prefs opts = 0;
 
 	while((o = getopt(argc, argv, "hRHLP")) != -1)
 	{
 		switch(o)
 		{
 			case 'h':
-				opts |= OPT_h;
+				opts |= CHGRP_PREFS_h;
 				break;
 			case 'R':
-				opts |= OPT_R;
+				opts |= CHGRP_PREFS_R;
 				break;
 			case 'H':
 			case 'L':
 			case 'P':
+				/* FIXME implement */
 				fprintf(stderr, "%s%c%s", "chgrp: -", o,
 						": Not yet implemented\n");
 			default:
@@ -181,5 +187,6 @@ int main(int argc, char * argv[])
 	}
 	if(argc - optind < 2)
 		return _usage();
-	return _chgrp(opts, argv[optind], argc - optind - 1, &argv[optind+1]);
+	return _chgrp(opts, argv[optind], argc - optind - 1,
+			&argv[optind + 1]);
 }
diff --git a/src/chmod.c b/src/chmod.c
index ddc6b09..ac381f0 100644
--- a/src/chmod.c
+++ b/src/chmod.c
@@ -1,5 +1,5 @@
 /* $Id$ */
-/* Copyright (c) 2007 Pierre Pronchery <khorben@defora.org> */
+/* Copyright (c) 2009 Pierre Pronchery <khorben@defora.org> */
 /* This file is part of DeforaOS Unix utils */
 /* utils is not free software; you can redistribute it and/or modify it under
  * the terms of the Creative Commons Attribution-NonCommercial-ShareAlike 3.0
@@ -28,27 +28,30 @@
 #include "common.c"
 
 
-#define OPT_R 1
+/* types */
+typedef int Prefs;
+#define CHMOD_PREFS_R 1
 
 
 /* chmod */
-static int _chmod_error(char * message, int ret);
+static int _chmod_error(char const * message, int ret);
 static int _chmod_do(mode_t mode, char * file);
-static int _chmod_do_recursive(int opts, mode_t mode, char * file);
-static int _chmod(int opts, mode_t mode, int filec, char * filev[])
+static int _chmod_do_recursive(Prefs prefs, mode_t mode, char * file);
+
+static int _chmod(Prefs prefs, mode_t mode, int filec, char * filev[])
 {
 	int ret = 0;
 	int i;
 
 	for(i = 0; i < filec; i++)
-		if(opts & OPT_R)
-			ret += _chmod_do_recursive(opts, mode, filev[i]);
+		if(prefs & CHMOD_PREFS_R)
+			ret += _chmod_do_recursive(prefs, mode, filev[i]);
 		else
 			ret += _chmod_do(mode, filev[i]);
-	return ret == 0 ? 0 : 2;
+	return (ret == 0) ? 0 : 2;
 }
 
-static int _chmod_error(char * message, int ret)
+static int _chmod_error(char const * message, int ret)
 {
 	fputs("chmod: ", stderr);
 	perror(message);
@@ -62,8 +65,8 @@ static int _chmod_do(mode_t mode, char * file)
 	return 0;
 }
 
-static int _chmod_do_recursive_do(int opts, mode_t mode, char * file);
-static int _chmod_do_recursive(int opts, mode_t mode, char * file)
+static int _chmod_do_recursive_do(Prefs prefs, mode_t mode, char * file);
+static int _chmod_do_recursive(Prefs prefs, mode_t mode, char * file)
 {
 	struct stat st;
 
@@ -72,11 +75,11 @@ static int _chmod_do_recursive(int opts, mode_t mode, char * file)
 	if(!S_ISDIR(st.st_mode))
 		return _chmod_do(mode, file);
 	if(!S_ISLNK(st.st_mode))
-		return _chmod_do_recursive_do(opts, mode, file);
+		return _chmod_do_recursive_do(prefs, mode, file);
 	return 0;
 }
 
-static int _chmod_do_recursive_do(int opts, mode_t mode, char * file)
+static int _chmod_do_recursive_do(Prefs prefs, mode_t mode, char * file)
 {
 	DIR * dir;
 	struct dirent * de;
@@ -89,15 +92,15 @@ static int _chmod_do_recursive_do(int opts, mode_t mode, char * file)
 	readdir(dir);
 	readdir(dir);
 	len = strlen(file);
-	len += (len && file[len-1] == '/') ? 1 : 2;
+	len += (len && file[len - 1] == '/') ? 1 : 2;
 	if((s = malloc(len)) == NULL)
 	{
 		closedir(dir);
 		return _chmod_error(file, 1);
 	}
 	strcpy(s, file);
-	s[len-2] = '/';
-	s[len-1] = '\0';
+	s[len - 2] = '/';
+	s[len - 1] = '\0';
 	while((de = readdir(dir)) != NULL)
 	{
 		if((p = realloc(s, len + strlen(de->d_name))) == NULL)
@@ -107,8 +110,8 @@ static int _chmod_do_recursive_do(int opts, mode_t mode, char * file)
 		}
 		s = p;
 		strcat(s, de->d_name);
-		_chmod_do_recursive(opts, mode, s);
-		s[len-1] = '\0';
+		_chmod_do_recursive(prefs, mode, s);
+		s[len - 1] = '\0';
 	}
 	free(s);
 	closedir(dir);
@@ -128,15 +131,15 @@ static int _usage(void)
 /* main */
 int main(int argc, char * argv[])
 {
-	int opts = 0;
-	mode_t mode;
+	Prefs prefs = 0;
+	mode_t mode = 0;
 	int o;
 
 	while((o = getopt(argc, argv, "R")) != -1)
 		switch(o)
 		{
 			case 'R':
-				mode = OPT_R;
+				prefs = CHMOD_PREFS_R;
 				break;
 			default:
 				return _usage();
@@ -145,5 +148,5 @@ int main(int argc, char * argv[])
 		return _usage();
 	if(_mode(argv[optind], &mode) != 0)
 		return _usage();
-	return _chmod(opts, mode, argc - optind - 1, &argv[optind+1]);
+	return _chmod(prefs, mode, argc - optind - 1, &argv[optind + 1]);
 }
diff --git a/src/chown.c b/src/chown.c
index 23fdc1d..be24ccf 100644
--- a/src/chown.c
+++ b/src/chown.c
@@ -1,5 +1,5 @@
 /* $Id$ */
-/* Copyright (c) 2007 Pierre Pronchery <khorben@defora.org> */
+/* Copyright (c) 2009 Pierre Pronchery <khorben@defora.org> */
 /* This file is part of DeforaOS Unix utils */
 /* utils is not free software; you can redistribute it and/or modify it under
  * the terms of the Creative Commons Attribution-NonCommercial-ShareAlike 3.0
@@ -31,11 +31,11 @@
 
 /* types */
 typedef int Prefs;
-#define PREFS_h 1
-#define PREFS_R 2
-#define PREFS_H 4
-#define PREFS_L 8
-#define PREFS_P 12
+#define CHOWN_PREFS_h 1
+#define CHOWN_PREFS_R 2
+#define CHOWN_PREFS_H 4
+#define CHOWN_PREFS_L 8
+#define CHOWN_PREFS_P 12
 
 
 /* chown */
@@ -46,14 +46,14 @@ static int _chown_do_recursive(Prefs * prefs, uid_t uid, gid_t gid,
 static int _chown_do(Prefs * prefs, uid_t uid, gid_t gid, char * file);
 static int _chown(Prefs * prefs, char * owner, int argc, char * argv[])
 {
-	uid_t uid;
-	gid_t gid;
 	int ret = 0;
+	uid_t uid = 0;
+	gid_t gid = 0;
 	int i;
 
 	if(_chown_owner(owner, &uid, &gid) != 0)
 		return 2;
-	if(*prefs & PREFS_R)
+	if(*prefs & CHOWN_PREFS_R)
 	{
 		for(i = 0; i < argc; i++)
 			ret |= _chown_do_recursive(prefs, uid, gid, argv[i]);
@@ -188,7 +188,7 @@ static int _chown_do(Prefs * prefs, uid_t uid, gid_t gid, char * file)
 {
 	int res;
 
-	if((*prefs & PREFS_h) == PREFS_h)
+	if((*prefs & CHOWN_PREFS_h) == CHOWN_PREFS_h)
 		res = lchown(file, uid, gid);
 	else
 		res = chown(file, uid, gid);
@@ -212,17 +212,17 @@ static int _usage(void)
 /* main */
 int main(int argc, char * argv[])
 {
-	int o;
 	Prefs prefs = 0;
+	int o;
 
 	while((o = getopt(argc, argv, "hRHLP")) != -1)
 		switch(o)
 		{
 			case 'h':
-				prefs |= PREFS_h;
+				prefs |= CHOWN_PREFS_h;
 				break;
 			case 'R':
-				prefs |= PREFS_R;
+				prefs |= CHOWN_PREFS_R;
 				break;
 			case 'H':
 			case 'L':
@@ -234,6 +234,6 @@ int main(int argc, char * argv[])
 		}
 	if(argc - optind < 2)
 		return _usage();
-	return _chown(&prefs, argv[optind], argc-optind-1, &argv[optind+1]) == 0
-		? 0 : 2;
+	return (_chown(&prefs, argv[optind], argc - optind - 1,
+			&argv[optind + 1]) == 0) ? 0 : 2;
 }
diff --git a/src/common.c b/src/common.c
index 3fe1ae9..dccd9dd 100644
--- a/src/common.c
+++ b/src/common.c
@@ -1,5 +1,5 @@
 /* $Id$ */
-/* Copyright (c) 2007 Pierre Pronchery <khorben@defora.org> */
+/* Copyright (c) 2009 Pierre Pronchery <khorben@defora.org> */
 /* This file is part of DeforaOS Unix utils */
 /* utils is not free software; you can redistribute it and/or modify it under
  * the terms of the Creative Commons Attribution-NonCommercial-ShareAlike 3.0
@@ -28,6 +28,7 @@
  * 	1	an error happened */
 static int _mode_alpha(char const * mode, mode_t * mask);
 static int _mode_digit(char const * mode, mode_t * mask);
+
 static int _mode(char const * mode, mode_t * mask)
 	/* FIXME need a way to tell whether to =, & or | the resulting mask */
 {
@@ -41,8 +42,9 @@ static int _mode(char const * mode, mode_t * mask)
 static int _mode_digit(char const * mode, mode_t * mask)
 {
 	char const * p;
+	int i;
 
-	for(p = mode; isdigit(*p) && *p < '8'; p++);
+	for(p = mode; (i = *p) != '\0' && isdigit(i) && i < '8'; p++);
 	if(*p == '\0')
 	{
 		*mask = strtol(mode, NULL, 8);
diff --git a/src/cp.c b/src/cp.c
index b2b7eb1..9ae75a6 100644
--- a/src/cp.c
+++ b/src/cp.c
@@ -1,5 +1,5 @@
 /* $Id$ */
-/* Copyright (c) 2007 Pierre Pronchery <khorben@defora.org> */
+/* Copyright (c) 2009 Pierre Pronchery <khorben@defora.org> */
 /* This file is part of DeforaOS Unix utils */
 /* utils is not free software; you can redistribute it and/or modify it under
  * the terms of the Creative Commons Attribution-NonCommercial-ShareAlike 3.0
@@ -32,13 +32,13 @@
 
 /* types */
 typedef int Prefs;
-#define PREFS_f 0x01
-#define PREFS_i 0x02
-#define PREFS_p 0x04
-#define PREFS_R 0x08
-#define PREFS_H 0x10
-#define PREFS_L 0x20
-#define PREFS_P 0x40
+#define CP_PREFS_f 0x01
+#define CP_PREFS_i 0x02
+#define CP_PREFS_p 0x04
+#define CP_PREFS_R 0x08
+#define CP_PREFS_H 0x10
+#define CP_PREFS_L 0x20
+#define CP_PREFS_P 0x40
 
 
 /* cp */
@@ -105,7 +105,7 @@ static int _cp_single(Prefs * prefs, char const * src, char const * dst)
 	struct stat st;
 	struct stat st2;
 
-	if(*prefs & PREFS_P) /* don't follow symlinks */
+	if(*prefs & CP_PREFS_P) /* don't follow symlinks */
 	{
 		if(lstat(src, &st) != 0 && errno == ENOENT)
 			return _cp_error(src, 1);
@@ -114,7 +114,7 @@ static int _cp_single(Prefs * prefs, char const * src, char const * dst)
 		return _cp_error(src, 1);
 	if(lstat(dst, &st2) == 0)
 	{
-		if(*prefs & PREFS_i && _cp_confirm(dst) != 1)
+		if(*prefs & CP_PREFS_i && _cp_confirm(dst) != 1)
 			return 0;
 		if(unlink(dst) != 0)
 			return _cp_error(dst, 1);
@@ -129,17 +129,18 @@ static int _cp_single(Prefs * prefs, char const * src, char const * dst)
 		ret = _cp_single_regular(src, dst);
 	if(ret != 0)
 		return ret;
-	if(*prefs & PREFS_p) /* XXX TOCTOU */
+	if(*prefs & CP_PREFS_p) /* XXX TOCTOU */
 		_cp_single_p(dst, &st);
 	return 0;
 }
 
 /* single_dir */
-static int _cp_single_recurse(Prefs * prefs, char const * src, char const * dst);
+static int _cp_single_recurse(Prefs * prefs, char const * src,
+		char const * dst);
 
 static int _cp_single_dir(Prefs * prefs, char const * src, char const * dst)
 {
-	if(*prefs & PREFS_R)
+	if(*prefs & CP_PREFS_R)
 		return _cp_single_recurse(prefs, src, dst);
 	fprintf(stderr, "%s%s%s", "cp: ", src, ": Omitting directory\n");
 	return 0;
@@ -163,7 +164,7 @@ static int _cp_single_recurse(Prefs * prefs, char const * src, char const * dst)
 	dstlen = strlen(dst);
 	if((dir = opendir(src)) == NULL)
 		return _cp_error(src, 1);
-	prefs2 |= (prefs2 & PREFS_H) ? PREFS_P : 0;
+	prefs2 |= (prefs2 & CP_PREFS_H) ? CP_PREFS_P : 0;
 	while((de = readdir(dir)) != NULL)
 	{
 		if(de->d_name[0] == '.' && (de->d_name[1] == '\0'
@@ -307,45 +308,43 @@ static int _usage(void)
 /* main */
 int main(int argc, char * argv[])
 {
-	Prefs prefs;
+	Prefs prefs = CP_PREFS_i | CP_PREFS_H;
 	int o;
 
-	memset(&prefs, 0, sizeof(Prefs));
-	prefs |= PREFS_i | PREFS_H;
 	while((o = getopt(argc, argv, "fipRrHLP")) != -1)
 		switch(o)
 		{
 			case 'f':
-				prefs -= prefs & PREFS_i;
-				prefs |= PREFS_f;
+				prefs -= prefs & CP_PREFS_i;
+				prefs |= CP_PREFS_f;
 				break;
 			case 'i':
-				prefs -= prefs & PREFS_f;
-				prefs |= PREFS_i;
+				prefs -= prefs & CP_PREFS_f;
+				prefs |= CP_PREFS_i;
 				break;
 			case 'p':
-				prefs |= PREFS_p;
+				prefs |= CP_PREFS_p;
 				break;
 			case 'R':
 			case 'r':
-				prefs |= PREFS_R;
+				prefs |= CP_PREFS_R;
 				break;
 			case 'H':
-				prefs -= prefs & (PREFS_L | PREFS_P);
-				prefs |= PREFS_H;
+				prefs -= prefs & (CP_PREFS_L | CP_PREFS_P);
+				prefs |= CP_PREFS_H;
 				break;
 			case 'L':
-				prefs -= prefs & (PREFS_H | PREFS_P);
-				prefs |= PREFS_L;
+				prefs -= prefs & (CP_PREFS_H | CP_PREFS_P);
+				prefs |= CP_PREFS_L;
 				break;
 			case 'P':
-				prefs -= prefs & (PREFS_H | PREFS_L);
-				prefs |= PREFS_P;
+				prefs -= prefs & (CP_PREFS_H | CP_PREFS_L);
+				prefs |= CP_PREFS_P;
 				break;
 			default:
 				return _usage();
 		}
 	if(argc - optind < 2)
 		return _usage();
-	return _cp(&prefs, argc - optind, &argv[optind]) == 0 ? 0 : 2;
+	return (_cp(&prefs, argc - optind, &argv[optind]) == 0) ? 0 : 2;
 }
diff --git a/src/df.c b/src/df.c
index eaf083b..002ec68 100644
--- a/src/df.c
+++ b/src/df.c
@@ -1,5 +1,5 @@
 /* $Id$ */
-/* Copyright (c) 2007 Pierre Pronchery <khorben@defora.org> */
+/* Copyright (c) 2009 Pierre Pronchery <khorben@defora.org> */
 /* This file is part of DeforaOS Unix utils */
 /* utils is not free software; you can redistribute it and/or modify it under
  * the terms of the Creative Commons Attribution-NonCommercial-ShareAlike 3.0
@@ -26,8 +26,8 @@
 
 /* Prefs */
 typedef int Prefs;
-#define PREFS_k 1
-#define PREFS_P 2
+#define DF_PREFS_k 1
+#define DF_PREFS_P 2
 
 
 /* df */
@@ -39,7 +39,7 @@ static int _df(Prefs * prefs, int filec, char * filev[])
 	int ret = 0;
 	int i;
 
-	printf("%s%s%s", "Filesystem ", *prefs & PREFS_k ? "1024" : " 512",
+	printf("%s%s%s", "Filesystem ", (*prefs & DF_PREFS_k) ? "1024" : " 512",
 			"-blocks       Used  Available Capacity Mounted on\n");
 	if(filec == 0)
 		return _df_mtab(prefs);
@@ -93,7 +93,7 @@ static void _df_print(Prefs * prefs, struct statvfs const * f)
 	unsigned long long avail;
 	unsigned int cap;
 
-	mod = f->f_bsize / ((*prefs & PREFS_k) ? 8192 : 4096);
+	mod = f->f_bsize / ((*prefs & DF_PREFS_k) ? 8192 : 4096);
 	cnt = f->f_blocks * mod;
 	used = (f->f_blocks - f->f_bfree) * mod;
 	avail = f->f_bavail * mod;
@@ -130,18 +130,17 @@ static int _usage(void)
 /* main */
 int main(int argc, char * argv[])
 {
+	Prefs prefs = 0;
 	int o;
-	Prefs prefs;
 
-	memset(&prefs, 0, sizeof(prefs));
 	while((o = getopt(argc, argv, "kP")) != -1)
 		switch(o)
 		{
 			case 'k':
-				prefs |= PREFS_k;
+				prefs |= DF_PREFS_k;
 				break;
 			case 'P':
-				prefs |= PREFS_P;
+				prefs |= DF_PREFS_P;
 				break;
 			default:
 				return _usage();
diff --git a/src/du.c b/src/du.c
index 7604da4..6799019 100644
--- a/src/du.c
+++ b/src/du.c
@@ -1,5 +1,5 @@
 /* $Id$ */
-/* Copyright (c) 2007 Pierre Pronchery <khorben@defora.org> */
+/* Copyright (c) 2009 Pierre Pronchery <khorben@defora.org> */
 /* This file is part of DeforaOS Unix utils */
 /* utils is not free software; you can redistribute it and/or modify it under
  * the terms of the Creative Commons Attribution-NonCommercial-ShareAlike 3.0
@@ -27,12 +27,12 @@
 
 /* Prefs */
 typedef int Prefs;
-#define PREFS_a 1
-#define PREFS_s 2 
-#define PREFS_x 4
-#define PREFS_k 8 
-#define PREFS_H 16
-#define PREFS_L 48
+#define DU_PREFS_a 1
+#define DU_PREFS_s 2 
+#define DU_PREFS_x 4
+#define DU_PREFS_k 8 
+#define DU_PREFS_H 16
+#define DU_PREFS_L 48
 
 
 /* du */
@@ -63,10 +63,10 @@ static int _du_do_recursive(Prefs * prefs, char const * filename);
 
 static int _du_do(Prefs * prefs, char const * filename)
 {
-	int (* _stat)(const char * filename, struct stat * buf) = lstat;
+	int (*_stat)(const char * filename, struct stat * buf) = lstat;
 	struct stat st;
 
-	if(*prefs & PREFS_H)
+	if(*prefs & DU_PREFS_H)
 		_stat = stat;
 	if(_stat(filename, &st) != 0)
 		return _du_error(filename);
@@ -135,12 +135,12 @@ static int _recursive_do(Prefs * prefs, off_t * size, char ** filename)
 static off_t _du_blocks(Prefs * prefs, off_t size);
 static void _recursive_do_stat(Prefs * prefs, off_t * size, char ** filename)
 {
-	int (* _stat)(const char * filename, struct stat * buf) = lstat;
+	int (*_stat)(const char * filename, struct stat * buf) = lstat;
 	struct stat st;
 	char * p;
 	long long dirsize;
 
-	if(*prefs & PREFS_L)
+	if(*prefs & DU_PREFS_L)
 		_stat = stat;
 	if(_stat(*filename, &st) != 0)
 	{
@@ -153,21 +153,21 @@ static void _recursive_do_stat(Prefs * prefs, off_t * size, char ** filename)
 		dirsize = _du_blocks(prefs, st.st_blocks);
 		if((p = strdup(*filename)) == NULL)
 		{
-			_du_error("malloc");
+			_du_error(*filename);
 			return;
 		}
 		_recursive_do(prefs, size, filename);
-		if(!(*prefs & PREFS_s))
+		if(!(*prefs & DU_PREFS_s))
 			printf("%lld %s\n", dirsize, p);
 		free(p);
 	}
-	else if(*prefs & PREFS_a)
+	else if(*prefs & DU_PREFS_a)
 		_du_print(prefs, st.st_blocks, *filename);
 }
 
 static off_t _du_blocks(Prefs * prefs, off_t size)
 {
-	if(*prefs & PREFS_k)
+	if(*prefs & DU_PREFS_k)
 		return size / 2;
 	return size;
 }
@@ -198,32 +198,31 @@ static int _usage(void)
 /* main */
 int main(int argc, char * argv[])
 {
+	Prefs prefs = 0;
 	int o;
-	Prefs prefs;
 
-	memset(&prefs, 0, sizeof(Prefs));
 	while((o = getopt(argc, argv, "askxHL")) != -1)
 		switch(o)
 		{
 			case 'a':
-				prefs -= prefs & PREFS_s;
-				prefs |= PREFS_a;
+				prefs -= prefs & DU_PREFS_s;
+				prefs |= DU_PREFS_a;
 				break;
 			case 's':
-				prefs -= prefs & PREFS_a;
-				prefs |= PREFS_s;
+				prefs -= prefs & DU_PREFS_a;
+				prefs |= DU_PREFS_s;
 				break;
 			case 'k':
-				prefs |= PREFS_k;
+				prefs |= DU_PREFS_k;
 				break;
 			case 'x':
-				prefs |= PREFS_x;
+				prefs |= DU_PREFS_x;
 				break;
 			case 'H':
-				prefs |= PREFS_H;
+				prefs |= DU_PREFS_H;
 				break;
 			case 'L':
-				prefs |= PREFS_L;
+				prefs |= DU_PREFS_L;
 				break;
 			default:
 				return _usage();
diff --git a/src/file.c b/src/file.c
index 4a5eccb..1b775f4 100644
--- a/src/file.c
+++ b/src/file.c
@@ -1,5 +1,5 @@
 /* $Id$ */
-/* Copyright (c) 2007 Pierre Pronchery <khorben@defora.org> */
+/* Copyright (c) 2009 Pierre Pronchery <khorben@defora.org> */
 /* This file is part of DeforaOS Unix utils */
 /* utils is not free software; you can redistribute it and/or modify it under
  * the terms of the Creative Commons Attribution-NonCommercial-ShareAlike 3.0
@@ -24,15 +24,15 @@
 
 /* prefs */
 typedef int Prefs;
-#define PREFS_h	1
-#define PREFS_m	2
-#define PREFS_M	4
-#define PREFS_d	6
-#define PREFS_i	8
+#define FILE_PREFS_h	1
+#define FILE_PREFS_m	2
+#define FILE_PREFS_M	4
+#define FILE_PREFS_d	6
+#define FILE_PREFS_i	8
 
 
 /* file */
-static int _file_do(Prefs * p, char * filename);
+static int _file_do(Prefs * p, char const * filename);
 static int _file(Prefs * p, int argc, char * argv[])
 {
 	int ret = 0;
@@ -43,41 +43,40 @@ static int _file(Prefs * p, int argc, char * argv[])
 	return ret;
 }
 
-static int _file_do(Prefs * p, char * filename)
+static int _file_do(Prefs * p, char const * filename)
 {
 	struct stat st;
-	int (*statfunc)(const char *, struct stat*) = *p & PREFS_h
+	int (*statfunc)(const char *, struct stat*) = *p & FILE_PREFS_h
 		? lstat : stat;
 
 	printf("%s: ", filename);
 	if(statfunc(filename, &st) != 0)
 	{
-		printf("%s\n", "cannot open file");
+		puts("cannot open file");
 		return 0;
 	}
 	if(S_ISLNK(st.st_mode))
-		printf("%s", "symbolic link to ");
+		fputs("symbolic link to ", stdout);
 	if(S_ISBLK(st.st_mode))
-		printf("%s", "block special ");
+		fputs("block special ", stdout);
 	else if(S_ISCHR(st.st_mode))
-		printf("%s", "character special ");
+		fputs("character special ", stdout);
 	else if(S_ISDIR(st.st_mode))
-		printf("%s", "directory ");
+		fputs("directory ", stdout);
 	else if(S_ISFIFO(st.st_mode))
-		printf("%s", "fifo ");
+		fputs("fifo ", stdout);
 	else if(S_ISSOCK(st.st_mode))
-		printf("%s", "socket ");
+		fputs("socket ", stdout);
 	else
 	{
-		if(*p & PREFS_i)
-			printf("%s", "regular file ");
+		if(*p & FILE_PREFS_i)
+			fputs("regular file ", stdout);
 		else if(st.st_size == 0)
-			printf("%s", "empty ");
+			fputs("empty ", stdout);
 		if(st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))
-			printf("%s", "executable ");
+			fputs("executable ", stdout);
 	}
-	printf("%s", "data");
-	fputc('\n', stdout);
+	puts("data");
 	return 0;
 }
 
@@ -101,30 +100,30 @@ int main(int argc, char * argv[])
 		switch(o)
 		{
 			case 'd':
-				if(p & PREFS_i)
+				if(p & FILE_PREFS_i)
 					return _usage();
-				p |= PREFS_d;
+				p |= FILE_PREFS_d;
 				break;
 			case 'h':
-				p |= PREFS_h;
+				p |= FILE_PREFS_h;
 				break;
 			case 'i':
 				if(p != 0)
 					return _usage();
-				p = PREFS_i;
+				p = FILE_PREFS_i;
 				break;
 			case 'M':
-				if(p & PREFS_i)
+				if(p & FILE_PREFS_i)
 					return _usage();
-				p |= PREFS_M;
+				p |= FILE_PREFS_M;
 				break;
 			case 'm':
-				if(p & PREFS_i)
+				if(p & FILE_PREFS_i)
 					return _usage();
-				p |= PREFS_m;
+				p |= FILE_PREFS_m;
 				break;
 			default:
 				return _usage();
 		}
-	return _file(&p, argc-optind, &argv[optind]);
+	return _file(&p, argc - optind, &argv[optind]);
 }
diff --git a/src/find.c b/src/find.c
index 8ac048f..f255df7 100644
--- a/src/find.c
+++ b/src/find.c
@@ -1,5 +1,5 @@
 /* $Id$ */
-/* Copyright (c) 2007 Pierre Pronchery <khorben@defora.org> */
+/* Copyright (c) 2009 Pierre Pronchery <khorben@defora.org> */
 /* This file is part of DeforaOS Unix utils */
 /* utils is not free software; you can redistribute it and/or modify it under
  * the terms of the Creative Commons Attribution-NonCommercial-ShareAlike 3.0
@@ -33,17 +33,34 @@
 
 /* types */
 typedef int Prefs;
-#define PREFS_H 1
-#define PREFS_L 2
+#define FIND_PREFS_H 1
+#define FIND_PREFS_L 2
 
 
 /* find */
 /* types */
 typedef enum _FindCmd
 {
-	FC_INVALID = -1, FC_NAME = 0, FC_NOGROUP, FC_NOUSER, FC_XDEV, FC_PRUNE,
-	FC_PERM, FC_TYPE, FC_LINKS, FC_USER, FC_GROUP, FC_SIZE, FC_ATIME,
-	FC_CTIME, FC_MTIME, FC_EXEC, FC_OK, FC_PRINT, FC_NEWER, FC_DEPTH
+	FC_INVALID = -1,
+	FC_NAME = 0,
+	FC_NOGROUP,
+	FC_NOUSER,
+	FC_XDEV,
+	FC_PRUNE,
+	FC_PERM,
+	FC_TYPE,
+	FC_LINKS,
+	FC_USER,
+	FC_GROUP,
+	FC_SIZE,
+	FC_ATIME,
+	FC_CTIME,
+	FC_MTIME,
+	FC_EXEC,
+	FC_OK,
+	FC_PRINT,
+	FC_NEWER,
+	FC_DEPTH
 } FindCmd;
 #define FC_LAST FC_DEPTH
 
@@ -93,7 +110,7 @@ static int _find_do(Prefs * prefs, char const * pathname, int cmdc,
 
 	if(stat(pathname, &st) != 0) /* XXX TOCTOU, danger of infinite loop */
 	{
-		if(errno != ENOENT || *prefs & PREFS_L
+		if(errno != ENOENT || *prefs & FIND_PREFS_L
 				|| stat(pathname, &st) != 0)
 			return _find_error(pathname, 1);
 	}
@@ -168,7 +185,7 @@ static int _do_cmd(Prefs * prefs, char const * pathname, struct stat * st,
 					ret = 1;
 				break;
 			case FC_PRINT:
-				printf("%s\n", pathname);
+				puts(pathname);
 				break;
 			case FC_PRUNE:
 				if(S_ISDIR(st->st_mode))
@@ -201,7 +218,7 @@ static int _do_cmd(Prefs * prefs, char const * pathname, struct stat * st,
 				return _find_error(cmdv[i], 1);
 		}
 	if(ret == 0 && i == cmdc)
-		printf("%s\n", pathname);
+		puts(pathname);
 	if(S_ISDIR(st->st_mode))
 		return 0;
 	return ret;
@@ -255,12 +272,13 @@ static int _do_dir(Prefs * prefs, char const * pathname, int cmdc,
 	int ret = 0;
 	DIR * dir;
 	struct dirent * de;
-	size_t len = strlen(pathname) + 2;
+	size_t len;
 	char * path;
 	char * p;
 
 	if((dir = opendir(pathname)) == NULL)
 		return _find_error(pathname, 1);
+	len = strlen(pathname) + 2;
 	if((path = malloc(len)) == NULL)
 	{
 		closedir(dir);
@@ -301,25 +319,24 @@ static int _usage(void)
 /* main */
 int main(int argc, char * argv[])
 {
+	Prefs prefs = 0;
 	int o;
-	Prefs prefs;
 
-	memset(&prefs, 0, sizeof(prefs));
 	while((o = getopt(argc, argv, "HL")) != -1)
 		switch(o)
 		{
 			case 'H':
-				prefs &= ~PREFS_L;
-				prefs |= PREFS_H;
+				prefs &= ~FIND_PREFS_L;
+				prefs |= FIND_PREFS_H;
 				break;
 			case 'L':
-				prefs &= ~PREFS_H;
-				prefs |= PREFS_L;
+				prefs &= ~FIND_PREFS_H;
+				prefs |= FIND_PREFS_L;
 				break;
 			default:
 				return _usage();
 		}
 	if(argc - optind == 0)
 		return _usage();
-	return _find(&prefs, argc - optind, &argv[optind]) == 0 ? 0 : 2;
+	return (_find(&prefs, argc - optind, &argv[optind]) == 0) ? 0 : 2;
 }
diff --git a/src/locale.c b/src/locale.c
index 9d43804..b0a2dde 100644
--- a/src/locale.c
+++ b/src/locale.c
@@ -1,5 +1,5 @@
 /* $Id$ */
-/* Copyright (c) 2007 Pierre Pronchery <khorben@defora.org> */
+/* Copyright (c) 2009 Pierre Pronchery <khorben@defora.org> */
 /* This file is part of DeforaOS Unix utils */
 /* utils is not free software; you can redistribute it and/or modify it under
  * the terms of the Creative Commons Attribution-NonCommercial-ShareAlike 3.0
@@ -23,25 +23,26 @@
 
 /* prefs */
 typedef int Prefs;
-#define PREFS_a 0x1
-#define PREFS_m 0x2
-#define PREFS_c 0x4
-#define PREFS_k 0x8
+#define LOCALE_PREFS_a 0x1
+#define LOCALE_PREFS_m 0x2
+#define LOCALE_PREFS_c 0x4
+#define LOCALE_PREFS_k 0x8
 
 
 /* locale */
 static int _locale_locales(void);
 static int _locale_charsets(void);
 static int _locale_default(void);
-static int _locale_do(Prefs * p, char * locale);
+static int _locale_do(Prefs * p, char const * locale);
+
 static int _locale(Prefs * p, int argc, char * argv[])
 {
 	int ret = 0;
 	int i;
 
-	if(*p & PREFS_a)
+	if(*p & LOCALE_PREFS_a)
 		return _locale_locales();
-	if(*p & PREFS_m)
+	if(*p & LOCALE_PREFS_m)
 		return _locale_charsets();
 	if(*p == 0 && argc == 0)
 		return _locale_default() ? 2 : 0;
@@ -52,13 +53,13 @@ static int _locale(Prefs * p, int argc, char * argv[])
 
 static int _locale_locales(void)
 {
-	printf("%s", "C\nPOSIX\n");
+	puts("C\nPOSIX");
 	return 0;
 }
 
 static int _locale_charsets(void)
 {
-	printf("%s", "ISO_10646\n");
+	puts("ISO_10646");
 	return 0;
 }
 
@@ -72,9 +73,9 @@ static int _locale_default(void)
 	{
 		printf("%s=", *p);
 		if((e = getenv(*p)) == NULL)
-			printf("\"\"\n");
+			puts("\"\"");
 		else
-			printf("%s\n", e);
+			puts(e);
 	}
 	if((e = getenv("LC_ALL")) == NULL)
 		e = "";
@@ -82,9 +83,9 @@ static int _locale_default(void)
 	return 0;
 }
 
-static int _locale_do(Prefs * p, char * locale)
+static int _locale_do(Prefs * p, char const * locale)
 {
-	/* FIXME */
+	/* FIXME implement */
 	return 0;
 }
 
@@ -108,23 +109,25 @@ int main(int argc, char * argv[])
 		switch(o)
 		{
 			case 'a':
-				p -= (p & (PREFS_m | PREFS_c | PREFS_k));
-				p |= PREFS_a;
+				p -= (p & (LOCALE_PREFS_m | LOCALE_PREFS_c
+							| LOCALE_PREFS_k));
+				p |= LOCALE_PREFS_a;
 				break;
 			case 'm':
-				p -= (p & (PREFS_a | PREFS_c | PREFS_k));
-				p |= PREFS_m;
+				p -= (p & (LOCALE_PREFS_a | LOCALE_PREFS_c
+							| LOCALE_PREFS_k));
+				p |= LOCALE_PREFS_m;
 				break;
 			case 'c':
-				p -= (p & (PREFS_a | PREFS_m));
-				p |= PREFS_c;
+				p -= (p & (LOCALE_PREFS_a | LOCALE_PREFS_m));
+				p |= LOCALE_PREFS_c;
 				break;
 			case 'k':
-				p -= (p & (PREFS_a | PREFS_m));
-				p |= PREFS_k;
+				p -= (p & (LOCALE_PREFS_a | LOCALE_PREFS_m));
+				p |= LOCALE_PREFS_k;
 				break;
 			default:
 				return _usage();
 		}
-	return _locale(&p, argc-optind, &argv[optind]);
+	return _locale(&p, argc - optind, &argv[optind]);
 }
diff --git a/src/ls.c b/src/ls.c
index 6f5886b..5ecef1a 100644
--- a/src/ls.c
+++ b/src/ls.c
@@ -34,18 +34,18 @@
 
 /* Prefs */
 typedef int Prefs;
-#define PREFS_C 00001
-#define PREFS_F 00002
-#define PREFS_R 00004
-#define PREFS_a 00010
-#define PREFS_c 00020
-#define PREFS_d 00040
-#define PREFS_l 00100
-#define PREFS_t 00200
-#define PREFS_u 00400
-#define PREFS_1 01000
-#define PREFS_H 02000
-#define PREFS_L 04000
+#define LS_PREFS_C 00001
+#define LS_PREFS_F 00002
+#define LS_PREFS_R 00004
+#define LS_PREFS_a 00010
+#define LS_PREFS_c 00020
+#define LS_PREFS_d 00040
+#define LS_PREFS_l 00100
+#define LS_PREFS_t 00200
+#define LS_PREFS_u 00400
+#define LS_PREFS_1 01000
+#define LS_PREFS_H 02000
+#define LS_PREFS_L 04000
 
 static int _prefs_parse(Prefs * prefs, int argc, char * argv[])
 {
@@ -56,45 +56,45 @@ static int _prefs_parse(Prefs * prefs, int argc, char * argv[])
 		switch(o)
 		{
 			case 'C':
-				*prefs -= *prefs & PREFS_1;
-				*prefs |= PREFS_C;
+				*prefs -= *prefs & LS_PREFS_1;
+				*prefs |= LS_PREFS_C;
 				break;
 			case 'F':
-				*prefs |= PREFS_F;
+				*prefs |= LS_PREFS_F;
 				break;
 			case 'R':
-				*prefs |= PREFS_R;
+				*prefs |= LS_PREFS_R;
 				break;
 			case 'a':
-				*prefs |= PREFS_a;
+				*prefs |= LS_PREFS_a;
 				break;
 			case 'c':
-				*prefs -= *prefs & PREFS_u;
-				*prefs |= PREFS_c;
+				*prefs -= *prefs & LS_PREFS_u;
+				*prefs |= LS_PREFS_c;
 				break;
 			case 'd':
-				*prefs |= PREFS_d;
+				*prefs |= LS_PREFS_d;
 				break;
 			case 'l':
-				*prefs |= PREFS_l;
+				*prefs |= LS_PREFS_l;
 				break;
 			case 't':
-				*prefs |= PREFS_t;
+				*prefs |= LS_PREFS_t;
 				break;
 			case 'u':
-				*prefs -= *prefs & PREFS_c;
-				*prefs |= PREFS_u;
+				*prefs -= *prefs & LS_PREFS_c;
+				*prefs |= LS_PREFS_u;
 				break;
 			case '1':
-				*prefs |= PREFS_1;
+				*prefs |= LS_PREFS_1;
 				break;
 			case 'H':
-				*prefs -= *prefs & PREFS_L;
-				*prefs |= PREFS_H;
+				*prefs -= *prefs & LS_PREFS_L;
+				*prefs |= LS_PREFS_H;
 				break;
 			case 'L':
-				*prefs -= *prefs & PREFS_H;
-				*prefs |= PREFS_L;
+				*prefs -= *prefs & LS_PREFS_H;
+				*prefs |= LS_PREFS_L;
 				break;
 			default:
 				return 1;
@@ -225,7 +225,7 @@ static int _ls(int argc, char * argv[], Prefs * prefs)
 	int isdir;
 	char * str;
 
-	if(argc == 0 && !(*prefs & PREFS_d))
+	if(argc == 0 && !(*prefs & LS_PREFS_d))
 		return _ls_directory_do(prefs, ".");
 	if(_ls_args(&files, &dirs) != 0)
 		return 2;
@@ -237,7 +237,7 @@ static int _ls(int argc, char * argv[], Prefs * prefs)
 			ret |= 1;
 		else if((str = strdup(argv[i])) == NULL)
 			ret |= _ls_error("malloc", 1);
-		else if(*prefs & PREFS_d)
+		else if(*prefs & LS_PREFS_d)
 			ret |= slist_insert_sorted(files, str, cmp);
 		else
 			ret |= slist_insert_sorted(isdir ? dirs : files, str,
@@ -258,9 +258,9 @@ static int _acccmp(char * a, char * b);
 static int _modcmp(char * a, char * b);
 static compare_func _ls_compare(Prefs * prefs)
 {
-	if(!(*prefs & PREFS_t))
+	if(!(*prefs & LS_PREFS_t))
 		return (compare_func)strcmp;
-	if(*prefs & PREFS_u)
+	if(*prefs & LS_PREFS_u)
 		return (compare_func)_acccmp;
 	return (compare_func)_modcmp;
 }
@@ -305,7 +305,7 @@ static int _ls_directory_do(Prefs * prefs, char const * directory)
 	_ls_args(&files, &dirs);
 	for(; (de = readdir(dir)) != NULL; pos++)
 	{
-		if(*(de->d_name) == '.' && !(*prefs & PREFS_a))
+		if(*(de->d_name) == '.' && !(*prefs & LS_PREFS_a))
 			continue;
 		slist_insert_sorted(files, strdup(de->d_name), cmp);
 		if(pos <= 2)
@@ -318,7 +318,7 @@ static int _ls_directory_do(Prefs * prefs, char const * directory)
 		}
 		file = p;
 		sprintf(file, "%s/%s", directory, de->d_name);
-		if((*prefs & PREFS_R) && _is_directory(prefs, file) == 1)
+		if((*prefs & LS_PREFS_R) && _is_directory(prefs, file) == 1)
 			slist_insert_sorted(dirs, strdup(file), cmp);
 	}
 	free(file);
@@ -345,7 +345,7 @@ static int _is_directory(Prefs * prefs, char const * filename)
 	int (*_stat)(const char * filename, struct stat * buf) = lstat;
 	struct stat st;
 
-	if(*prefs & PREFS_H || *prefs & PREFS_L)
+	if(*prefs & LS_PREFS_H || *prefs & LS_PREFS_L)
 		_stat = stat;
 	if((_stat(filename, &st)) != 0)
 		return _ls_error(filename, 2);
@@ -378,7 +378,7 @@ static int _ls_do_files(Prefs * prefs, char const * directory, SList * files)
 {
 	int res = 0;
 
-	if(*prefs & PREFS_l)
+	if(*prefs & LS_PREFS_l)
 		res = _ls_do_files_long(prefs, directory, files);
 	else
 		res = _ls_do_files_short(prefs, directory, files);
@@ -403,7 +403,7 @@ static int _ls_do_files_short(Prefs * prefs, char const * directory,
 	char c;
 	SList cur;
 
-	if(((*prefs & PREFS_1) == 0) && (cols = getenv("COLUMNS")) != NULL
+	if(((*prefs & LS_PREFS_1) == 0) && (cols = getenv("COLUMNS")) != NULL
 			&& *cols != '\0' && (len = strtol(cols, &p, 10)) > 0
 			&& *p == '\0')
 	{
@@ -412,7 +412,7 @@ static int _ls_do_files_short(Prefs * prefs, char const * directory,
 			lencur = strlen(slist_data(&cur));
 			lenmax = max(lenmax, lencur);
 		}
-		if(*prefs & PREFS_F)
+		if(*prefs & LS_PREFS_F)
 			lenmax++;
 		if(lenmax > 0)
 			colnb = len / ++lenmax;
@@ -422,7 +422,7 @@ static int _ls_do_files_short(Prefs * prefs, char const * directory,
 		p = slist_data(&cur);
 		j = strlen(p);
 		fwrite(p, sizeof(char), j, stdout);
-		if((*prefs & PREFS_F)
+		if((*prefs & LS_PREFS_F)
 				&& (c = _short_file_mode(prefs, directory, p)))
 		{
 			fputc(c, stdout);
@@ -450,7 +450,7 @@ static char _short_file_mode(Prefs * prefs, char const * directory,
 	struct stat st;
 	char * p;
 
-	if(*prefs & PREFS_H || *prefs & PREFS_L)
+	if(*prefs & LS_PREFS_H || *prefs & LS_PREFS_L)
 		_stat = stat;
 	if(directory == NULL)
 	{
@@ -484,7 +484,7 @@ static int _ls_do_files_long(Prefs * prefs, char const * directory,
 	int (* _stat)(const char * filename, struct stat * buf) = lstat;
 	struct stat st;
 
-	if(*prefs & PREFS_H || *prefs & PREFS_L)
+	if(*prefs & LS_PREFS_H || *prefs & LS_PREFS_L)
 		_stat = stat;
 	for(cur = *files; cur != NULL; slist_next(&cur))
 	{
@@ -529,17 +529,18 @@ static void _long_print(Prefs * prefs, char const * filename,
 	_long_mode(mode, st->st_mode);
 	owner = _long_owner(st->st_uid);
 	group = _long_group(st->st_gid);
-	if(*prefs & PREFS_u)
+	if(*prefs & LS_PREFS_u)
 		date = _long_date(st->st_atime);
-	else if(*prefs & PREFS_c)
+	else if(*prefs & LS_PREFS_c)
 		date = _long_date(st->st_ctime);
 	else
 		date = _long_date(st->st_mtime);
 	printf("%s %2u %-7s %-7s %6u %s %s", mode, (unsigned)st->st_nlink,
 			owner, group, (unsigned)st->st_size, date, basename);
-	if(S_ISLNK(st->st_mode) && !(*prefs & PREFS_L)) /* FIXME not in POSIX? */
+	if(S_ISLNK(st->st_mode) && !(*prefs & LS_PREFS_L))
+		/* FIXME not in POSIX? */
 		_print_link(filename);
-	else if(*prefs & PREFS_F)
+	else if(*prefs & LS_PREFS_F)
 		fputc(_file_mode_letter(st->st_mode), stdout);
 	fputc('\n', stdout);
 }
diff --git a/src/mv.c b/src/mv.c
index 6fad30e..b563d7b 100644
--- a/src/mv.c
+++ b/src/mv.c
@@ -1,5 +1,5 @@
 /* $Id$ */
-/* Copyright (c) 2007 Pierre Pronchery <khorben@defora.org> */
+/* Copyright (c) 2009 Pierre Pronchery <khorben@defora.org> */
 /* This file is part of DeforaOS Unix utils */
 /* utils is not free software; you can redistribute it and/or modify it under
  * the terms of the Creative Commons Attribution-NonCommercial-ShareAlike 3.0
@@ -31,8 +31,8 @@
 
 /* types */
 typedef int Prefs;
-#define PREFS_f 0x1
-#define PREFS_i 0x2
+#define MV_PREFS_f 0x1
+#define MV_PREFS_i 0x2
 
 
 /* mv */
@@ -99,16 +99,14 @@ static int _mv_single(Prefs * prefs, char const * src, char const * dst)
 
 	if(lstat(src, &st) != 0 && errno == ENOENT) /* XXX TOCTOU */
 		return _mv_error(src, 1);
-	if(*prefs & PREFS_i
-			&& (lstat(dst, &st) == 0 || errno != ENOENT)
+	if(*prefs & MV_PREFS_i && (lstat(dst, &st) == 0 || errno != ENOENT)
 			&& _mv_confirm(dst) != 1)
 		return 0;
 	if(rename(src, dst) == 0)
 		return 0;
 	if(errno != EXDEV)
 		return _mv_error(src, 1);
-	if(unlink(dst) != 0
-			&& errno != ENOENT)
+	if(unlink(dst) != 0 && errno != ENOENT)
 		return _mv_error(dst, 1);
 	if(lstat(src, &st) != 0)
 		return _mv_error(dst, 1);
@@ -320,25 +318,23 @@ static int _usage(void)
 int main(int argc, char * argv[])
 {
 	int o;
-	Prefs prefs;
+	Prefs prefs = MV_PREFS_f;
 
-	memset(&prefs, 0, sizeof(Prefs));
-	prefs |= PREFS_f;
 	while((o = getopt(argc, argv, "fi")) != -1)
 		switch(o)
 		{
 			case 'f':
-				prefs -= prefs & PREFS_i;
-				prefs |= PREFS_f;
+				prefs -= prefs & MV_PREFS_i;
+				prefs |= MV_PREFS_f;
 				break;
 			case 'i':
-				prefs -= prefs & PREFS_f;
-				prefs |= PREFS_i;
+				prefs -= prefs & MV_PREFS_f;
+				prefs |= MV_PREFS_i;
 				break;
 			default:
 				return _usage();
 		}
 	if(argc - optind < 2)
 		return _usage();
-	return _mv(&prefs, argc - optind, &argv[optind]) == 0 ? 0 : 2;
+	return (_mv(&prefs, argc - optind, &argv[optind]) == 0) ? 0 : 2;
 }
diff --git a/src/pr.c b/src/pr.c
index 8d88ba5..3fcc78d 100644
--- a/src/pr.c
+++ b/src/pr.c
@@ -1,5 +1,5 @@
 /* $Id$ */
-/* Copyright (c) 2007 Pierre Pronchery <khorben@defora.org> */
+/* Copyright (c) 2009 Pierre Pronchery <khorben@defora.org> */
 /* This file is part of DeforaOS Unix utils */
 /* utils is not free software; you can redistribute it and/or modify it under
  * the terms of the Creative Commons Attribution-NonCommercial-ShareAlike 3.0
@@ -34,10 +34,10 @@ typedef struct _Prefs
 	int width;
 	int offset;
 } Prefs;
-#define PREFS_d 1
-#define PREFS_F 2
-#define PREFS_n 4
-#define PREFS_t 8
+#define PR_PREFS_d 1
+#define PR_PREFS_F 2
+#define PR_PREFS_n 4
+#define PR_PREFS_t 8
 
 /* functions */
 static int _pr_error(char const * message, int ret);
@@ -98,13 +98,13 @@ static int _pr_do(Prefs * prefs, FILE * fp, char const * filename)
 		return _pr_error("malloc", 1);
 	while(fgets(buf, prefs->width, fp) != NULL)
 	{
-		if(nb == 0 && !(prefs->flags & PREFS_t) && prefs->lines > 10)
+		if(nb == 0 && !(prefs->flags & PR_PREFS_t) && prefs->lines > 10)
 		{
 			_do_header(prefs, mtime, filename, page++);
 			nb = 10;
 		}
 		_do_offset(prefs->offset); /* FIXME not if truncated line */
-		if(prefs->flags & PREFS_n)
+		if(prefs->flags & PR_PREFS_n)
 			printf("%5lu ", line);
 		if((len = strlen(buf)) > 0)
 		{
@@ -113,7 +113,7 @@ static int _pr_do(Prefs * prefs, FILE * fp, char const * filename)
 			else
 			{
 				line++;
-				if(prefs->flags & PREFS_d)
+				if(prefs->flags & PR_PREFS_d)
 					buf[len++] = '\n';
 			}
 		}
@@ -123,13 +123,13 @@ static int _pr_do(Prefs * prefs, FILE * fp, char const * filename)
 			return _pr_error("stdout", 1);
 		}
 		if(nb++ == prefs->lines && prefs->lines > 10
-				&& !(prefs->flags & PREFS_t))
+				&& !(prefs->flags & PR_PREFS_t))
 		{
 			_do_footer(prefs);
 			nb = 0;
 		}
 	}
-	if(prefs->lines > 10 && !(prefs->flags & PREFS_t))
+	if(prefs->lines > 10 && !(prefs->flags & PR_PREFS_t))
 		for(; nb != prefs->lines; nb++)
 			fputc('\n', stdout);
 	free(buf);
@@ -180,7 +180,7 @@ static void _do_footer(Prefs * prefs)
 {
 	int i;
 
-	if(prefs->flags & PREFS_F)
+	if(prefs->flags & PR_PREFS_F)
 	{
 		_do_offset(prefs->offset);
 		fputc('\f', stdout);
@@ -222,10 +222,10 @@ int main(int argc, char * argv[])
 		switch(o)
 		{
 			case 'd':
-				prefs.flags |= PREFS_d;
+				prefs.flags |= PR_PREFS_d;
 				break;
 			case 'F':
-				prefs.flags |= PREFS_F;
+				prefs.flags |= PR_PREFS_F;
 				break;
 			case 'h':
 				prefs.header = optarg;
@@ -237,7 +237,7 @@ int main(int argc, char * argv[])
 					return _usage();
 				break;
 			case 'n':
-				prefs.flags |= PREFS_n;
+				prefs.flags |= PR_PREFS_n;
 				break;
 			case 'o':
 				prefs.offset = strtol(optarg, &p, 10);
@@ -246,7 +246,7 @@ int main(int argc, char * argv[])
 					return _usage();
 				break;
 			case 't':
-				prefs.flags |= PREFS_t;
+				prefs.flags |= PR_PREFS_t;
 				break;
 			case 'w':
 				prefs.width = strtol(optarg, &p, 10);
diff --git a/src/rm.c b/src/rm.c
index 736ae7b..b2b0cc1 100644
--- a/src/rm.c
+++ b/src/rm.c
@@ -1,5 +1,5 @@
 /* $Id$ */
-/* Copyright (c) 2007 Pierre Pronchery <khorben@defora.org> */
+/* Copyright (c) 2009 Pierre Pronchery <khorben@defora.org> */
 /* This file is part of DeforaOS Unix utils */
 /* utils is not free software; you can redistribute it and/or modify it under
  * the terms of the Creative Commons Attribution-NonCommercial-ShareAlike 3.0
@@ -28,25 +28,26 @@
 
 /* types */
 typedef int Prefs;
-#define PREFS_f 0x1
-#define PREFS_i 0x2
-#define PREFS_R 0x4
+#define RM_PREFS_f 0x1
+#define RM_PREFS_i 0x2
+#define RM_PREFS_R 0x4
 
 
 /* rm */
-static int _rm_error(char * message, int ret);
+static int _rm_error(char const * message, int ret);
+
 static int _rm_do(Prefs * prefs, char * file);
 static int _rm(Prefs * prefs, int argc, char * argv[])
 {
-	int i;
 	int ret = 0;
+	int i;
 
 	for(i = 0; i < argc; i++)
 		ret |= _rm_do(prefs, argv[i]);
 	return ret;
 }
 
-static int _rm_error(char * message, int ret)
+static int _rm_error(char const * message, int ret)
 {
 	fputs("rm: ", stderr);
 	perror(message);
@@ -72,21 +73,21 @@ static int _rm_do(Prefs * prefs, char * file)
 
 	if(lstat(file, &st) != 0 && errno == ENOENT)
 	{
-		if(!(*prefs & PREFS_f))
+		if(!(*prefs & RM_PREFS_f))
 			return _rm_error(file, 1);
 		return 0;
 	}
 	if(S_ISDIR(st.st_mode))
 	{
-		if(!(*prefs & PREFS_R))
+		if(!(*prefs & RM_PREFS_R))
 		{
 			errno = EISDIR;
-			return _rm_error(file, *prefs & PREFS_f ? 0 : 1);
+			return _rm_error(file, *prefs & RM_PREFS_f ? 0 : 1);
 		}
 		return _rm_do_recursive(prefs, file);
 	}
 	/* FIXME ask also if permissions do not allow file removal */
-	if(*prefs & PREFS_i && !_rm_confirm(file, "file"))
+	if(*prefs & RM_PREFS_i && !_rm_confirm(file, "file"))
 		return 0;
 	if(unlink(file) != 0)
 		return _rm_error(file, 1);
@@ -126,7 +127,7 @@ static int _rm_do_recursive(Prefs * prefs, char * filename)
 	closedir(dir);
 	if(de != NULL)
 		return _rm_error(filename, 1);
-	if(*prefs & PREFS_i && !_rm_confirm(filename, "directory"))
+	if(*prefs & RM_PREFS_i && !_rm_confirm(filename, "directory"))
 		return ret;
 	if(rmdir(filename) != 0)
 		return _rm_error(filename, 1);
@@ -149,24 +150,23 @@ static int _usage(void)
 /* main */
 int main(int argc, char * argv[])
 {
-	Prefs prefs;
+	Prefs prefs = 0;
 	int o;
 
-	memset(&prefs, 0, sizeof(Prefs));
 	while((o = getopt(argc, argv, "fiRr")) != -1)
 		switch(o)
 		{
 			case 'f':
-				prefs -= prefs & PREFS_i;
-				prefs |= PREFS_f;
+				prefs -= prefs & RM_PREFS_i;
+				prefs |= RM_PREFS_f;
 				break;
 			case 'i':
-				prefs -= prefs & PREFS_f;
-				prefs |= PREFS_i;
+				prefs -= prefs & RM_PREFS_f;
+				prefs |= RM_PREFS_i;
 				break;
 			case 'R':
 			case 'r':
-				prefs |= PREFS_R;
+				prefs |= RM_PREFS_R;
 				break;
 			default:
 				return _usage();
diff --git a/src/touch.c b/src/touch.c
index a103086..44f2907 100644
--- a/src/touch.c
+++ b/src/touch.c
@@ -28,11 +28,11 @@
 
 
 /* Prefs */
-#define PREFS_a 1
-#define PREFS_m 2
-#define PREFS_c 4
-#define PREFS_r 8
-#define PREFS_t 16
+#define TOUCH_PREFS_a 1
+#define TOUCH_PREFS_m 2
+#define TOUCH_PREFS_c 4
+#define TOUCH_PREFS_r 8
+#define TOUCH_PREFS_t 16
 typedef struct _Prefs
 {
 	int flags;
@@ -50,30 +50,30 @@ static int _prefs_parse(Prefs * prefs, int argc, char * argv[])
 		switch(o)
 		{
 			case 'a':
-				prefs->flags |= PREFS_a;
+				prefs->flags |= TOUCH_PREFS_a;
 				break;
 			case 'c':
-				prefs->flags |= PREFS_c;
+				prefs->flags |= TOUCH_PREFS_c;
 				break;
 			case 'm':
-				prefs->flags |= PREFS_m;
+				prefs->flags |= TOUCH_PREFS_m;
 				break;
 			case 'r':
-				prefs->flags -= prefs->flags & PREFS_t;
-				prefs->flags |= PREFS_r;
+				prefs->flags -= prefs->flags & TOUCH_PREFS_t;
+				prefs->flags |= TOUCH_PREFS_r;
 				prefs->rtime = optarg;
 				break;
 			case 't':
-				prefs->flags -= prefs->flags & PREFS_r;
-				prefs->flags |= PREFS_t;
+				prefs->flags -= prefs->flags & TOUCH_PREFS_r;
+				prefs->flags |= TOUCH_PREFS_t;
 				if(!_prefs_ttime(optarg, &prefs->ttime))
 					return 1;
 				break;
 			default:
 				return 1;
 		}
-	if(!((prefs->flags & PREFS_a) && (prefs->flags & PREFS_m)))
-		prefs->flags |= (PREFS_a | PREFS_m);
+	if(!((prefs->flags & TOUCH_PREFS_a) && (prefs->flags & TOUCH_PREFS_m)))
+		prefs->flags |= (TOUCH_PREFS_a | TOUCH_PREFS_m);
 	return 0;
 }
 
@@ -220,12 +220,12 @@ static int _touch(Prefs * prefs, int argc, char * argv[])
 	time_t mtime = prefs->ttime;
 	int i;
 
-	if(prefs->flags & PREFS_r)
+	if(prefs->flags & TOUCH_PREFS_r)
 	{
 		if(_touch_rtime(prefs->rtime, &atime, &mtime) != 0)
 			return 1;
 	}
-	else if(!(prefs->flags & PREFS_t))
+	else if(!(prefs->flags & TOUCH_PREFS_t))
 	{
 		atime = time(NULL);
 		mtime = atime;
@@ -264,17 +264,17 @@ static int _touch_do(Prefs * prefs, char const * filename, time_t atime,
 	fprintf(stderr, "%s%d%s%s%s%ld%s%ld%s", "_touch_do(", prefs->flags,
 			", ", filename, ", ", atime, ", ", mtime, ");\n");
 #endif
-	if(!(prefs->flags & PREFS_c))
+	if(!(prefs->flags & TOUCH_PREFS_c))
 	{
 		if((fd = open(filename, O_CREAT, 0666) == -1))
 			_touch_error(filename, 0);
 		else if(close(fd) != 0)
 			_touch_error(filename, 0);
 	}
-	if(prefs->flags == PREFS_m || prefs->flags == PREFS_a)
+	if(prefs->flags == TOUCH_PREFS_m || prefs->flags == TOUCH_PREFS_a)
 		if(stat(filename, &st) != 0)
 		{
-			if(prefs->flags == PREFS_m)
+			if(prefs->flags == TOUCH_PREFS_m)
 				atime = st.st_atime;
 			else
 				mtime = st.st_mtime;
@@ -283,7 +283,7 @@ static int _touch_do(Prefs * prefs, char const * filename, time_t atime,
 	ut.modtime = mtime;
 	if(utime(filename, &ut) != 0)
 	{
-		if((prefs->flags & PREFS_c) && errno == ENOENT)
+		if((prefs->flags & TOUCH_PREFS_c) && errno == ENOENT)
 			return 0;
 		return _touch_error(filename, 1);
 	}
diff --git a/src/uniq.c b/src/uniq.c
index dd1e522..a1d4198 100644
--- a/src/uniq.c
+++ b/src/uniq.c
@@ -22,9 +22,11 @@
 #include <string.h>
 
 
-#define OPTS_c 1
-#define OPTS_d 2
-#define OPTS_u 4
+/* types */
+typedef int Prefs;
+#define UNIQ_PREFS_c 1
+#define UNIQ_PREFS_d 2
+#define UNIQ_PREFS_u 4
 
 
 /* uniq */
@@ -33,10 +35,10 @@
  * 	0	success
  * 	else	error(s) occured */
 static int _uniq_error(char const * message, int ret);
-static int _uniq_do(int opts, char const * fields, unsigned int skip,
+static int _uniq_do(Prefs prefs, char const * fields, unsigned int skip,
 		FILE * infp, FILE * outfp);
 
-static int _uniq(int opts, char const * fields, unsigned int skip,
+static int _uniq(Prefs prefs, char const * fields, unsigned int skip,
 		char const * in, char const * out)
 {
 	FILE * infp = stdin;
@@ -50,7 +52,7 @@ static int _uniq(int opts, char const * fields, unsigned int skip,
 		fclose(infp);
 		return _uniq_error(out, 1);
 	}
-	ret = _uniq_do(opts, fields, skip, infp, outfp);
+	ret = _uniq_do(prefs, fields, skip, infp, outfp);
 	if(in != NULL)
 	{
 		if(fclose(infp) != 0)
@@ -68,8 +70,8 @@ static int _uniq_error(char const * message, int ret)
 	return ret;
 }
 
-static void _do_count(int opts, unsigned int skip, char * line, FILE * fp);
-static int _uniq_do(int opts, char const * fields, unsigned int skip,
+static void _do_count(Prefs prefs, unsigned int skip, char * line, FILE * fp);
+static int _uniq_do(Prefs prefs, char const * fields, unsigned int skip,
 		FILE * infp, FILE * outfp)
 {
 	int ret = 0;
@@ -102,16 +104,16 @@ static int _uniq_do(int opts, char const * fields, unsigned int skip,
 #ifdef DEBUG
 		fprintf(stderr, "%s%s%s", "DEBUG: Got line \"", line, "\"\n");
 #endif
-		_do_count(opts, skip, line, outfp);
+		_do_count(prefs, skip, line, outfp);
 		line = NULL;
 		len = 0;
 	}
-	_do_count(opts, skip, NULL, outfp);
+	_do_count(prefs, skip, NULL, outfp);
 	return ret;
 }
 
 static int _count_repeated(char * lastline, char * line, unsigned int skip);
-static void _do_count(int opts, unsigned int skip, char * line, FILE * fp)
+static void _do_count(Prefs prefs, unsigned int skip, char * line, FILE * fp)
 {
 	static char * lastline = NULL;
 	static unsigned int cnt = 1;
@@ -128,11 +130,12 @@ static void _do_count(int opts, unsigned int skip, char * line, FILE * fp)
 		cnt++;
 		return;
 	}
-	if(cnt == 1 && !(opts & OPTS_d)) /* line is not repeated */
-		fprintf(fp, "%s%s\n", opts & OPTS_c ? "1 " : "", lastline);
-	else if(cnt > 1 && !(opts & OPTS_u)) /* line is repeated */
+	if(cnt == 1 && !(prefs & UNIQ_PREFS_d)) /* line is not repeated */
+		fprintf(fp, "%s%s\n", prefs & UNIQ_PREFS_c ? "1 " : "",
+				lastline);
+	else if(cnt > 1 && !(prefs & UNIQ_PREFS_u)) /* line is repeated */
 	{
-		if(opts & OPTS_c)
+		if(prefs & UNIQ_PREFS_c)
 			fprintf(fp, "%d ", cnt);
 		fprintf(fp, "%s\n", lastline);
 	}
@@ -171,7 +174,7 @@ static int _usage(void)
 /* main */
 int main(int argc, char * argv[])
 {
-	int opts = 0;
+	Prefs prefs = 0;
 	char * fields = NULL;
 	int skip = 0;
 	char * p;
@@ -183,10 +186,10 @@ int main(int argc, char * argv[])
 		switch(o)
 		{
 			case 'c':
-				opts |= OPTS_c;
+				prefs |= UNIQ_PREFS_c;
 				break;
 			case 'd':
-				opts |= OPTS_d;
+				prefs |= UNIQ_PREFS_d;
 				break;
 			case 's':
 				skip = strtol(optarg, &p, 10);
@@ -194,7 +197,7 @@ int main(int argc, char * argv[])
 					return _usage();
 				break;
 			case 'u':
-				opts |= OPTS_u;
+				prefs |= UNIQ_PREFS_u;
 				break;
 			case 'f':
 				/* FIXME */
@@ -209,5 +212,5 @@ int main(int argc, char * argv[])
 		else if(argc - optind > 2)
 			return _usage();
 	}
-	return (_uniq(opts, fields, skip, in, out) == 0) ? 0 : 2;
+	return (_uniq(prefs, fields, skip, in, out) == 0) ? 0 : 2;
 }