rewrite code

Use a comparator function that returns a pointer to the appropriate
function according to the command line options. The different options
are stored in a 1 byte bit flag. This abstracts quiet a bit of code and
thus simplifies the main routine other functions.

Author: fsaadatmand

chapter05/5-14.c

@@ -1,34 +1,36 @@
 /*
  * Exercise 5-14. Modify the sort program to handle a -r flag, which indicates
  * sorting in reverse (decreasing) order. Be sure that -r works with -n.
+ *
  * By Faisal Saadatmand
  */
 
 #include <stdio.h>
-#include <string.h>
 #include <stdlib.h>
+#include <string.h>
 
 #define MAXLINES   5000      /* max #lines to be sorted */
 #define MAXLEN     1000      /* max length of any input line */
-#define ALLOCSIZE 100000     /* storage for alloc */
+#define ALLOCSIZE  100000    /* storage for alloc */
+#define NUMERIC    01        /* numeric sort */
+#define REVERSE    02        /* reverse sort */
+
+typedef int (*funcP)(void *, void*); /* type alias to simplify syntax
+										see section 6.7 */
 
 /* functions */
-int  getLine(char *, int);
-int  readlines(char *[], int);
+int getLine(char *, int);
+int readlines(char *[], int);
 void witelines(char *[], int);
 char *alloc(int);
-void qSort(void *[], int, int,
-		int (*)(void *, void *));
-int  numcmp(char *, char *);
-int  strCmp(char *, char *);
-int  reverse(char *, char *);
+void qSort(void *[], int, int, funcP);
+int numcmp(char *, char *);
+funcP comperator(int);
 
 /* globals */
-char        *lineptr[MAXLINES];   /* pointers to text lines */
 static char allocbuf[ALLOCSIZE];  /* storage for alloc */
 static char *allocp = allocbuf;   /* next free position */
-int         numeric = 0;          /* 1 if numeric sort */
-int         decreasing = 0;       /* 1 if reverse order sort */
+static char option;               /* bit flag (1 byte in size) */
 
 /* getLine: get line into s, return length of s -- pointer version */
 int getLine(char *s, int lim)
@@ -40,7 +42,7 @@ int getLine(char *s, int lim)
 		*s++ = c;
 		++len;
 	}
-	if ( c == '\n') {
+	if (c == '\n') {
 		*s++ = c;
 		++len;
 	}
@@ -55,45 +57,55 @@ int readlines(char *lineptr[], int maxlines)
 	char *p, line[MAXLEN];
 
 	nlines = 0;
-	while ((len = getLine(line, MAXLEN)) > 0)
+	while ((len = getLine(line, MAXLEN)) > 0) {
 		if (nlines >= maxlines || (p = alloc(len)) == NULL)
 			return -1;
-		else {
-			line[len - 1] = '\0';   /* delete newline character */
-			strcpy(p, line);
-			lineptr[nlines++] = p;
-		}
+		line[len - 1] = '\0';   /* delete newline character */
+		strcpy(p, line);
+		lineptr[nlines++] = p;
+	}
 	return nlines;
 }
 
 /* writelines: write output lines */
-void writelines(char *lineptr[], int nlines)
+void writelines(char *lineptr[], int nlines, int reverse)
 {
-	while (nlines-- > 0)
-		printf("%s\n", *lineptr++);
+	if (reverse)
+		while (--nlines > 0) /* print lines in reverser order */
+			printf("%s\n", lineptr[nlines]);
+	else
+		while (nlines-- > 0)
+			printf("%s\n", *lineptr++);
 }
 
