diff --git a/src/Makefile b/src/Makefile
index 1a4089b..f293916 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -3,6 +3,7 @@ PREFIX	= /usr/local
 DESTDIR	= 
 BINDIR	= $(PREFIX)/bin
 CC	= cc
+CPPFLAGSF=
 CPPFLAGS=
 CFLAGSF	= -W
 CFLAGS	= -Wall -g -O2 -ansi
@@ -14,277 +15,277 @@ INSTALL	= install
 all: $(TARGETS)
 
 basename_OBJS = basename.o
-basename_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+basename_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 basename: $(basename_OBJS)
 	$(CC) -o basename $(basename_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 cat_OBJS = cat.o
-cat_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+cat_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 cat: $(cat_OBJS)
 	$(CC) -o cat $(cat_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 chgrp_OBJS = chgrp.o
-chgrp_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+chgrp_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 chgrp: $(chgrp_OBJS)
 	$(CC) -o chgrp $(chgrp_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 chmod_OBJS = chmod.o
-chmod_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+chmod_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 chmod: $(chmod_OBJS) common.c
 	$(CC) -o chmod $(chmod_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 chown_OBJS = chown.o
-chown_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+chown_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 chown: $(chown_OBJS)
 	$(CC) -o chown $(chown_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 cksum_OBJS = cksum.o
-cksum_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+cksum_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 cksum: $(cksum_OBJS)
 	$(CC) -o cksum $(cksum_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 cmp_OBJS = cmp.o
-cmp_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+cmp_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 cmp: $(cmp_OBJS)
 	$(CC) -o cmp $(cmp_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 cp_OBJS = cp.o
-cp_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+cp_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 cp: $(cp_OBJS)
 	$(CC) -o cp $(cp_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 df_OBJS = df.o
-df_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+df_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 df: $(df_OBJS)
 	$(CC) -o df $(df_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 dirname_OBJS = dirname.o
-dirname_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+dirname_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 dirname: $(dirname_OBJS)
 	$(CC) -o dirname $(dirname_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 du_OBJS = du.o
-du_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+du_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 du: $(du_OBJS)
 	$(CC) -o du $(du_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 echo_OBJS = echo.o
-echo_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+echo_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 echo: $(echo_OBJS)
 	$(CC) -o echo $(echo_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 false_OBJS = false.o
-false_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+false_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 false: $(false_OBJS)
 	$(CC) -o false $(false_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 file_OBJS = file.o
-file_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+file_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 file: $(file_OBJS)
 	$(CC) -o file $(file_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 find_OBJS = find.o
-find_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+find_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 find: $(find_OBJS)
 	$(CC) -o find $(find_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 head_OBJS = head.o
-head_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+head_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 head: $(head_OBJS)
 	$(CC) -o head $(head_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 id_OBJS = id.o
-id_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+id_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 id: $(id_OBJS)
 	$(CC) -o id $(id_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 kill_OBJS = kill.o
-kill_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+kill_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 kill: $(kill_OBJS)
 	$(CC) -o kill $(kill_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 link_OBJS = link.o
-link_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+link_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 link: $(link_OBJS)
 	$(CC) -o link $(link_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 ln_OBJS = ln.o
-ln_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+ln_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 ln: $(ln_OBJS)
 	$(CC) -o ln $(ln_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 locale_OBJS = locale.o
-locale_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+locale_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 locale: $(locale_OBJS)
 	$(CC) -o locale $(locale_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 logname_OBJS = logname.o
-logname_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+logname_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 logname: $(logname_OBJS)
 	$(CC) -o logname $(logname_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 ls_OBJS = ls.o
-ls_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+ls_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 ls: $(ls_OBJS)
 	$(CC) -o ls $(ls_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 mkdir_OBJS = mkdir.o
-mkdir_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+mkdir_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 mkdir: $(mkdir_OBJS)
 	$(CC) -o mkdir $(mkdir_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 mkfifo_OBJS = mkfifo.o
-mkfifo_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+mkfifo_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 mkfifo: $(mkfifo_OBJS)
 	$(CC) -o mkfifo $(mkfifo_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 mv_OBJS = mv.o
-mv_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+mv_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 mv: $(mv_OBJS)
 	$(CC) -o mv $(mv_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 nice_OBJS = nice.o
-nice_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+nice_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 nice: $(nice_OBJS)
 	$(CC) -o nice $(nice_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 pr_OBJS = pr.o
-pr_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+pr_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 pr: $(pr_OBJS)
 	$(CC) -o pr $(pr_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 printf_OBJS = printf.o
-printf_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+printf_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 printf: $(printf_OBJS)
 	$(CC) -o printf $(printf_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 pwd_OBJS = pwd.o
-pwd_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+pwd_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 pwd: $(pwd_OBJS)
 	$(CC) -o pwd $(pwd_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 renice_OBJS = renice.o
-renice_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+renice_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 renice: $(renice_OBJS)
 	$(CC) -o renice $(renice_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 rm_OBJS = rm.o
-rm_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+rm_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 rm: $(rm_OBJS)
 	$(CC) -o rm $(rm_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 rmdir_OBJS = rmdir.o
-rmdir_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+rmdir_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 rmdir: $(rmdir_OBJS)
 	$(CC) -o rmdir $(rmdir_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 sleep_OBJS = sleep.o
-sleep_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+sleep_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 sleep: $(sleep_OBJS)
 	$(CC) -o sleep $(sleep_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 strings_OBJS = strings.o
-strings_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+strings_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 strings: $(strings_OBJS)
 	$(CC) -o strings $(strings_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 tail_OBJS = tail.o
-tail_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+tail_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 tail: $(tail_OBJS)
 	$(CC) -o tail $(tail_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 test_OBJS = test.o
-test_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+test_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 test: $(test_OBJS)
 	$(CC) -o test $(test_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 time_OBJS = time.o
-time_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+time_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 time: $(time_OBJS)
 	$(CC) -o time $(time_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 touch_OBJS = touch.o
-touch_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+touch_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 touch: $(touch_OBJS)
 	$(CC) -o touch $(touch_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 true_OBJS = true.o
-true_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+true_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 true: $(true_OBJS)
 	$(CC) -o true $(true_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 tty_OBJS = tty.o
-tty_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+tty_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 tty: $(tty_OBJS)
 	$(CC) -o tty $(tty_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 uname_OBJS = uname.o
-uname_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+uname_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 uname: $(uname_OBJS)
 	$(CC) -o uname $(uname_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 uniq_OBJS = uniq.o
-uniq_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+uniq_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 uniq: $(uniq_OBJS)
 	$(CC) -o uniq $(uniq_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 unlink_OBJS = unlink.o
-unlink_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+unlink_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 unlink: $(unlink_OBJS)
 	$(CC) -o unlink $(unlink_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 wc_OBJS = wc.o
-wc_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+wc_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 wc: $(wc_OBJS)
 	$(CC) -o wc $(wc_OBJS) $(LDFLAGSF) $(LDFLAGS)
 
 who_OBJS = who.o
-who_CFLAGS = $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
+who_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS) $(CFLAGSF) $(CFLAGS)
 
 who: $(who_OBJS)
 	$(CC) -o who $(who_OBJS) $(LDFLAGSF) $(LDFLAGS)