===================================================================
RCS file: /cvsrepo/anoncvs/cvs/src/usr.bin/sort/file.c,v
retrieving revision 1.11
retrieving revision 1.12
diff -u -r1.11 -r1.12
--- src/usr.bin/sort/file.c	2015/04/01 21:27:18	1.11
+++ src/usr.bin/sort/file.c	2015/04/01 21:33:01	1.12
@@ -1,4 +1,4 @@
-/*	$OpenBSD: file.c,v 1.11 2015/04/01 21:27:18 millert Exp $	*/
+/*	$OpenBSD: file.c,v 1.12 2015/04/01 21:33:01 millert Exp $	*/
 
 /*-
  * Copyright (C) 2009 Gabor Kovesdan <gabor@FreeBSD.org>
@@ -115,12 +115,11 @@
 void
 tmp_file_atexit(const char *tmp_file)
 {
-	if (tmp_file) {
-		struct CLEANABLE_FILE *item =
-		    sort_malloc(sizeof(struct CLEANABLE_FILE));
-		item->fn = sort_strdup(tmp_file);
-		LIST_INSERT_HEAD(&tmp_files, item, files);
-	}
+	struct CLEANABLE_FILE *item;
+
+	item = sort_malloc(sizeof(struct CLEANABLE_FILE));
+	item->fn = sort_strdup(tmp_file);
+	LIST_INSERT_HEAD(&tmp_files, item, files);
 }
 
 /*
@@ -144,19 +143,13 @@
 file_is_tmp(const char *fn)
 {
 	struct CLEANABLE_FILE *item;
-	bool ret = false;
 
-	if (fn) {
-		LIST_FOREACH(item, &tmp_files, files) {
-			if (item != NULL && item->fn != NULL)
-				if (strcmp(item->fn, fn) == 0) {
-					ret = true;
-					break;
-				}
-		}
+	LIST_FOREACH(item, &tmp_files, files) {
+		if (item->fn != NULL && strcmp(item->fn, fn) == 0)
+			return true;
 	}
 
-	return ret;
+	return false;
 }
 
 /*
@@ -182,12 +175,10 @@
 void
 file_list_init(struct file_list *fl, bool tmp)
 {
-	if (fl) {
-		fl->count = 0;
-		fl->sz = 0;
-		fl->fns = NULL;
-		fl->tmp = tmp;
-	}
+	fl->count = 0;
+	fl->sz = 0;
+	fl->fns = NULL;
+	fl->tmp = tmp;
 }
 
 /*
@@ -196,15 +187,13 @@
 void
 file_list_add(struct file_list *fl, char *fn, bool allocate)
 {
-	if (fl && fn) {
-		if (fl->count >= fl->sz || fl->fns == NULL) {
-			fl->fns = sort_reallocarray(fl->fns,
-			    fl->sz ? fl->sz : (fl->sz = 1), 2 * sizeof(char *));
-			fl->sz *= 2;
-		}
-		fl->fns[fl->count] = allocate ? sort_strdup(fn) : fn;
-		fl->count += 1;
+	if (fl->count >= fl->sz) {
+		fl->fns = sort_reallocarray(fl->fns,
+		    fl->sz ? fl->sz : (fl->sz = 1), 2 * sizeof(char *));
+		fl->sz *= 2;
 	}
+	fl->fns[fl->count] = allocate ? sort_strdup(fn) : fn;
+	fl->count += 1;
 }
 
 /*
@@ -213,12 +202,10 @@
 void
 file_list_populate(struct file_list *fl, int argc, char **argv, bool allocate)
 {
-	if (fl && argv) {
-		int i;
+	int i;
 
-		for (i = 0; i < argc; i++)
-			file_list_add(fl, argv[i], allocate);
-	}
+	for (i = 0; i < argc; i++)
+		file_list_add(fl, argv[i], allocate);
 }
 
 /*
@@ -228,25 +215,23 @@
 void
 file_list_clean(struct file_list *fl)
 {
-	if (fl) {
-		if (fl->fns) {
-			size_t i;
+	if (fl->fns) {
+		size_t i;
 
-			for (i = 0; i < fl->count; i++) {
-				if (fl->fns[i]) {
-					if (fl->tmp)
-						unlink(fl->fns[i]);
-					sort_free(fl->fns[i]);
-					fl->fns[i] = 0;
-				}
+		for (i = 0; i < fl->count; i++) {
+			if (fl->fns[i]) {
+				if (fl->tmp)
+					unlink(fl->fns[i]);
+				sort_free(fl->fns[i]);
+				fl->fns[i] = NULL;
 			}
-			sort_free(fl->fns);
-			fl->fns = NULL;
 		}
-		fl->sz = 0;
-		fl->count = 0;
-		fl->tmp = false;
+		sort_free(fl->fns);
+		fl->fns = NULL;
 	}
+	fl->sz = 0;
+	fl->count = 0;
+	fl->tmp = false;
 }
 
 /*
@@ -255,12 +240,10 @@
 void
 sort_list_init(struct sort_list *l)
 {
-	if (l) {
-		l->count = 0;
-		l->size = 0;
-		l->memsize = sizeof(struct sort_list);
-		l->list = NULL;
-	}
+	l->count = 0;
+	l->size = 0;
+	l->memsize = sizeof(struct sort_list);
+	l->list = NULL;
 }
 
 /*
@@ -269,23 +252,21 @@
 void
 sort_list_add(struct sort_list *l, struct bwstring *str)
 {
-	if (l && str) {
-		size_t indx = l->count;
+	size_t indx = l->count;
 
-		if ((l->list == NULL) || (indx >= l->size)) {
-			size_t newsize = (l->size + 1) + 1024;
+	if ((l->list == NULL) || (indx >= l->size)) {
+		size_t newsize = (l->size + 1) + 1024;
 
-			l->list = sort_reallocarray(l->list, newsize,
-			    sizeof(struct sort_list_item *));
-			l->memsize += (newsize - l->size) *
-			    sizeof(struct sort_list_item *);
-			l->size = newsize;
-		}
-		l->list[indx] = sort_list_item_alloc();
-		sort_list_item_set(l->list[indx], str);
-		l->memsize += sort_list_item_size(l->list[indx]);
-		l->count += 1;
+		l->list = sort_reallocarray(l->list, newsize,
+		    sizeof(struct sort_list_item *));
+		l->memsize += (newsize - l->size) *
+		    sizeof(struct sort_list_item *);
+		l->size = newsize;
 	}
+	l->list[indx] = sort_list_item_alloc();
+	sort_list_item_set(l->list[indx], str);
+	l->memsize += sort_list_item_size(l->list[indx]);
+	l->count += 1;
 }
 
 /*
@@ -294,28 +275,26 @@
 void
 sort_list_clean(struct sort_list *l)
 {
-	if (l) {
-		if (l->list) {
-			size_t i;
+	if (l->list) {
+		size_t i;
 
-			for (i = 0; i < l->count; i++) {
-				struct sort_list_item *item;
+		for (i = 0; i < l->count; i++) {
+			struct sort_list_item *item;
 
-				item = l->list[i];
+			item = l->list[i];
 
-				if (item) {
-					sort_list_item_clean(item);
-					sort_free(item);
-					l->list[i] = NULL;
-				}
+			if (item) {
+				sort_list_item_clean(item);
+				sort_free(item);
+				l->list[i] = NULL;
 			}
-			sort_free(l->list);
-			l->list = NULL;
 		}
-		l->count = 0;
-		l->size = 0;
-		l->memsize = sizeof(struct sort_list);
+		sort_free(l->list);
+		l->list = NULL;
 	}
+	l->count = 0;
+	l->size = 0;
+	l->memsize = sizeof(struct sort_list);
 }
 
 /*
@@ -324,35 +303,34 @@
 void
 sort_list_dump(struct sort_list *l, const char *fn)
 {
-	if (l && fn) {
-		FILE *f;
+	FILE *f;
 
-		f = openfile(fn, "w");
-		if (f == NULL)
-			err(2, "%s", fn);
+	f = openfile(fn, "w");
+	if (f == NULL)
+		err(2, "%s", fn);
 
-		if (l->list) {
-			size_t i;
-			if (!sort_opts_vals.uflag) {
-				for (i = 0; i < l->count; ++i)
-					bwsfwrite(l->list[i]->str, f,
-					    sort_opts_vals.zflag);
-			} else {
-				struct sort_list_item *last_printed_item = NULL;
-				struct sort_list_item *item;
-				for (i = 0; i < l->count; ++i) {
-					item = l->list[i];
-					if ((last_printed_item == NULL) ||
-					    list_coll(&last_printed_item, &item)) {
-						bwsfwrite(item->str, f, sort_opts_vals.zflag);
-						last_printed_item = item;
-					}
+	if (l->list) {
+		size_t i;
+
+		if (!sort_opts_vals.uflag) {
+			for (i = 0; i < l->count; ++i)
+				bwsfwrite(l->list[i]->str, f,
+				    sort_opts_vals.zflag);
+		} else {
+			struct sort_list_item *last_printed_item = NULL;
+			struct sort_list_item *item;
+			for (i = 0; i < l->count; ++i) {
+				item = l->list[i];
+				if ((last_printed_item == NULL) ||
+				    list_coll(&last_printed_item, &item)) {
+					bwsfwrite(item->str, f, sort_opts_vals.zflag);
+					last_printed_item = item;
 				}
 			}
 		}
-
-		closefile(f, fn);
 	}
+
+	closefile(f, fn);
 }
 
 /*
@@ -698,10 +676,10 @@
 				fr->bsz += bsz1;
 				remsz += bsz1;
 			} else {
-				if (remsz > 0 && fr->strbeg>0)
-					bcopy(fr->buffer + fr->strbeg,
-					    fr->buffer, remsz);
-
+				if (remsz > 0 && fr->strbeg > 0) {
+					memmove(fr->buffer,
+					    fr->buffer + fr->strbeg, remsz);
+				}
 				fr->strbeg = 0;
 				search_start = remsz;
 				bsz1 = fread(fr->buffer + remsz, 1,
@@ -725,7 +703,6 @@
 			    fr->buffer - fr->strbeg);
 
 		fr->strbeg = (strend - fr->buffer) + 1;
-
 	} else {
 		size_t len = 0;
 
@@ -739,32 +716,28 @@
 static void
 file_reader_clean(struct file_reader *fr)
 {
-	if (fr) {
-		if (fr->mmapaddr)
-			munmap(fr->mmapaddr, fr->mmapsize);
+	if (fr->mmapaddr)
+		munmap(fr->mmapaddr, fr->mmapsize);
 
-		if (fr->fd)
-			close(fr->fd);
+	if (fr->fd)
+		close(fr->fd);
 
-		sort_free(fr->buffer);
+	sort_free(fr->buffer);
 
-		if (fr->file)
-			if (fr->file != stdin)
-				closefile(fr->file, fr->fname);
+	if (fr->file)
+		if (fr->file != stdin)
+			closefile(fr->file, fr->fname);
 
-		sort_free(fr->fname);
+	sort_free(fr->fname);
 
-		memset(fr, 0, sizeof(struct file_reader));
-	}
+	memset(fr, 0, sizeof(struct file_reader));
 }
 
 void
 file_reader_free(struct file_reader *fr)
 {
-	if (fr) {
-		file_reader_clean(fr);
-		sort_free(fr);
-	}
+	file_reader_clean(fr);
+	sort_free(fr);
 }
 
 int
@@ -808,22 +781,19 @@
 static int
 file_header_cmp(struct file_header *f1, struct file_header *f2)
 {
+	int ret;
+
 	if (f1 == f2)
 		return 0;
-	else {
-		if (f1->fr == NULL) {
-			return (f2->fr == NULL) ? 0 : 1;
-		} else if (f2->fr == NULL)
-			return -1;
-		else {
-			int ret;
+	if (f1->fr == NULL)
+		return (f2->fr == NULL) ? 0 : 1;
+	if (f2->fr == NULL)
+		return -1;
 
-			ret = list_coll(&(f1->si), &(f2->si));
-			if (!ret)
-				return (f1->file_pos < f2->file_pos) ? -1 : 1;
-			return ret;
-		}
-	}
+	ret = list_coll(&(f1->si), &(f2->si));
+	if (!ret)
+		return (f1->file_pos < f2->file_pos) ? -1 : 1;
+	return ret;
 }
 
 /*
@@ -832,26 +802,24 @@
 static void
 file_header_init(struct file_header **fh, const char *fn, size_t file_pos)
 {
-	if (fh && fn) {
-		struct bwstring *line;
+	struct bwstring *line;
 
-		*fh = sort_malloc(sizeof(struct file_header));
-		(*fh)->file_pos = file_pos;
-		(*fh)->fr = file_reader_init(fn);
-		if ((*fh)->fr == NULL) {
-			err(2, "Cannot open %s for reading",
-			    strcmp(fn, "-") == 0 ? "stdin" : fn);
-		}
-		line = file_reader_readline((*fh)->fr);
-		if (line == NULL) {
-			file_reader_free((*fh)->fr);
-			(*fh)->fr = NULL;
-			(*fh)->si = NULL;
-		} else {
-			(*fh)->si = sort_list_item_alloc();
-			sort_list_item_set((*fh)->si, line);
-		}
+	*fh = sort_malloc(sizeof(struct file_header));
+	(*fh)->file_pos = file_pos;
+	(*fh)->fr = file_reader_init(fn);
+	if ((*fh)->fr == NULL) {
+		err(2, "Cannot open %s for reading",
+		    strcmp(fn, "-") == 0 ? "stdin" : fn);
 	}
+	line = file_reader_readline((*fh)->fr);
+	if (line == NULL) {
+		file_reader_free((*fh)->fr);
+		(*fh)->fr = NULL;
+		(*fh)->si = NULL;
+	} else {
+		(*fh)->si = sort_list_item_alloc();
+		sort_list_item_set((*fh)->si, line);
+	}
 }
 
 /*
@@ -860,19 +828,17 @@
 static void
 file_header_close(struct file_header **fh)
 {
-	if (fh && *fh) {
-		if ((*fh)->fr) {
-			file_reader_free((*fh)->fr);
-			(*fh)->fr = NULL;
-		}
-		if ((*fh)->si) {
-			sort_list_item_clean((*fh)->si);
-			sort_free((*fh)->si);
-			(*fh)->si = NULL;
-		}
-		sort_free(*fh);
-		*fh = NULL;
+	if ((*fh)->fr) {
+		file_reader_free((*fh)->fr);
+		(*fh)->fr = NULL;
 	}
+	if ((*fh)->si) {
+		sort_list_item_clean((*fh)->si);
+		sort_free((*fh)->si);
+		(*fh)->si = NULL;
+	}
+	sort_free(*fh);
+	*fh = NULL;
 }
 
 /*
@@ -970,17 +936,15 @@
 static void
 file_header_print(struct file_header *fh, FILE *f_out, struct last_printed *lp)
 {
-	if (fh && fh->fr && f_out && fh->si && fh->si->str) {
-		if (sort_opts_vals.uflag) {
-			if ((lp->str == NULL) || (str_list_coll(lp->str, &(fh->si)))) {
-				bwsfwrite(fh->si->str, f_out, sort_opts_vals.zflag);
-				if (lp->str)
-					bwsfree(lp->str);
-				lp->str = bwsdup(fh->si->str);
-			}
-		} else
+	if (sort_opts_vals.uflag) {
+		if ((lp->str == NULL) || (str_list_coll(lp->str, &(fh->si)))) {
 			bwsfwrite(fh->si->str, f_out, sort_opts_vals.zflag);
-	}
+			if (lp->str)
+				bwsfree(lp->str);
+			lp->str = bwsdup(fh->si->str);
+		}
+	} else
+		bwsfwrite(fh->si->str, f_out, sort_opts_vals.zflag);
 }
 
 /*
@@ -989,23 +953,21 @@
 static void
 file_header_read_next(struct file_header *fh)
 {
-	if (fh && fh->fr) {
-		struct bwstring *tmp;
+	struct bwstring *tmp;
 
-		tmp = file_reader_readline(fh->fr);
-		if (tmp == NULL) {
-			file_reader_free(fh->fr);
-			fh->fr = NULL;
-			if (fh->si) {
-				sort_list_item_clean(fh->si);
-				sort_free(fh->si);
-				fh->si = NULL;
-			}
-		} else {
-			if (fh->si == NULL)
-				fh->si = sort_list_item_alloc();
-			sort_list_item_set(fh->si, tmp);
+	tmp = file_reader_readline(fh->fr);
+	if (tmp == NULL) {
+		file_reader_free(fh->fr);
+		fh->fr = NULL;
+		if (fh->si) {
+			sort_list_item_clean(fh->si);
+			sort_free(fh->si);
+			fh->si = NULL;
 		}
+	} else {
+		if (fh->si == NULL)
+			fh->si = sort_list_item_alloc();
+		sort_list_item_set(fh->si, tmp);
 	}
 }
 
@@ -1046,31 +1008,28 @@
 static void
 merge_files_array(size_t argc, char **argv, const char *fn_out)
 {
-	if (argv && fn_out) {
-		struct file_header **fh;
-		FILE *f_out;
-		size_t i;
+	struct file_header **fh;
+	FILE *f_out;
+	size_t i;
 
-		f_out = openfile(fn_out, "w");
+	f_out = openfile(fn_out, "w");
 
-		if (f_out == NULL)
-			err(2, "%s", fn_out);
+	if (f_out == NULL)
+		err(2, "%s", fn_out);
 
-		fh = sort_reallocarray(NULL, argc + 1,
-		    sizeof(struct file_header *));
+	fh = sort_reallocarray(NULL, argc + 1, sizeof(struct file_header *));
 
-		for (i = 0; i < argc; i++)
-			file_header_init(fh + i, argv[i], (size_t) i);
+	for (i = 0; i < argc; i++)
+		file_header_init(fh + i, argv[i], i);
 
-		file_headers_merge(argc, fh, f_out);
+	file_headers_merge(argc, fh, f_out);
 
-		for (i = 0; i < argc; i++)
-			file_header_close(fh + i);
+	for (i = 0; i < argc; i++)
+		file_header_close(fh + i);
 
-		sort_free(fh);
+	sort_free(fh);
 
-		closefile(f_out, fn_out);
-	}
+	closefile(f_out, fn_out);
 }
 
 /*
@@ -1079,42 +1038,41 @@
 static int
 shrink_file_list(struct file_list *fl)
 {
-	if (fl == NULL || (size_t)fl->count < max_open_files)
+	struct file_list new_fl;
+	size_t indx = 0;
+
+	if (fl->count < max_open_files)
 		return 0;
-	else {
-		struct file_list new_fl;
-		size_t indx = 0;
 
-		file_list_init(&new_fl, true);
-		while (indx < fl->count) {
-			char *fnew;
-			size_t num;
+	file_list_init(&new_fl, true);
+	while (indx < fl->count) {
+		char *fnew;
+		size_t num;
 
-			num = fl->count - indx;
-			fnew = new_tmp_file_name();
+		num = fl->count - indx;
+		fnew = new_tmp_file_name();
 
-			if ((size_t) num >= max_open_files)
-				num = max_open_files - 1;
-			merge_files_array(num, fl->fns + indx, fnew);
-			if (fl->tmp) {
-				size_t i;
+		if (num >= max_open_files)
+			num = max_open_files - 1;
+		merge_files_array(num, fl->fns + indx, fnew);
+		if (fl->tmp) {
+			size_t i;
 
-				for (i = 0; i < num; i++)
-					unlink(fl->fns[indx + i]);
-			}
-			file_list_add(&new_fl, fnew, false);
-			indx += num;
+			for (i = 0; i < num; i++)
+				unlink(fl->fns[indx + i]);
 		}
-		fl->tmp = false; /* already taken care of */
-		file_list_clean(fl);
+		file_list_add(&new_fl, fnew, false);
+		indx += num;
+	}
+	fl->tmp = false; /* already taken care of */
+	file_list_clean(fl);
 
-		fl->count = new_fl.count;
-		fl->fns = new_fl.fns;
-		fl->sz = new_fl.sz;
-		fl->tmp = new_fl.tmp;
+	fl->count = new_fl.count;
+	fl->fns = new_fl.fns;
+	fl->sz = new_fl.sz;
+	fl->tmp = new_fl.tmp;
 
-		return 1;
-	}
+	return 1;
 }
 
 /*
@@ -1123,11 +1081,10 @@
 void
 merge_files(struct file_list *fl, const char *fn_out)
 {
-	if (fl && fn_out) {
-		while (shrink_file_list(fl));
+	while (shrink_file_list(fl))
+		;
 
-		merge_files_array(fl->count, fl->fns, fn_out);
-	}
+	merge_files_array(fl->count, fl->fns, fn_out);
 }
 
 static const char *
@@ -1160,8 +1117,8 @@
 		err(2, "Radix sort cannot be used with these sort options");
 
 	/*
-	 * to handle stable sort and the unique cases in the
-	 * right order, we need stable basic algorithm
+	 * To handle stable sort and the unique cases in the
+	 * right order, we need to use a stable algorithm.
 	 */
 	if (sort_opts_vals.sflag) {
 		switch (sort_opts_vals.sort_method){