 @@ -1,14 +1,14 @@
-/*	$NetBSD: parse.c,v 1.429 2020/11/07 10:44:53 rillig Exp $	*/
+/*	$NetBSD: parse.c,v 1.430 2020/11/07 22:25:19 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -107,27 +107,27 @@
 #ifndef MAP_FILE
 #define MAP_FILE 0
 #endif
 #ifndef MAP_COPY
 #define MAP_COPY MAP_PRIVATE
 #endif
 #include "make.h"
 #include "dir.h"
 #include "job.h"
 #include "pathnames.h"
 /*	"@(#)parse.c	8.3 (Berkeley) 3/19/94"	*/
-MAKE_RCSID("$NetBSD: parse.c,v 1.429 2020/11/07 10:44:53 rillig Exp $");
+MAKE_RCSID("$NetBSD: parse.c,v 1.430 2020/11/07 22:25:19 rillig Exp $");
 /* types and constants */
 /*
  * Structure for a file being read ("included file")
  */
 typedef struct IFile {
     char *fname;		/* name of file (relative? absolute?) */
     Boolean fromForLoop;	/* simulated .include by the .for loop */
     int lineno;			/* current line number in file */
     int first_lineno;		/* line number of start of text */
     unsigned int cond_depth;	/* 'if' nesting when file opened */
     Boolean depending;		/* state of doing_depend on EOF */
 @@ -363,141 +363,141 @@ loadedfile_create(const char *path)
 	lf = bmake_malloc(sizeof *lf);
 	lf->path = path == NULL ? "(stdin)" : path;
 	lf->buf = NULL;
 	lf->len = 0;
 	lf->maplen = 0;
 	lf->used = FALSE;
 	return lf;
+}
 static void
 loadedfile_destroy(struct loadedfile *lf)
