Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/make/compat.c	Lines:	69	108	63.9 %
Date:	2017-11-07	Branches:	53	94	56.4 %


/*	$OpenBSD: compat.c,v 1.86 2016/10/21 16:12:38 espie Exp $	*/
/*	$NetBSD: compat.c,v 1.14 1996/11/06 17:59:01 christos Exp $	*/

/*
 * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
 * Copyright (c) 1988, 1989 by Adam de Boor
 * Copyright (c) 1989 by Berkeley Softworks
 * 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.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <limits.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include "config.h"
#include "defines.h"
#include "dir.h"
#include "engine.h"
#include "job.h"
#include "compat.h"
#include "suff.h"
#include "var.h"
#include "targ.h"
#include "targequiv.h"
#include "error.h"
#include "extern.h"
#include "gnode.h"
#include "timestamp.h"
#include "lst.h"

static void CompatMake(void *, void *);

/*-
 *-----------------------------------------------------------------------
 * CompatMake --
 *	Make a target.
 *
 * Side Effects:
 *	If an error is detected and not being ignored, the process exits.
 *-----------------------------------------------------------------------
 */
static void
CompatMake(void *gnp,	/* The node to make */
    void *pgnp)		/* Parent to abort if necessary */
{
	GNode *gn = gnp;
	GNode *pgn = pgnp;

	GNode *sib;
	bool cmdsOk;

	if (DEBUG(MAKE))
		printf("CompatMake(%s, %s)\n", pgn ? pgn->name : "NULL",
		    gn->name);

	/* XXX some loops are not loops, people write dependencies
	 * between siblings to make sure they get built.
	 * Also, we don't recognize direct loops.
	 */
	if (gn == pgn)
		return;
	/* handle .USE right away */
	if (gn->type & OP_USE) {
		Make_HandleUse(gn, pgn);
		return;
	}

	look_harder_for_target(gn);

	if (pgn != NULL && is_sibling(gn, pgn))
		return;

	if (pgn == NULL)
		pgn = gn;

	if (pgn->type & OP_MADE) {
		sib = gn;
		do {
			sib->mtime = gn->mtime;
			sib->built_status = UPTODATE;
			sib = sib->sibling;
		} while (sib != gn);
	}

	switch(gn->built_status) {
	case UNKNOWN:
		/* First mark ourselves to be made, then apply whatever
		 * transformations the suffix module thinks are necessary.
		 * Once that's done, we can descend and make all our children.
		 * If any of them has an error but the -k flag was given,
		 * our 'must_make' field will be set false again.  This is our
		 * signal to not attempt to do anything but abort our
		 * parent as well.  */
		gn->must_make = true;
		gn->built_status = BEINGMADE;
		/* note that, in case we have siblings, we only check all
		 * children for all siblings, but we don't try to apply
		 * any other rule.
		 */
		sib = gn;
		do {
			Suff_FindDeps(sib);
			Lst_ForEach(&sib->children, CompatMake, gn);
			sib = sib->sibling;
		} while (sib != gn);

		if (!gn->must_make) {
			Error("Build for %s aborted", gn->name);
			gn->built_status = ABORTED;
			pgn->must_make = false;
			return;
		}

		/* All the children were made ok. Now youngest points to
		 * the newest child, we need to find out
		 * if we exist and when we were modified last. The criteria
		 * for datedness are defined by the Make_OODate function.  */
		if (DEBUG(MAKE))
			printf("Examining %s...", gn->name);
		if (!Make_OODate(gn)) {
			gn->built_status = UPTODATE;
			if (DEBUG(MAKE))
				printf("up-to-date.\n");
			return;
		} else if (DEBUG(MAKE))
			printf("out-of-date.\n");

		/* If the user is just seeing if something is out-of-date,
		 * exit now to tell him/her "yes".  */
		if (queryFlag)
			exit(1);

		/* normally, we run the job, but if we can't find any
		 * commands, we defer to siblings instead.
		 */
		sib = gn;
		do {
			/* We need to be re-made. We also have to make sure
			 * we've got a $?  variable. To be nice, we also define
			 * the $> variable using Make_DoAllVar().
			 */
			Make_DoAllVar(sib);
			cmdsOk = node_find_valid_commands(sib);
			if (cmdsOk || (gn->type & OP_OPTIONAL))
				break;

			sib = sib->sibling;
		} while (sib != gn);

		if (cmdsOk) {
			/* Our commands are ok, but we still have to worry
			 * about the -t flag...	*/
			if (!touchFlag)
				run_gnode(sib);
			else {
				Job_Touch(sib);
				if (gn != sib)
					Job_Touch(gn);
			}
		} else {
			node_failure(gn);
			sib->built_status = ERROR;
		}

		/* copy over what we just did */
		gn->built_status = sib->built_status;

		if (gn->built_status != ERROR) {
			/* If the node was made successfully, mark it so,
			 * update its modification time and timestamp all
			 * its parents.
			 * This is to keep its state from affecting that of
			 * its parent.  */
			gn->built_status = MADE;
			sib->built_status = MADE;
			/* This is what Make does and it's actually a good
			 * thing, as it allows rules like
			 *
			 *	cmp -s y.tab.h parse.h || cp y.tab.h parse.h
			 *
			 * to function as intended. Unfortunately, thanks to
			 * the stateless nature of NFS (and the speed of
			 * this program), there are times when the
			 * modification time of a file created on a remote
			 * machine will not be modified before the stat()
			 * implied by the Dir_MTime occurs, thus leading us
			 * to believe that the file is unchanged, wreaking
			 * havoc with files that depend on this one.
			 */
			if (noExecute || is_out_of_date(Dir_MTime(gn)))
				clock_gettime(CLOCK_REALTIME, &gn->mtime);
			if (is_strictly_before(gn->mtime, gn->youngest->mtime))
				gn->mtime = gn->youngest->mtime;
			if (sib != gn) {
				if (noExecute || is_out_of_date(Dir_MTime(sib)))
					clock_gettime(CLOCK_REALTIME,
					    &sib->mtime);
				if (is_strictly_before(sib->mtime,
				    sib->youngest->mtime))
					sib->mtime = sib->youngest->mtime;
			}
			if (DEBUG(MAKE))
				printf("update time: %s\n",
				    time_to_string(&gn->mtime));
			if (!(gn->type & OP_EXEC)) {
				pgn->childMade = true;
				Make_TimeStamp(pgn, gn);
			}
		} else if (keepgoing)
			pgn->must_make = false;
		else {
			print_errors();
			exit(1);
		}
		break;
	case ERROR:
		/* Already had an error when making this beastie. Tell the
		 * parent to abort.  */
		pgn->must_make = false;
		break;
	case BEINGMADE:
		Error("Graph cycles through %s", gn->name);
		gn->built_status = ERROR;
		pgn->must_make = false;
		break;
	case MADE:
		if ((gn->type & OP_EXEC) == 0) {
			pgn->childMade = true;
			Make_TimeStamp(pgn, gn);
		}
		break;
	case UPTODATE:
		if ((gn->type & OP_EXEC) == 0)
			Make_TimeStamp(pgn, gn);
		break;
	default:
		break;
	}
}