-/* alloc: allocate memory */
-char *alloc(int n)               /* return pointer to n characters */
+/* alloc: return pointer to n characters */
+char *alloc(int n)
+{
+	if (allocbuf + ALLOCSIZE - allocp < n)
+		return 0; /* not enough room */
+	allocp += n;
+	return allocp - n; /* old p */
+}
+
+/* swap: swap the values of v[i] and v[j]. */
+void swap(void *v[], int i, int j)
 {
-	if (allocbuf + ALLOCSIZE - allocp >=n) {     /* it fits */
-		allocp += n;
-		return allocp - n;                       /* old p */
-	} else                                       /* not enough room */
-		return 0;
+	void *temp;
+
+	temp = v[i];
+	v[i] = v[j];
+	v[j] = temp;
 }
 
 /* qsort: sort v[left]...V[right] into increasing order */
-void qSort(void *v[], int left, int right,
-		int (*comp)(void *, void *))
+void qSort(void *v[], int left, int right, funcP comp)
 {
 	int i, last;
 
 	void swap(void *v[], int, int);
 
 	if (left >= right)             /* do nothing if array contains */
 		return;                    /* fewer than two elements */
-
 	swap(v, left, (left + right) / 2);
 	last = left;
 	for (i = left + 1; i <= right; i++)
@@ -111,13 +123,11 @@ int numcmp(char *s1, char *s2)
 
 	v1 = atof(s1);
 	v2 = atof(s2);
-
 	if (v1 < v2)
 		return -1;
-	 else if (v1 > v2)
-		 return 1;
-	 else
-		return 0;
+	if (v1 > v2)
+		return 1;
+	return 0;
 }
 
 /* strCmp: return < 0 if s < t, 0 if s == t, > 0 if s > t */
@@ -129,49 +139,40 @@ int strCmp(char *s, char *t)
 	return *s - *t;
 }
 
-void swap(void *v[], int i, int j)
+/* comparator: return a function pointer to the compare function corresponding
+ * to the input option(s). If no option was provided, i.e. the bit flag
+ * 'option' was 0, return a function pointer to strCmp. */
+funcP comparator(int option) 
 {
-	void *temp;
-
-	temp = v[i];
-	v[i] = v[j];
-	v[j] = temp;
-}
-
-/* reverse: reverse the return value of a function */
-int reverse(char *s, char *t)
-{
-	int (*compfun) (char *, char *);  /* pointer to compare function */
-
-	compfun = (numeric) ? numcmp : strCmp;
-
-	if ((*compfun)(s, t) < 0)
-		return  1;
-	else if ((*compfun)(s, t) > 0)
-		return -1;
-	return 0;
+	/*
+	 * Because functions could use the comparator function to determine which
+	 * operation to perform, the order of the checks is important. Moreover,
+	 * when calling the comparator, the calling function must exclude itself
+	 * and any preceding options in the checks order from the option bit flag.
+	 */
+	return (funcP) (option & NUMERIC ? numcmp : strCmp);
 }
 
 /* sort input lines */
 int main(int argc, char *argv[])
 {
-	int nlines;                    /* number of input lines read */     
+	char *lineptr[MAXLINES];  /* pointers to text lines */
+	int nlines;               /* number of input lines read */     
 
+	/* Note: no input error checking */
+	option = 0;
 	while (--argc > 0) {
 		++argv;
-		if (strCmp(argv[0], "-n") == 0)
-			numeric = 1;
-		if (strCmp(argv[0], "-r") == 0)
-			decreasing = 1;
+		if (!strCmp(argv[0], "-n"))
+			option |= NUMERIC;
+		if (!strCmp(argv[0], "-r"))
+			option |= REVERSE;
 	}
-	if ((nlines = readlines(lineptr, MAXLINES)) >= 0) {
-			qSort((void**) lineptr, 0, nlines - 1,
-					(int (*)(void *, void *))(decreasing ? reverse :
-						numeric ? numcmp : strCmp));
-		writelines(lineptr, nlines);
-		return 0;
-	} else {
+	if ((nlines = readlines(lineptr, MAXLINES)) < 0) {
 		printf("input too big to sort\n");
 		return 1;
 	}
+	qSort((void**) lineptr, 0, nlines - 1, comparator(option));
+	writelines(lineptr, nlines, option & REVERSE);
+	return 0;
 }