rewrite

Simplified the code and used the revised error recovery approach from
5-18.

Author: fsaadatmand

chapter05/5-19.c

@@ -1,124 +1,125 @@
 /*
  * Exercise 5-19. Modify undcl so that it does not add redundant parentheses to
  * declaration.
+ *
  * By Faisal Saadatmand
- * */
+ */
 
+#include <ctype.h>
 #include <stdio.h>
 #include <string.h>
-#include <ctype.h>
-
-#define MAXTOKEN    100
-#define BUFSIZE     100
 
-#define SKIP_BLANKS(c)  while (((c) = getch()) == ' ' || (c) == '\t')
+#define BUFSIZE   100
+#define MAXLEN    1000
+#define MAXTOKEN  100
 
 enum { NAME, PARENS, BRACKETS };
+enum { GOOD, FAIL };
 
 /* functions */
-int  gettoken(void);
-int  getch(void);
-void ungetch(int);
+void undcl(void);
+int gettoken();
 
 /* globals */
-char token[MAXTOKEN];                  /* last token string */
-int  tokentype;                        /* type of last token */
-char name[MAXTOKEN];                   /* identifier name */
-char out[1000];
-int  buf[BUFSIZE];                     /* buffer from ungetch */
-int  bufp;                             /* next free position in buf */
-int  pushedEOF;                        /* signals EOF has been pushed-back */
-
-/* gettoekn: return next token */
-int gettoken(void)
-{
-	int c, getch(void);
-	void ungetch(int);
-	char *p = token;
-
-	SKIP_BLANKS(c);
-
-	if (c == '(') {
-		SKIP_BLANKS(c);                /* allow spaces in parens */
-		if (c == ')') {
-			strcpy(token, "()");
-			return tokentype = PARENS;
-		} else {
-			ungetch(c);
-			return tokentype = '(';
-		}
-	} else if (c == '[') {
-		for (*p++ = c; (*p = getch()) != ']'; p++)
-			if (*p == '\n')            /* error check: missing ']' */
-				return *p;
-		*++p = '\0';
-		return tokentype = BRACKETS;
-	} else if (isalpha(c)) {
-		for (*p++ = c; isalnum(c = getch()); p++)
-			*p = c;
-		*p = '\0';
-		ungetch(c);
-		return tokentype = NAME;
-	} else
-		return tokentype = c;
-}
+int buf[BUFSIZE];         /* buffer from ungetch */
+int bufp = 0;             /* next free position in buf */
+int tokentype;            /* type of last token */
+char token[MAXTOKEN];     /* last token string */
+char name[MAXTOKEN];      /* identifier name */
+char datatype[MAXTOKEN];  /* data type = char, int, etc. */
+char out[MAXLEN];         /* composed output string */
+char state;               /* flag to propagate the current state of parsing */
 
 /* getch: get a (possibly pushed back) character */
 int getch(void)
 {
-	return (bufp > 0) ? buf[--bufp] : (pushedEOF) ? EOF : getchar();
+	return (bufp > 0) ? buf[--bufp] : getchar();
 }
 
 /* ungerch: push character back on input */
 void ungetch(int c)
 {
-	if (c == EOF) {
-		pushedEOF = 1;
-		return;
-	}
-
 	if (bufp >= BUFSIZE)
 		printf("ungetch: too many characters\n");
 	else
 		buf[bufp++] = c;
 }
 
+/* needsParens: check if the next token is a parenthesis or a bracket */
+int needsParens()
+{
+	void ungettokken(int);
+	int nextType;
+
+	nextType = gettoken(); /* peek ahead */
+	state = FAIL; /* signal token push back */
+	return nextType == PARENS || nextType == BRACKETS;
+}
+
 /* undcl: convert word descriptions to declarations */
 void undcl(void)
 {
-	int  type, is_dcl, error;
-	char temp[1100];           /* increased size to avoid potential overflow */
+	int type;
+	char temp[MAXTOKEN];
 
-	is_dcl = error = 0;
-	strcpy(out, token);
-	while ((type = gettoken()) != '\n') {
-		if (type == PARENS || type == BRACKETS) {
-			if (is_dcl) {          /* check if previous token is the start of dcl */
-				sprintf(temp, "(%s)", out);
-				strcpy(out, temp);
-				is_dcl = 0;
-				}
+	while ((type = gettoken()) != '\n')
+		if (type == PARENS || type == BRACKETS)
 			strcat(out, token);
-		} else if (type == '*') {
-			sprintf(temp, "*%s", out);
+		else if (type == '*') {
+			sprintf(temp, needsParens() ? "(*%s)" : "*%s", out);
 			strcpy(out, temp);
-			is_dcl = 1;
 		} else if (type == NAME) {
 			sprintf(temp, "%s %s", token, out);
 			strcpy(out, temp);
-		} else {
+		} else
 			printf("invalid input at %s\n", token);
-			error = 1;
+}
+
+/* gettoken: return next token */
+int gettoken(void)
+{
+	int c, getch(void);
+	void ungetch(int);
+	char *p = token;
+
+	if (state == FAIL) {
+		state = GOOD;
+		return tokentype; /* push back the previous token */
+	}
+	while ((c = getch()) == ' ' || c == '\t')
+		;
+	if (c == '(') {
+		if ((c = getch()) == ')') {
+			strcpy(token, "()");
+			return tokentype = PARENS;
 		}
+		ungetch(c);
+		return tokentype = '(';
+	} 
+	if (c == '[') {
+		for (*p++ = c; (*p++ = getch()) != ']'; )
+			;
+		*p = '\0';
+		return tokentype = BRACKETS;
 	}
-	if (!error)
-		printf("%s\n", out);
+	if (isalpha(c)) {
+		for (*p++ = c; isalnum(c = getch()); )
+			*p++ = c;
+		*p = '\0';
+		ungetch(c);
+		return tokentype = NAME;
+	}
+	return tokentype = c;
 }
 
-int main(void)               
+int main(void)
 {
-	while (gettoken() != EOF)
-		if (tokentype != '\n')         /* skip empty input lines */
-			undcl();
+	while (gettoken() != EOF) {  /* first token on line */
+		if (tokentype == '\n')  /* skip empty input lines */
+			continue;
+		strcpy(out, token); /* is the datatype */
+		undcl();
+		printf("%s\n", out);
+	}
 	return 0;
 }