void
Compat_Run(Lst targs)		/* List of target nodes to re-create */
{
	GNode	  *gn = NULL;	/* Current root target */
	int 	  errors;   	/* Number of targets not remade due to errors */

	/* For each entry in the list of targets to create, call CompatMake on
	 * it to create the thing. CompatMake will leave the 'built_status'
	 * field of gn in one of several states:
	 *	    UPTODATE	    gn was already up-to-date
	 *	    MADE	    gn was recreated successfully
	 *	    ERROR	    An error occurred while gn was being
	 *                          created
	 *	    ABORTED	    gn was not remade because one of its
	 *                          inferiors could not be made due to errors.
	 */
	errors = 0;
	while ((gn = Lst_DeQueue(targs)) != NULL) {
		CompatMake(gn, NULL);

		if (gn->built_status == UPTODATE)
			printf("`%s' is up to date.\n", gn->name);
		else if (gn->built_status == ABORTED) {
			printf("`%s' not remade because of errors.\n",
			    gn->name);
			errors++;
		}
	}

	/* If the user has defined a .END target, run its commands.  */
	if (errors == 0)
		run_gnode(end_node);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: compat.c,v 1.86 2016/10/21 16:12:38 espie Exp $ */
2			/* $NetBSD: compat.c,v 1.14 1996/11/06 17:59:01 christos Exp $ */
3
4			/*
5			* Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
6			* Copyright (c) 1988, 1989 by Adam de Boor
7			* Copyright (c) 1989 by Berkeley Softworks
8			* All rights reserved.
9			*
10			* This code is derived from software contributed to Berkeley by
11			* Adam de Boor.
12			*
13			* Redistribution and use in source and binary forms, with or without
14			* modification, are permitted provided that the following conditions
15			* are met:
16			* 1. Redistributions of source code must retain the above copyright
17			* notice, this list of conditions and the following disclaimer.
18			* 2. Redistributions in binary form must reproduce the above copyright
19			* notice, this list of conditions and the following disclaimer in the
20			* documentation and/or other materials provided with the distribution.
21			* 3. Neither the name of the University nor the names of its contributors
22			* may be used to endorse or promote products derived from this software
23			* without specific prior written permission.
24			*
25			* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28			* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35			* SUCH DAMAGE.
36			*/
37
38			#include <limits.h>
39			#include <signal.h>
40			#include <stdint.h>
41			#include <stdio.h>
42			#include <stdlib.h>
43			#include "config.h"
44			#include "defines.h"
45			#include "dir.h"
46			#include "engine.h"
47			#include "job.h"
48			#include "compat.h"
49			#include "suff.h"
50			#include "var.h"
51			#include "targ.h"
52			#include "targequiv.h"
53			#include "error.h"
54			#include "extern.h"
55			#include "gnode.h"
56			#include "timestamp.h"
57			#include "lst.h"
58
59			static void CompatMake(void , void );
60
61			/*-
62			*-----------------------------------------------------------------------
63			* CompatMake --
64			* Make a target.
65			*
66			* Side Effects:
67			* If an error is detected and not being ignored, the process exits.
68			*-----------------------------------------------------------------------
69			*/
70			static void
71			CompatMake(void gnp, / The node to make */
72			void pgnp) / Parent to abort if necessary */
73			{
74		5485148	GNode *gn = gnp;
75		2742574	GNode *pgn = pgnp;
76
77			GNode *sib;
78			bool cmdsOk;
79
80	✗✓	2742574	if (DEBUG(MAKE))
81			printf("CompatMake(%s, %s)\n", pgn ? pgn->name : "NULL",
82			gn->name);
83
84			/* XXX some loops are not loops, people write dependencies
85			* between siblings to make sure they get built.
86			* Also, we don't recognize direct loops.
87			*/
88	✗✓	2742574	if (gn == pgn)
89			return;
90			/* handle .USE right away */
91	✓✓	2742574	if (gn->type & OP_USE) {
92		22264	Make_HandleUse(gn, pgn);
93		22264	return;
94			}
95
96		2720310	look_harder_for_target(gn);
97
98	✓✓✗✓	5406439	if (pgn != NULL && is_sibling(gn, pgn))
99			return;
100
101	✓✓	2720310	if (pgn == NULL)
102		34181	pgn = gn;
103
104	✗✓	2720310	if (pgn->type & OP_MADE) {
105			sib = gn;
106			do {
107			sib->mtime = gn->mtime;
108			sib->built_status = UPTODATE;
109			sib = sib->sibling;
110			} while (sib != gn);
111			}
112
113	✓✗✗✓ ✓✓	4976130	switch(gn->built_status) {
114			case UNKNOWN:
115			/* First mark ourselves to be made, then apply whatever
116			* transformations the suffix module thinks are necessary.
117			* Once that's done, we can descend and make all our children.
118			* If any of them has an error but the -k flag was given,
119			* our 'must_make' field will be set false again. This is our
120			* signal to not attempt to do anything but abort our
121			* parent as well. */
122		586774	gn->must_make = true;
123		586774	gn->built_status = BEINGMADE;
124			/* note that, in case we have siblings, we only check all
125			* children for all siblings, but we don't try to apply
126			* any other rule.
127			*/
128			sib = gn;
129		586774	do {
130		621274	Suff_FindDeps(sib);
131		621274	Lst_ForEach(&sib->children, CompatMake, gn);
132		621274	sib = sib->sibling;
133	✓✓	621274	} while (sib != gn);
134
135	✗✓	586617	if (!gn->must_make) {
136			Error("Build for %s aborted", gn->name);
137			gn->built_status = ABORTED;
138			pgn->must_make = false;
139			return;
140			}
141
142			/* All the children were made ok. Now youngest points to
143			* the newest child, we need to find out
144			* if we exist and when we were modified last. The criteria
145			* for datedness are defined by the Make_OODate function. */
146	✗✓	586617	if (DEBUG(MAKE))
147			printf("Examining %s...", gn->name);
148	✓✓	586617	if (!Make_OODate(gn)) {
149		463586	gn->built_status = UPTODATE;
150	✗✓	463586	if (DEBUG(MAKE))
151			printf("up-to-date.\n");
152		463586	return;
153	✗✓	123031	} else if (DEBUG(MAKE))
154			printf("out-of-date.\n");
155
156			/* If the user is just seeing if something is out-of-date,
157			* exit now to tell him/her "yes". */
158	✗✓	123031	if (queryFlag)
159			exit(1);
160
161			/* normally, we run the job, but if we can't find any
162			* commands, we defer to siblings instead.
163			*/
164			sib = gn;
165		123031	do {
166			/* We need to be re-made. We also have to make sure
167			* we've got a $? variable. To be nice, we also define
168			* the $> variable using Make_DoAllVar().
169			*/
170		123031	Make_DoAllVar(sib);
171		123031	cmdsOk = node_find_valid_commands(sib);
172	✓✓✓✗	123037	if (cmdsOk \|\| (gn->type & OP_OPTIONAL))
173			break;
174
175		6	sib = sib->sibling;
176	✗✓	6	} while (sib != gn);
177
178	✓✓	123031	if (cmdsOk) {
179			/* Our commands are ok, but we still have to worry
180			* about the -t flag... */
181	✓✗	123025	if (!touchFlag)
182		123025	run_gnode(sib);
183			else {
184			Job_Touch(sib);
185			if (gn != sib)
186			Job_Touch(gn);
187			}
188			} else {
189		6	node_failure(gn);
190		6	sib->built_status = ERROR;
191			}
192
193			/* copy over what we just did */
194		123019	gn->built_status = sib->built_status;
195
196	✓✓	123019	if (gn->built_status != ERROR) {
197			/* If the node was made successfully, mark it so,
198			* update its modification time and timestamp all
199			* its parents.
200			* This is to keep its state from affecting that of
201			* its parent. */
202		122284	gn->built_status = MADE;
203		122284	sib->built_status = MADE;
204			/* This is what Make does and it's actually a good
205			* thing, as it allows rules like
206			*
207			* cmp -s y.tab.h parse.h \|\| cp y.tab.h parse.h
208			*
209			* to function as intended. Unfortunately, thanks to
210			* the stateless nature of NFS (and the speed of
211			* this program), there are times when the
212			* modification time of a file created on a remote
213			* machine will not be modified before the stat()
214			* implied by the Dir_MTime occurs, thus leading us
215			* to believe that the file is unchanged, wreaking
216			* havoc with files that depend on this one.
217			*/
218	✓✗✓✓ ✓✗	326659	if (noExecute \|\| is_out_of_date(Dir_MTime(gn)))
219		82091	clock_gettime(CLOCK_REALTIME, &gn->mtime);
220	✓✓✓✓ ✗✓	244568	if (is_strictly_before(gn->mtime, gn->youngest->mtime))
221		15	gn->mtime = gn->youngest->mtime;
222	✗✓	122284	if (sib != gn) {
223			if (noExecute \|\| is_out_of_date(Dir_MTime(sib)))
224			clock_gettime(CLOCK_REALTIME,
225			&sib->mtime);
226			if (is_strictly_before(sib->mtime,
227			sib->youngest->mtime))
228			sib->mtime = sib->youngest->mtime;
229			}
230	✗✓	122284	if (DEBUG(MAKE))
231			printf("update time: %s\n",
232			time_to_string(&gn->mtime));
233	✓✗	122284	if (!(gn->type & OP_EXEC)) {
234		122284	pgn->childMade = true;
235		122284	Make_TimeStamp(pgn, gn);
236		122284	}
237	✗✓	735	} else if (keepgoing)
238			pgn->must_make = false;
239			else {
240			print_errors();
241			exit(1);
242			}
243			break;
244			case ERROR:
245			/* Already had an error when making this beastie. Tell the
246			* parent to abort. */
247			pgn->must_make = false;
248			break;
249			case BEINGMADE:
250			Error("Graph cycles through %s", gn->name);
251			gn->built_status = ERROR;
252			pgn->must_make = false;
253			break;
254			case MADE:
255	✓✗	90291	if ((gn->type & OP_EXEC) == 0) {
256		90291	pgn->childMade = true;
257		90291	Make_TimeStamp(pgn, gn);
258		90291	}
259			break;
260			case UPTODATE:
261	✓✗	2043245	if ((gn->type & OP_EXEC) == 0)
262		2043245	Make_TimeStamp(pgn, gn);
263			break;
264			default:
265			break;
266			}
267		4997490	}
268
269			void
270			Compat_Run(Lst targs) /* List of target nodes to re-create */
271			{
272			GNode gn = NULL; / Current root target */
273			int errors; /* Number of targets not remade due to errors */
274
275			/* For each entry in the list of targets to create, call CompatMake on
276			* it to create the thing. CompatMake will leave the 'built_status'
277			* field of gn in one of several states:
278			* UPTODATE gn was already up-to-date
279			* MADE gn was recreated successfully
280			* ERROR An error occurred while gn was being
281			* created
282			* ABORTED gn was not remade because one of its
283			* inferiors could not be made due to errors.
284			*/
285			errors = 0;
286	✓✓	135638	while ((gn = Lst_DeQueue(targs)) != NULL) {
287		33434	CompatMake(gn, NULL);
288
289	✓✓	33434	if (gn->built_status == UPTODATE)
290		112	printf("`%s' is up to date.\n", gn->name);
291	✓✗	33322	else if (gn->built_status == ABORTED) {
292			printf("`%s' not remade because of errors.\n",
293			gn->name);
294			errors++;
295			}
296			}
297
298			/* If the user has defined a .END target, run its commands. */
299	✓✗	33321	if (errors == 0)
300		33321	run_gnode(end_node);
301		33321	}