+{
 	if (lf->buf != NULL) {
-		if (lf->maplen > 0) {
+		if (lf->maplen > 0)
 			munmap(lf->buf, lf->maplen);
-		} else {
+		else
 			free(lf->buf);
+	}
 	free(lf);
+}
 /* deleteme */
 /*
  * nextbuf() operation for loadedfile, as needed by the weird and twisted
  * logic below. Once that's cleaned up, we can get rid of lf->used...
  */
 static char *
 loadedfile_nextbuf(void *x, size_t *len)
+{
 	struct loadedfile *lf = x;
-	if (lf->used) {
+	if (lf->used)
 		return NULL;
 	lf->used = TRUE;
 	*len = lf->len;
 	return lf->buf;
+}
 /*
  * Try to get the size of a file.
  */
 static Boolean
 load_getsize(int fd, size_t *ret)
+{
 	struct stat st;
-	if (fstat(fd, &st) < 0) {
+	if (fstat(fd, &st) < 0)
 		return FALSE;
-	if (!S_ISREG(st.st_mode)) {
+	if (!S_ISREG(st.st_mode))
 		return FALSE;
 	/*
 	 * st_size is an off_t, which is 64 bits signed; *ret is
 	 * size_t, which might be 32 bits unsigned or 64 bits
 	 * unsigned. Rather than being elaborate, just punt on
 	 * files that are more than 2^31 bytes. We should never
 	 * see a makefile that size in practice...
+	 *
 	 * While we're at it reject negative sizes too, just in case.
 	 */
-	if (st.st_size < 0 || st.st_size > 0x7fffffff) {
+	if (st.st_size < 0 || st.st_size > 0x7fffffff)
 		return FALSE;
 	*ret = (size_t)st.st_size;
 	return TRUE;
+}
 /* deleteme */
 /* deleteme */
 /* deleteme */
 static Boolean
 loadedfile_mmap(struct loadedfile *lf, int fd)
+{
 	static unsigned long pagesize = 0;
-	if (load_getsize(fd, &lf->len)) {
+	if (!load_getsize(fd, &lf->len))
 		return FALSE;
-		/* found a size, try mmap */
+	/* found a size, try mmap */
-		if (pagesize == 0)
+	if (pagesize == 0)
-			pagesize = (unsigned long)sysconf(_SC_PAGESIZE);
+		pagesize = (unsigned long)sysconf(_SC_PAGESIZE);
-		if (pagesize == 0 || pagesize == (unsigned long)-1) {
+	if (pagesize == 0 || pagesize == (unsigned long)-1)
-			pagesize = 0x1000;
+		pagesize = 0x1000;
 		/* round size up to a page */
 		lf->maplen = pagesize * ((lf->len + pagesize - 1) / pagesize);
-		/*
+	/* round size up to a page */
-		 * XXX hack for dealing with empty files; remove when
+	lf->maplen = pagesize * ((lf->len + pagesize - 1) / pagesize);
 		 * we're no longer limited by interfacing to the old
 		 * logic elsewhere in this file.
 		 */
 		if (lf->maplen == 0) {
 			lf->maplen = pagesize;
-		/*
+	/*
-		 * FUTURE: remove PROT_WRITE when the parser no longer
+	 * XXX hack for dealing with empty files; remove when
-		 * needs to scribble on the input.
+	 * we're no longer limited by interfacing to the old
-		 */
+	 * logic elsewhere in this file.
-		lf->buf = mmap(NULL, lf->maplen, PROT_READ|PROT_WRITE,
+	 */
-			       MAP_FILE|MAP_COPY, fd, 0);
+	if (lf->maplen == 0)
-		if (lf->buf != MAP_FAILED) {
+		lf->maplen = pagesize;
 			/* succeeded */
-			if (lf->len == lf->maplen && lf->buf[lf->len - 1] != '\n') {
+	/*
-				char *b = bmake_malloc(lf->len + 1);
+	 * FUTURE: remove PROT_WRITE when the parser no longer
-				b[lf->len] = '\n';
+	 * needs to scribble on the input.
-				memcpy(b, lf->buf, lf->len++);
+	 */
-				munmap(lf->buf, lf->maplen);
+	lf->buf = mmap(NULL, lf->maplen, PROT_READ|PROT_WRITE,
-				lf->maplen = 0;
+		       MAP_FILE|MAP_COPY, fd, 0);
-				lf->buf = b;
+	if (lf->buf == MAP_FAILED)
 		return FALSE;
 			return TRUE;
 	if (lf->len == lf->maplen && lf->buf[lf->len - 1] != '\n') {
 		char *b = bmake_malloc(lf->len + 1);
 		b[lf->len] = '\n';
 		memcpy(b, lf->buf, lf->len++);
 		munmap(lf->buf, lf->maplen);
 		lf->maplen = 0;
 		lf->buf = b;
+	}
 	return FALSE;
 	return TRUE;
+}
 /* deleteme */
 /* deleteme */
 /*
  * Read in a file.
+ *
  * Until the path search logic can be moved under here instead of
  * being in the caller in another source file, we need to have the fd
  * passed in already open. Bleh.
+ *
- * If the path is NULL use stdin and (to insure against fd leaks)
+ * If the path is NULL, use stdin.
  * assert that the caller passed in -1.
  */
 static struct loadedfile *
 loadfile(const char *path, int fd)
+{
 	struct loadedfile *lf;
 	ssize_t result;
 	size_t bufpos;
 	lf = loadedfile_create(path);
 	if (path == NULL) {
 		assert(fd == -1);
 		fd = STDIN_FILENO;
 @@ -529,47 +529,47 @@ loadfile(const char *path, int fd)
 				errno = EFBIG;
 				Error("%s: file too large", path);
 				exit(1);
+			}
 			lf->len *= 2;
 			lf->buf = bmake_realloc(lf->buf, lf->len);
+		}
 		assert(bufpos < lf->len);
 		result = read(fd, lf->buf + bufpos, lf->len - bufpos);
 		if (result < 0) {
 			Error("%s: read error: %s", path, strerror(errno));
 			exit(1);
+		}
-		if (result == 0) {
+		if (result == 0)
 			break;
 		bufpos += (size_t)result;
+	}
 	assert(bufpos <= lf->len);
 	lf->len = bufpos;
 	/* truncate malloc region to actual length (maybe not useful) */
 	if (lf->len > 0) {
 		/* as for mmap case, ensure trailing \n */
 		if (lf->buf[lf->len - 1] != '\n')
 			lf->len++;
 		lf->buf = bmake_realloc(lf->buf, lf->len);
 		lf->buf[lf->len - 1] = '\n';
+	}
 done:
-	if (path != NULL) {
+	if (path != NULL)
 		close(fd);
 	return lf;
+}
 /* old code */
 /* Check if the current character is escaped on the current line. */
 static Boolean
 ParseIsEscaped(const char *line, const char *c)
+{
     Boolean active = FALSE;
     for (;;) {
 	if (line == c)
 	    return active;
 @@ -584,46 +584,46 @@ ParseIsEscaped(const char *line, const c
 static void
 ParseMark(GNode *gn)
+{
     IFile *curFile = CurFile();
     gn->fname = curFile->fname;
     gn->lineno = curFile->lineno;
+}
 /* Look in the table of keywords for one matching the given string.
  * Return the index of the keyword, or -1 if it isn't there. */
 static int
 ParseFindKeyword(const char *str)
+{
-    int start, end, cur;
+    int start = 0;
-    int diff;
+    int end = sizeof parseKeywords / sizeof parseKeywords[0] - 1;
     start = 0;
     end = sizeof parseKeywords / sizeof parseKeywords[0] - 1;
     do {
-	cur = start + (end - start) / 2;
+	int cur = start + (end - start) / 2;
-	diff = strcmp(str, parseKeywords[cur].name);
+	int diff = strcmp(str, parseKeywords[cur].name);
-	if (diff == 0) {
+	if (diff == 0)
 	    return cur;
-	} else if (diff < 0) {
+	if (diff < 0)
 	    end = cur - 1;
-	} else {
+	else
 	    start = cur + 1;
     } while (start <= end);
     return -1;
+}
 /* deleteme */
 /* deleteme */
 /* deleteme */
 static void
 PrintLocation(FILE *f, const char *filename, size_t lineno)
+{
 	char dirbuf[MAXPATHLEN+1];
 	const char *dir, *base;
 	void *dir_freeIt, *base_freeIt;
 	if (*filename == '/' || strcmp(filename, "(stdin)") == 0) {
 		(void)fprintf(f, "\"%s\" line %zu: ", filename, lineno);
 		return;
+	}
 @@ -961,32 +961,32 @@ ParseDoSrcOther(const char *src, GNodeTy
      * from a special target or link it to its parents, as
      * appropriate.
+     *
      * In the case of a source that was the object of a :: operator,
      * the attribute is applied to all of its instances (as kept in
      * the 'cohorts' list of the node) or all the cohorts are linked
      * to all the targets.
      */
     /* Find/create the 'src' node and attach to all targets */
     gn = Targ_GetNode(src);
     if (doing_depend)
 	ParseMark(gn);
-    if (tOp) {
+    if (tOp)
 	gn->type |= tOp;
-    } else {
+    else
 	LinkToTargets(gn, specType != SP_NOT);
+}
 /* deleteme */
 /* Given the name of a source in a dependency line, figure out if it is an
  * attribute (such as .SILENT) and apply it to the targets if it is. Else
  * decide if there is some attribute which should be applied *to* the source
  * because of some special target (such as .PHONY) and apply it if so.
  * Otherwise, make the source a child of the targets in the list 'targets'.
+ *
  * Input:
  *	tOp		operator (if any) from special targets
  *	src		name of the source to handle
  */
 static void
 ParseDoSrc(GNodeType tOp, const char *src, ParseSpecial specType)
 @@ -1114,36 +1114,36 @@ ParseDependencyTargetWord(/*const*/ char
  *	.INTERRUPT	Are not to be considered the
  *			main target.
  *	.NOTPARALLEL	Make only one target at a time.
  *	.SINGLESHELL	Create a shell for each command.
  *	.ORDER		Must set initial predecessor to NULL
  */
 static void
 ParseDoDependencyTargetSpecial(ParseSpecial *inout_specType,
 			       const char *line,
 			       SearchPathList **inout_paths)
+{
     switch (*inout_specType) {
     case SP_PATH:
-	if (*inout_paths == NULL) {
+	if (*inout_paths == NULL)
 	    *inout_paths = Lst_New();
 	Lst_Append(*inout_paths, dirSearchPath);
 	break;
 /* deleteme */
     case SP_MAIN:
-	if (!Lst_IsEmpty(opts.create)) {
+	if (!Lst_IsEmpty(opts.create))
 	    *inout_specType = SP_NOT;
 	break;
 /* deleteme */
     case SP_BEGIN:
     case SP_END:
     case SP_STALE:
     case SP_ERROR:
     case SP_INTERRUPT: {
 	GNode *gn = Targ_GetNode(line);
 	if (doing_depend)
 	    ParseMark(gn);
 	gn->type |= OP_NOTMAIN|OP_SPECIAL;
 	Lst_Append(targets, gn);
 	break;
+    }
     case SP_DEFAULT: {
 @@ -1175,32 +1175,32 @@ ParseDoDependencyTargetSpecial(ParseSpec
  * Call on the suffix module to give us a path to modify.
  */
 static Boolean
 ParseDoDependencyTargetPath(const char *line, SearchPathList **inout_paths)
+{
     SearchPath *path;
     path = Suff_GetPath(&line[5]);
     if (path == NULL) {
 	Parse_Error(PARSE_FATAL,
 		    "Suffix '%s' not defined (yet)",
 		    &line[5]);
 	return FALSE;
     } else {
 	if (*inout_paths == NULL) {
 	    *inout_paths = Lst_New();
 	Lst_Append(*inout_paths, path);
+    }
     if (*inout_paths == NULL)
 	*inout_paths = Lst_New();
     Lst_Append(*inout_paths, path);
     return TRUE;
+}
 /*
  * See if it's a special target and if so set specType to match it.
  */
 static Boolean
 ParseDoDependencyTarget(const char *line, ParseSpecial *inout_specType,
 			GNodeType *out_tOp, SearchPathList **inout_paths)
+{
     int keywd;
     if (!(*line == '.' && ch_isupper(line[1])))
 @@ -1263,39 +1263,39 @@ ParseDoDependencyTargetMundane(char *lin
 	if (doing_depend)
 	    ParseMark(gn);
 	Lst_Append(targets, gn);
+    }
+}
 static void
 ParseDoDependencyTargetExtraWarn(char **pp, const char *lstart)
+{
     Boolean warning = FALSE;
     char *cp = *pp;
-    while (*cp && (ParseIsEscaped(lstart, cp) ||
+    while (*cp != '\0') {
-		   (*cp != '!' && *cp != ':'))) {
+	if (!ParseIsEscaped(lstart, cp) && (*cp == '!' || *cp == ':'))
-	if (ParseIsEscaped(lstart, cp) ||
+	    break;
-	    (*cp != ' ' && *cp != '\t')) {
+	if (ParseIsEscaped(lstart, cp) || (*cp != ' ' && *cp != '\t'))
 	    warning = TRUE;
 	cp++;
+    }
-    if (warning) {
+    if (warning)
 	Parse_Error(PARSE_WARNING, "Extra target ignored");
     *pp = cp;
+}
 /* deleteme */
 static void
 ParseDoDependencyCheckSpec(ParseSpecial specType)
+{
     switch (specType) {
     default:
 	Parse_Error(PARSE_WARNING,
 		    "Special and mundane targets don't mix. Mundane ones ignored");
 	break;
     case SP_DEFAULT:
     case SP_STALE:
     case SP_BEGIN:
     case SP_END:
 @@ -1505,81 +1505,81 @@ ParseDoDependencyTargets(char **inout_cp
 	/* Insert a null terminator. */
 	savec = *cp;
 	*cp = '\0';
 	if (!ParseDoDependencyTarget(line, inout_specType, inout_tOp,
 				     inout_paths))
 	    return FALSE;
 	/*
 	 * Have word in line. Get or create its node and stick it at
 	 * the end of the targets list
 	 */
-	if (*inout_specType == SP_NOT && *line != '\0') {
+	if (*inout_specType == SP_NOT && *line != '\0')
 	    ParseDoDependencyTargetMundane(line, curTargs);
-	} else if (*inout_specType == SP_PATH && *line != '.' && *line != '\0') {
+	else if (*inout_specType == SP_PATH && *line != '.' && *line != '\0')
 	    Parse_Error(PARSE_WARNING, "Extra target (%s) ignored", line);
 	/* Don't need the inserted null terminator any more. */
 	*cp = savec;
 	/*
 	 * If it is a special type and not .PATH, it's the only target we
 	 * allow on this line...
 	 */
-	if (*inout_specType != SP_NOT && *inout_specType != SP_PATH) {
+	if (*inout_specType != SP_NOT && *inout_specType != SP_PATH)
 	    ParseDoDependencyTargetExtraWarn(&cp, lstart);
-	} else {
+	else
 	    pp_skip_whitespace(&cp);
 	line = cp;
 	if (*line == '\0')
 	    break;
 	if ((*line == '!' || *line == ':') && !ParseIsEscaped(lstart, line))
 	    break;
+    }
     *inout_cp = cp;
     *inout_line = line;
     return TRUE;
+}
 /* deleteme */
 static void
 ParseDoDependencySourcesSpecial(char *start, char *end,
 				ParseSpecial specType, SearchPathList *paths)
+{
     char savec;
     while (*start) {
 	while (*end && !ch_isspace(*end))
 	    end++;
 	savec = *end;
 	*end = '\0';
 	ParseDoDependencySourceSpecial(specType, start, paths);
 	*end = savec;
 	if (savec != '\0')
 	    end++;
 	pp_skip_whitespace(&end);
 	start = end;
+    }
+}
 static Boolean
 ParseDoDependencySourcesMundane(char *start, char *end,
 				ParseSpecial specType, GNodeType tOp)
+{
-    while (*start) {
+    while (*start != '\0') {
 	/*
 	 * The targets take real sources, so we must beware of archive
 	 * specifications (i.e. things with left parentheses in them)
 	 * and handle them accordingly.
 	 */
 	for (; *end && !ch_isspace(*end); end++) {
 	    if (*end == '(' && end > start && end[-1] != '$') {
 		/*
 		 * Only stop for a left parenthesis if it isn't at the
 		 * start of a word (that'll be for variable changes
 		 * later) and isn't preceded by a dollar sign (a dynamic
 		 * source).
 		 */
 @@ -1978,33 +1978,33 @@ VarAssign_EvalShell(const char *name, co
  * The actual value of the variable is returned in *out_avalue and
  * *out_avalue_freeIt.  Especially for VAR_SUBST and VAR_SHELL this can differ
  * from the literal value.
+ *
  * Return whether the assignment was actually done.  The assignment is only
  * skipped if the operator is '?=' and the variable already exists. */
 static Boolean
 VarAssign_Eval(const char *name, VarAssignOp op, const char *uvalue,
 	       GNode *ctxt, const char **out_avalue, void **out_avalue_freeIt)
+{
     const char *avalue = uvalue;
     void *avalue_freeIt = NULL;
-    if (op == VAR_APPEND) {
+    if (op == VAR_APPEND)
 	Var_Append(name, uvalue, ctxt);
-    } else if (op == VAR_SUBST) {
+    else if (op == VAR_SUBST)
 	VarAssign_EvalSubst(name, uvalue, ctxt, &avalue, &avalue_freeIt);
-    } else if (op == VAR_SHELL) {
+    else if (op == VAR_SHELL)
 	VarAssign_EvalShell(name, uvalue, ctxt, &avalue, &avalue_freeIt);
-    } else {
+    else {
 	if (op == VAR_DEFAULT && Var_Exists(name, ctxt)) {
 	    *out_avalue_freeIt = NULL;
 	    return FALSE;
+	}
 	/* Normal assignment -- just do it. */
 	Var_Set(name, uvalue, ctxt);
+    }
     *out_avalue = avalue;
     *out_avalue_freeIt = avalue_freeIt;
     return TRUE;
+}
 @@ -2012,32 +2012,32 @@ VarAssign_Eval(const char *name, VarAssi
 static void
 VarAssignSpecial(const char *name, const char *avalue)
+{
     if (strcmp(name, MAKEOVERRIDES) == 0)
 	Main_ExportMAKEFLAGS(FALSE);	/* re-export MAKEFLAGS */
     else if (strcmp(name, ".CURDIR") == 0) {
 	/*
 	 * Someone is being (too?) clever...
 	 * Let's pretend they know what they are doing and
 	 * re-initialize the 'cur' CachedDir.
 	 */
 	Dir_InitCur(avalue);
 	Dir_SetPATH();
-    } else if (strcmp(name, MAKE_JOB_PREFIX) == 0) {
+    } else if (strcmp(name, MAKE_JOB_PREFIX) == 0)
 	Job_SetPrefix();
-    } else if (strcmp(name, MAKE_EXPORTED) == 0) {
+    else if (strcmp(name, MAKE_EXPORTED) == 0)
 	Var_Export(avalue, FALSE);
+}
 /* deleteme */
 /* Perform the variable variable assignment in the given context. */
 void
 Parse_DoVar(VarAssign *var, GNode *ctxt)
+{
     const char *avalue;		/* actual value (maybe expanded) */
     void *avalue_freeIt;
     VarCheckSyntax(var->op, var->value, ctxt);
     if (VarAssign_Eval(var->varname, var->op, var->value, ctxt,
 		       &avalue, &avalue_freeIt))
 	VarAssignSpecial(var->varname, avalue);
 @@ -2178,35 +2178,33 @@ Parse_include_file(char *file, Boolean i
 	if (fullname == NULL) {
 	    /*
 	     * Makefile wasn't found in same directory as included makefile.
 	     * Search for it first on the -I search path,
 	     * then on the .PATH search path, if not found in a -I directory.
 	     * If we have a suffix specific path we should use that.
 	     */
 	    char *suff;
 	    SearchPath *suffPath = NULL;
 	    if ((suff = strrchr(file, '.'))) {
 		suffPath = Suff_GetPath(suff);
-		if (suffPath != NULL) {
+		if (suffPath != NULL)
 		    fullname = Dir_FindFile(file, suffPath);
+	    }
 	    if (fullname == NULL) {
 		fullname = Dir_FindFile(file, parseIncPath);
-		if (fullname == NULL) {
+		if (fullname == NULL)
 		    fullname = Dir_FindFile(file, dirSearchPath);
+	    }
+	}
+    }
     /* Looking for a system file or file still not found */
     if (fullname == NULL) {
 	/*
 	 * Look for it on the system path
 	 */
 	SearchPath *path = Lst_IsEmpty(sysIncPath) ? defSysIncPath : sysIncPath;
 	fullname = Dir_FindFile(file, path);
+    }
 @@ -2224,65 +2222,67 @@ Parse_include_file(char *file, Boolean i
 	free(fullname);
 	return;
+    }
     /* load it */
     lf = loadfile(fullname, fd);
     /* Start reading from this file next */
     Parse_SetInput(fullname, 0, -1, loadedfile_nextbuf, lf);
     CurFile()->lf = lf;
     if (depinc)
 	doing_depend = depinc;	/* only turn it on */
+}
 /* deleteme */
 /* deleteme */
 static void
 ParseDoInclude(char *line)
+{
     char endc;			/* the character which ends the file spec */
     char *cp;			/* current position in file spec */
     int silent = *line != 'i';
     char *file = line + (silent ? 8 : 7);
     /* Skip to delimiter character so we know where to look */
     pp_skip_hspace(&file);
     if (*file != '"' && *file != '<') {
 	Parse_Error(PARSE_FATAL,
 		    ".include filename must be delimited by '\"' or '<'");
 	return;
+    }
     /*
      * Set the search path on which to find the include file based on the
      * characters which bracket its name. Angle-brackets imply it's
      * a system Makefile while double-quotes imply it's a user makefile
      */
-    if (*file == '<') {
+    if (*file == '<')
 	endc = '>';
-    } else {
+    else
 	endc = '"';
     /* Skip to matching delimiter */
     for (cp = ++file; *cp && *cp != endc; cp++)
 	continue;
     if (*cp != endc) {
 	Parse_Error(PARSE_FATAL,
 		    "Unclosed %cinclude filename. '%c' expected",
 		    '.', endc);
 	return;
+    }
     *cp = '\0';
     /*
      * Substitute for any variables in the file name before trying to
      * find the thing.
      */
     (void)Var_Subst(file, VAR_CMDLINE, VARE_WANTRES, &file);
     /* TODO: handle errors */
     Parse_include_file(file, endc == '>', *line == 'd', silent);
     free(file);
+}
 @@ -2472,34 +2472,34 @@ IsInclude(const char *dir, Boolean sysv)
 #ifdef SYSVINCLUDE
 /* Check if the line is a SYSV include directive. */
 static Boolean
 IsSysVInclude(const char *line)
+{
 	const char *p;
 	if (!IsInclude(line, TRUE))
 		return FALSE;
 	/* Avoid interpreting a dependency line as an include */
 	for (p = line; (p = strchr(p, ':')) != NULL;) {
 		if (*++p == '\0') {
-			/* end of line -> dependency */
+		/* end of line -> it's a dependency */
 		if (*++p == '\0')
 			return FALSE;
-		if (*p == ':' || ch_isspace(*p)) {
+		/* '::' operator or ': ' -> it's a dependency */
-			/* :: operator or ': ' -> dependency */
+		if (*p == ':' || ch_isspace(*p))
 			return FALSE;
+	}
 	return TRUE;
+}
 /* Push to another file.  The line points to the word "include". */
 static void
 ParseTraditionalInclude(char *line)
+{
     char *cp;			/* current position in file spec */
     Boolean done = FALSE;
     int silent = line[0] != 'i';
     char *file = line + (silent ? 8 : 7);
     char *all_files;
 @@ -2584,30 +2584,28 @@ ParseEOF(void)
     char *ptr;
     size_t len;
     IFile *curFile = CurFile();
     assert(curFile->nextbuf != NULL);
     doing_depend = curFile->depending;	/* restore this */
     /* get next input buffer, if any */
     ptr = curFile->nextbuf(curFile->nextbuf_arg, &len);
     curFile->buf_ptr = ptr;
     curFile->buf_freeIt = ptr;
     curFile->buf_end = ptr + len;
     curFile->lineno = curFile->first_lineno;
-    if (ptr != NULL) {
+    if (ptr != NULL)
-	/* Iterate again */
+	return TRUE;		/* Iterate again */
 	return TRUE;
     /* Ensure the makefile (or loop) didn't have mismatched conditionals */
     Cond_restore_depth(curFile->cond_depth);
     if (curFile->lf != NULL) {
 	loadedfile_destroy(curFile->lf);
 	curFile->lf = NULL;
+    }
     /* Dispose of curFile info */
     /* Leak curFile->fname because all the gnodes have pointers to it */
     free(curFile->buf_freeIt);
     Vector_Pop(&includes);
 @@ -2853,42 +2851,44 @@ ParseReadLine(void)
 	    } while (For_Accum(line));
 	    /* Stash each iteration as a new 'input file' */
 	    For_Run(lineno);
 	    /* Read next line from for-loop buffer */
 	    continue;
+	}
 	return line;
+    }
+}
 static void
 FinishDependencyGroup(void)
+{
-    if (targets != NULL) {
+    GNodeListNode *ln;
 	GNodeListNode *ln;
 	for (ln = targets->first; ln != NULL; ln = ln->next) {
 	    GNode *gn = ln->datum;
-	    Suff_EndTransform(gn);
+    if (targets == NULL)
 	return;
-	    /* Mark the target as already having commands if it does, to
+    for (ln = targets->first; ln != NULL; ln = ln->next) {
-	     * keep from having shell commands on multiple dependency lines. */
+	GNode *gn = ln->datum;
 	    if (!Lst_IsEmpty(gn->commands))
 		gn->type |= OP_HAS_COMMANDS;
-	Lst_Free(targets);
+	Suff_EndTransform(gn);
 	targets = NULL;
 	/* Mark the target as already having commands if it does, to
 	 * keep from having shell commands on multiple dependency lines. */
 	if (!Lst_IsEmpty(gn->commands))
 	    gn->type |= OP_HAS_COMMANDS;
+    }
     Lst_Free(targets);
     targets = NULL;
+}
 /* Add the command to each target from the current dependency spec. */
 static void
 ParseLine_ShellCommand(const char *p)
+{
     cpp_skip_whitespace(&p);
     if (*p == '\0')
 	return;			/* skip empty commands */
     if (targets == NULL) {
 	Parse_Error(PARSE_FATAL, "Unassociated shell command \"%s\"", p);
 	return;
 @@ -2950,61 +2950,61 @@ ParseDirective(char *line)
 		   strncmp(cp, "error", 5) == 0 ||
 		   strncmp(cp, "warning", 7) == 0) {
 	    if (ParseMessage(cp))
 		return TRUE;
+	}
+    }
     return FALSE;
+}
 static Boolean
 ParseVarassign(const char *line)
+{
     VarAssign var;
     if (Parse_IsVar(line, &var)) {
-	FinishDependencyGroup();
+    if (!Parse_IsVar(line, &var))
-	Parse_DoVar(&var, VAR_GLOBAL);
+	return FALSE;
 	return TRUE;
     FinishDependencyGroup();
-    return FALSE;
+    Parse_DoVar(&var, VAR_GLOBAL);
     return TRUE;
+}
 static char *
 FindSemicolon(char *p)
+{
     int level = 0;
     for (; *p != '\0'; p++) {
 	if (*p == '\\' && p[1] != '\0') {
 	    p++;
 	    continue;
+	}
-	if (*p == '$' && (p[1] == '(' || p[1] == '{')) {
+	if (*p == '$' && (p[1] == '(' || p[1] == '{'))
 	    level++;
-	    continue;
+	else if (level > 0 && (*p == ')' || *p == '}'))
 	if (level > 0 && (*p == ')' || *p == '}')) {
 	    level--;
-	    continue;
+	else if (level == 0 && *p == ';')
 	if (level == 0 && *p == ';') {
 	    break;
+    }
     return p;
+}
 /* deleteme */
 /* deleteme */
 /* deleteme */
 /* deleteme */
 /* deleteme */
 /* deleteme */
 /* dependency	-> target... op [source...]
  * op		-> ':' | '::' | '!' */
 static void
 ParseDependency(char *line)
+{
     VarEvalFlags eflags;
     char *expanded_line;
     const char *shellcmd = NULL;
     /*
      * For some reason - probably to make the parser impossible -
      * a ';' can be used to separate commands from dependencies.
 @@ -3133,27 +3133,27 @@ Parse_File(const char *name, int fd)
     do {
 	while ((line = ParseReadLine()) != NULL) {
 	    DEBUG2(PARSE, "ParseReadLine (%d): '%s'\n",
 		   CurFile()->lineno, line);
 	    ParseLine(line);
+	}
 	/*
 	 * Reached EOF, but it may be just EOF of an include file...
 	 */
     } while (ParseEOF());
     FinishDependencyGroup();
-    if (fatals) {
+    if (fatals != 0) {
 	(void)fflush(stdout);
 	(void)fprintf(stderr,
 		      "%s: Fatal errors encountered -- cannot continue",
 		      progname);
 	PrintOnError(NULL, NULL);
 	exit(1);
+    }
+}
 /* Initialize the parsing module. */
 void
 Parse_Init(void)
+{
 @@ -3194,30 +3194,30 @@ Parse_End(void)
+ *
  * Side Effects:
  *	None.
+ *
  *-----------------------------------------------------------------------
  */
 GNodeList *
 Parse_MainName(void)
+{
     GNodeList *mainList;
     mainList = Lst_New();
-    if (mainNode == NULL) {
+    if (mainNode == NULL)
 	Punt("no target to make.");
 	/*NOTREACHED*/
-    } else if (mainNode->type & OP_DOUBLEDEP) {
+    if (mainNode->type & OP_DOUBLEDEP) {
 	Lst_Append(mainList, mainNode);
 	Lst_AppendAll(mainList, mainNode->cohorts);
     } else
 	Lst_Append(mainList, mainNode);
     Var_Append(".TARGETS", mainNode->name, VAR_GLOBAL);
     return mainList;
+}
 int
 Parse_GetFatals(void)
+{
     return fatals;
+}