rewrite code

Author: fsaadatmand

chapter05/5-13.c

@@ -3,130 +3,118 @@
  * input. By default, n is set to 10, let us say, but it can be changed by an
  * optional argument so that
  *
- * 	tail -n
+ * 		tail -n
  *
  * prints the last n lines. The program should behave rationally no matter how
- * unreasonable the input or value of n.  Write the program so it makes the
- * best use of available storage; lines should be stored as in the sorting
- * program of section 5.6, not in a two-dimensional array of fixed size.
+ * unreasonable the input or value of n. Write the program so it makes the best
+ * use of available storage; lines should be stored as in the sorting program
+ * of section 5.6, not in a two-dimensional array of fixed size.
+ *
  * By Faisal Saadatmand
  */
 
 #include <stdio.h>
-#include <string.h>
 #include <stdlib.h>
-#include <ctype.h>
+#include <string.h>
+
+#define MAXLEN 1000 /* max length of any input line */
+#define MAXLINES 5000 /* max #lines to be stored */
+#define ALLOCSIZE 10000 /* size of available space */
+
+static char allocbuf[ALLOCSIZE]; /* storage for alloc */
+static char *allocp = allocbuf; /* next free position */
 
-#define MAXLINES   5000      /* max #lines to be stored */
-#define MAXLEN     1000      /* max length of any input line */
-#define ALLOCSIZE 100000     /* storage for alloc */
-#define N          10        /* default value of last lines to print */
 
 /* functions */
-int  readlines(char *[], int);
-int  getLine(char *, int);
+int getLine(char *, int);
 char *alloc(int);
-int  isDigitStr(char *[]);
+int readlines(char *[], int);
+void writelines(char *[], int);
+int expandArg(int, char **, int *);
 
-/* globals */
-char        *lineptr[MAXLINES];   /* pointers to text lines */
-static char allocbuf[ALLOCSIZE];  /* storage for alloc */
-static char *allocp = allocbuf;   /* next free position */
+/* getLine function: read a line into s, return length */
+int getLine(char *s, int lim)
+{
+	int c;
+	char *len;
+
+	len = s;
+	while (--lim > 0 && (c = getchar()) != EOF && c != '\n')
+		*s++ = c;
+	if (c == '\n')
+		*s++ = c;
+	*s = '\0';
+	return strlen(len);
+}
+
+/* alloc: return pointer to n characters */
+char *alloc(int n)
+{
+	if (allocbuf + ALLOCSIZE - allocp >= n) { /* it fits */
+		allocp += n;
+		return allocp - n; /*old p */
+	}
+	return NULL;  /* not enough room */
+}
 
 /* readlines: read input lines */
-int readlines(char *lineptr[], int maxlines)
+int readlines(char *linerptr[], int maxlines)
 {
 	int len, nlines;
 	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;
-		}
-	return nlines;
-}
-
-/* getLine: get line into s, return length of s -- pointer version */
-int getLine(char *s, int lim)
-{
-	int c, len;
-
-	len = 0;
-	while (--lim > 0 && (c = getchar()) != EOF && c != '\n') {
-		*s++ = c;
-		++len;
-	}
-	if ( c == '\n') {
-		*s++ = c;
-		++len;
+		line[len - 1] = '\0'; /* delete newline */
+		strcpy(p, line);
+		linerptr[nlines++] = p;
 	}
-	*s = '\0';
-	return len;
+	return nlines;
 }
 
-/* alloc: allocate memory */
-char *alloc(int n)               /* return pointer to n characters */
+/* writelines: write output lines */
+void writelines(char *lineptr[], int nlines)
 {
-	if (allocbuf + ALLOCSIZE - allocp >=n) {     /* it fits */
-		allocp += n;
-		return allocp - n;                       /* old p */
-	} else                                       /* not enough room */
-		return 0;
+	while (nlines-- > 0)
+		printf("%s\n", *lineptr++);
 }
 
-/* isDigitStr: check if string is made of positive integers characters. Return
- * 1 if true; 0 if false */
-int isDigitStr(char *s[])
+int expandArg(int count, char **list, int *n)
 {
-	int i;
+	char *prog = *list, *end;
 
-		for (i = 0; (*s)[i]; ++i)   /* omitted '\0', since s is a pointer */
-			if (!isdigit((*s)[i]))
+	while (--count > 0)
+		if (!strcmp(*++list, "-n")) {
+			end = NULL;
+			if (!(*n = strtol(*++list, &end, 10)) || *end) {
+				printf("%s: invalid number of lines: %s\n", prog, *list);
 				return 0;
+			}
+			*n = abs(*n); /* treat negative numbers as positives */
+			--count;
+		} else {
+			printf("Usage: %s [-n lines]\n", prog);
+			return 0;
+		}
 	return 1;
 }
 
 int main(int argc, char *argv[])
 {
-	int nlines;                   /* number of input lines read */
-	int type;                     /* type of argument operator */
-	int i;                        /* index variable */
-	int n;                        /* cli argument value of n */
-
-	while (--argc > 0) {
-		type = *(++argv)[0];
-		switch (type) {
-		case ('-'):
-			n = *++argv[0];
-			if (isDigitStr(argv)) {
-				n = atoi(*argv);
-				argc = 0;         /* signal to exit loop */
-			}
-			else {
-				n = 0;            /* signal invalid value */
-				argc =0;
-			}
-			break;
-		default:
-			n = 0;                /* signal invalid input */
-			argc = 0;
-			break;
-		}
-	}
+	char *lineptr[MAXLINES]; /* pointers to text lines */
+	int nlines; /* number of read lines */
+	int n = 10; /* default last n lines to print */ 
 
-	if ((nlines = readlines(lineptr, MAXLINES)) >= 0) {
-		if (n <= 0 || n > nlines) /* check input or value of argument */
-			n = N;                /* default to N, if unreasonable */
-		for (i = 0; i < n; ++i)
-			printf("%s\n", lineptr[(nlines - n) + i]);
-		return 0;
-	} else {
-		printf("error: input too big to sort\n");
-		return 1;
+	if (!expandArg(argc, argv, &n))
+		return -1;
+	if ((nlines = readlines(lineptr, MAXLINES)) < 0) {
+		printf("Error: input is too big\n");
+		return -1;
 	}
+	if (n > nlines) /* max limit check */
+		n = nlines; /* print entire input, not more */
+	writelines(lineptr + nlines - n, n); 
+	return 0;
 }