2 * Copyright (c) 1988, 1989, 1990, 1993
3 * The Regents of the University of California. All rights reserved.
4 * Copyright (c) 1989 by Berkeley Softworks
7 * This code is derived from software contributed to Berkeley by
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. All advertising materials mentioning features or use of this software
19 * must display the following acknowledgement:
20 * This product includes software developed by the University of
21 * California, Berkeley and its contributors.
22 * 4. Neither the name of the University nor the names of its contributors
23 * may be used to endorse or promote products derived from this software
24 * without specific prior written permission.
26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
38 * @(#) Copyright (c) 1988, 1989, 1990, 1993 The Regents of the University of California. All rights reserved.
39 * @(#)main.c 8.3 (Berkeley) 3/19/94
40 * $FreeBSD: src/usr.bin/make/main.c,v 1.118 2005/02/13 13:33:56 harti Exp $
41 * $DragonFly: src/usr.bin/make/main.c,v 1.108 2005/05/23 20:04:04 okumoto Exp $
46 * The main file for this entire program. Exit routines etc
49 * Utility functions defined in this file:
51 * Takes a line of arguments, breaks them and
52 * treats them as if they were given when first
53 * invoked. Used by the parse module to implement
58 #include <sys/utsname.h>
60 #include <sys/param.h>
63 #include <sys/queue.h>
64 #include <sys/resource.h>
80 #include "pathnames.h"
88 extern char **environ; /* XXX what header declares this variable? */
92 * This control the default concurrency. On no occasion will more
93 * than DEFMAXJOBS targets be created at once.
97 typedef struct MakeFlags {
98 /* ordered list of makefiles to read */
101 /* list of variables to print */
104 Boolean expandVars; /* fully expand printed variables */
105 Boolean noBuiltins; /* -r flag */
106 Boolean forceJobs; /* -j argument given */
110 * TRUE if we aren't supposed to really make anything, just
111 * see if the targets are out-of-date
116 /* (-E) vars to override from env */
117 Lst envFirstVars = Lst_Initializer(envFirstVars);
119 /* Targets to be made */
120 Lst create = Lst_Initializer(create);
122 Boolean allPrecious; /* .PRECIOUS given on line by itself */
123 Boolean beSilent; /* -s flag */
124 Boolean beVerbose; /* -v flag */
125 Boolean compatMake; /* -B argument */
126 Boolean debug; /* -d flag */
127 Boolean ignoreErrors; /* -i flag */
128 int jobLimit; /* -j argument */
129 Boolean jobsRunning; /* TRUE if the jobs might be running */
130 Boolean keepgoing; /* -k flag */
131 Boolean noExecute; /* -n flag */
132 Boolean touchFlag; /* -t flag */
133 Boolean usePipes; /* !-P flag */
134 uint32_t warn_cmd; /* command line warning flags */
135 uint32_t warn_flags; /* actual warning flags */
136 uint32_t warn_nocmd; /* command line no-warning flags */
138 time_t now; /* Time at start of make */
139 struct GNode *DEFAULT; /* .DEFAULT node */
143 * Exit with usage message.
149 "usage: make [-BPSXeiknqrstv] [-C directory] [-D variable]\n"
150 "\t[-d flags] [-E variable] [-f makefile] [-I directory]\n"
151 "\t[-j max_jobs] [-m directory] [-V variable]\n"
152 "\t[variable=value] [target ...]\n");
158 * Append a flag with an optional argument to MAKEFLAGS and MFLAGS
161 MFLAGS_append(const char *flag, char *arg)
165 Var_Append(".MAKEFLAGS", flag, VAR_GLOBAL);
167 str = MAKEFLAGS_quote(arg);
168 Var_Append(".MAKEFLAGS", str, VAR_GLOBAL);
172 Var_Append("MFLAGS", flag, VAR_GLOBAL);
174 str = MAKEFLAGS_quote(arg);
175 Var_Append("MFLAGS", str, VAR_GLOBAL);
181 * Open and parse the given makefile.
184 * TRUE if ok. FALSE if couldn't open file.
187 ReadMakefile(MakeFlags *mf, const char file[], const char curdir[], const char objdir[])
189 char path[MAXPATHLEN];
194 if (!strcmp(file, "-")) {
195 Parse_File(mf, "(stdin)", stdin);
196 Var_SetGlobal("MAKEFILE", "");
200 if (strcmp(curdir, objdir) == 0 || file[0] == '/') {
204 * we've chdir'd, rebuild the path name
206 snprintf(path, MAXPATHLEN, "%s/%s", curdir, file);
208 #if THIS_BREAKS_THINGS
210 * XXX The realpath stuff breaks relative includes
211 * XXX in some cases. The problem likely is in
212 * XXX parse.c where it does special things in
213 * XXX ParseDoInclude if the file is relateive
214 * XXX or absolute and not a system file. There
215 * XXX it assumes that if the current file that's
216 * XXX being included is absolute, that any files
217 * XXX that it includes shouldn't do the -I path
218 * XXX stuff, which is inconsistant with historical
219 * XXX behavior. However, I can't pentrate the mists
220 * XXX further, so I'm putting this workaround in
221 * XXX here until such time as the underlying bug
224 if (realpath(path, path) == NULL) {
227 stream = fopen(path, "r");
230 stream = fopen(path, "r");
232 if (stream != NULL) {
233 if (strcmp(file, ".depend") != 0)
234 Var_SetGlobal("MAKEFILE", file);
235 Parse_File(mf, path, stream);
240 /* look in -I and system include directories. */
241 fname = estrdup(file);
244 name = Path_FindFile(fname, &parseIncPath);
246 name = Path_FindFile(fname, &sysIncPath);
249 stream = fopen(name, "r");
250 if (stream != NULL) {
252 * set the MAKEFILE variable desired by System V fans
253 * -- the placement of the setting here means it gets
254 * set to the last makefile specified, as it is set
257 if (strcmp(file, ".depend") != 0)
258 Var_SetGlobal("MAKEFILE", name);
259 Parse_File(mf, name, stream);
265 return (FALSE); /* no makefile found */
269 * Read in the built-in rules first, followed by the specified
270 * makefiles or the one of the default makefiles. Finally .depend
274 ReadInputFiles(MakeFlags *mf, const char curdir[], const char objdir[])
276 if (!mf->noBuiltins) {
278 Lst sysMkPath = Lst_Initializer(sysMkPath);
280 char defsysmk[] = PATH_DEFSYSMK;
282 Path_Expand(defsysmk, &sysIncPath, &sysMkPath);
283 if (Lst_IsEmpty(&sysMkPath))
284 Fatal("make: no system rules (%s).", PATH_DEFSYSMK);
285 LST_FOREACH(ln, &sysMkPath) {
286 if (!ReadMakefile(mf, Lst_Datum(ln), curdir, objdir))
290 Fatal("make: cannot open %s.", (char *)Lst_Datum(ln));
291 Lst_Destroy(&sysMkPath, free);
294 if (!Lst_IsEmpty(&mf->makefiles)) {
297 LST_FOREACH(ln, &mf->makefiles) {
298 if (!ReadMakefile(mf, Lst_Datum(ln), curdir, objdir))
302 Fatal("make: cannot open %s.", (char *)Lst_Datum(ln));
303 } else if (ReadMakefile(mf, "BSDmakefile", curdir, objdir)) {
304 /* read BSDmakefile */
305 } else if (ReadMakefile(mf, "makefile", curdir, objdir)) {
307 } else if (ReadMakefile(mf, "Makefile", curdir, objdir)) {
310 /* No Makefile found */
313 ReadMakefile(mf, ".depend", curdir, objdir);
319 * Handle argument to warning option.
322 Main_ParseWarn(const char *arg, int iscmd)
326 static const struct {
330 { "dirsyntax", WARN_DIRSYNTAX },
335 if (arg[0] == 'n' && arg[1] == 'o') {
340 for (i = 0; options[i].option != NULL; i++)
341 if (strcmp(arg, options[i].option) == 0)
344 if (options[i].option == NULL)
350 warn_cmd |= options[i].flag;
351 warn_nocmd &= ~options[i].flag;
352 warn_flags |= options[i].flag;
354 warn_nocmd |= options[i].flag;
355 warn_cmd &= ~options[i].flag;
356 warn_flags &= ~options[i].flag;
360 warn_flags |= (options[i].flag & ~warn_nocmd);
362 warn_flags &= ~(options[i].flag | warn_cmd);
370 * Parse a given argument vector. Called from main() and from
371 * Main_ParseArgLine() when the .MAKEFLAGS target is used.
373 * XXX: Deal with command line overriding .MAKEFLAGS in makefile
376 * Various global and local flags will be set depending on the flags
380 MainParseArgs(MakeFlags *mf, int argc, char **argv)
383 Boolean found_dd = FALSE;
386 optind = 1; /* since we're called more than once */
388 #define OPTFLAGS "ABC:D:E:I:PSV:Xd:ef:ij:km:nqrstvx:"
390 if ((optind < argc) && strcmp(argv[optind], "--") == 0) {
393 if ((c = getopt(argc, argv, OPTFLAGS)) == -1) {
400 MFLAGS_append("-A", NULL);
403 if (chdir(optarg) == -1)
404 err(1, "chdir %s", optarg);
407 Var_SetGlobal(optarg, "1");
408 MFLAGS_append("-D", optarg);
411 Parse_AddIncludeDir(optarg);
412 MFLAGS_append("-I", optarg);
415 Lst_AtEnd(&mf->variables, estrdup(optarg));
416 MFLAGS_append("-V", optarg);
419 mf->expandVars = FALSE;
423 MFLAGS_append("-B", NULL);
424 unsetenv("MAKE_JOBS_FIFO");
428 MFLAGS_append("-P", NULL);
432 MFLAGS_append("-S", NULL);
435 char *modules = optarg;
437 for (; *modules; ++modules)
455 if (modules[1] == '1') {
456 debug |= DEBUG_GRAPH1;
459 else if (modules[1] == '2') {
460 debug |= DEBUG_GRAPH2;
483 warnx("illegal argument to d option "
487 MFLAGS_append("-d", optarg);
491 Lst_AtEnd(&envFirstVars, estrdup(optarg));
492 MFLAGS_append("-E", optarg);
495 checkEnvFirst = TRUE;
496 MFLAGS_append("-e", NULL);
499 Lst_AtEnd(&mf->makefiles, estrdup(optarg));
503 MFLAGS_append("-i", NULL);
508 mf->forceJobs = TRUE;
509 jobLimit = strtol(optarg, &endptr, 10);
510 if (jobLimit <= 0 || *endptr != '\0') {
511 warnx("illegal number, -j argument -- %s",
515 MFLAGS_append("-j", optarg);
520 MFLAGS_append("-k", NULL);
523 Path_AddDir(&sysIncPath, optarg);
524 MFLAGS_append("-m", optarg);
528 MFLAGS_append("-n", NULL);
531 mf->queryFlag = TRUE;
532 /* Kind of nonsensical, wot? */
533 MFLAGS_append("-q", NULL);
536 mf->noBuiltins = TRUE;
537 MFLAGS_append("-r", NULL);
541 MFLAGS_append("-s", NULL);
545 MFLAGS_append("-t", NULL);
549 MFLAGS_append("-v", NULL);
552 if (Main_ParseWarn(optarg, 1) != -1)
553 MFLAGS_append("-x", optarg);
566 * Parse the rest of the arguments.
567 * o Check for variable assignments and perform them if so.
568 * o Check for more flags and restart getopt if so.
569 * o Anything else is taken to be a target and added
570 * to the end of the "create" list.
572 for (; *argv != NULL; ++argv, --argc) {
573 if (Parse_IsVar(*argv)) {
574 char *ptr = MAKEFLAGS_quote(*argv);
576 Var_Append(".MAKEFLAGS", ptr, VAR_GLOBAL);
577 Parse_DoVar(*argv, VAR_CMD);
580 } else if ((*argv)[0] == '-') {
581 if ((*argv)[1] == '\0') {
583 * (*argv) is a single dash, so we
586 } else if (found_dd) {
588 * Double dash has been found, ignore
589 * any more options. But what do we do
590 * with it? For now treat it like a target.
592 Lst_AtEnd(&create, estrdup(*argv));
595 * (*argv) is a -flag, so backup argv and
596 * argc. getopt() expects options to start
597 * in the 2nd position.
604 } else if ((*argv)[0] == '\0') {
605 Punt("illegal (null) argument.");
608 Lst_AtEnd(&create, estrdup(*argv));
615 * Used by the parse module when a .MFLAGS or .MAKEFLAGS target
616 * is encountered and by main() when reading the .MAKEFLAGS envariable.
617 * Takes a line of arguments and breaks it into its
618 * component words and passes those words and the number of them to the
619 * MainParseArgs function.
620 * The line should have all its leading whitespace removed.
623 * Only those that come from the various arguments.
626 Main_ParseArgLine(MakeFlags *mf, char line[], int mflags)
632 for (; *line == ' '; ++line)
638 MAKEFLAGS_break(&aa, line);
640 brk_string(&aa, line, TRUE);
642 MainParseArgs(mf, aa.argc, aa.argv);
647 * Try to change the current working directory into path.
650 chdir_verify_path(const char path[], char newdir[])
655 * Check if the path is a directory. If not fail without reporting
658 if (stat(path, &sb) < 0) {
659 return (0); /* fail but no report */
661 if (S_ISDIR(sb.st_mode) == 0) {
666 * The path refers to a directory, so we try to change into it. If we
667 * fail, or we fail to obtain the path from root to the directory,
668 * then report an error and fail.
670 if (chdir(path) < 0) {
671 warn("warning: %s", path);
674 if (getcwd(newdir, MAXPATHLEN) == NULL) {
675 warn("warning: %s", path);
682 determine_objdir(const char machine[], char curdir[], char objdir[])
685 char newdir[MAXPATHLEN];
686 char mdpath[MAXPATHLEN];
690 * Find a path to where we are... [-C directory] might have changed
691 * our current directory.
693 if (getcwd(curdir, MAXPATHLEN) == NULL)
696 if (stat(curdir, &sa) == -1)
697 err(2, "%s", curdir);
700 * The object directory location is determined using the
701 * following order of preference:
703 * 1. MAKEOBJDIRPREFIX`cwd`
705 * 3. PATH_OBJDIR.${MACHINE}
707 * 5. PATH_OBJDIRPREFIX`cwd`
709 * If one of the first two fails, use the current directory.
710 * If the remaining three all fail, use the current directory.
712 if ((env = getenv("MAKEOBJDIRPREFIX")) != NULL) {
713 snprintf(mdpath, MAXPATHLEN, "%s%s", env, curdir);
714 if (chdir_verify_path(mdpath, newdir)) {
715 strcpy(objdir, newdir);
718 strcpy(objdir, curdir);
722 if ((env = getenv("MAKEOBJDIR")) != NULL) {
723 if (chdir_verify_path(env, newdir)) {
724 strcpy(objdir, newdir);
727 strcpy(objdir, curdir);
731 snprintf(mdpath, MAXPATHLEN, "%s.%s", PATH_OBJDIR, machine);
732 if (chdir_verify_path(mdpath, newdir)) {
733 strcpy(objdir, newdir);
737 if (chdir_verify_path(PATH_OBJDIR, newdir)) {
738 strcpy(objdir, newdir);
742 snprintf(mdpath, MAXPATHLEN, "%s%s", PATH_OBJDIRPREFIX, curdir);
743 if (chdir_verify_path(mdpath, newdir)) {
744 strcpy(objdir, newdir);
748 strcpy(objdir, curdir);
752 * Initialize various make variables.
753 * MAKE also gets this name, for compatibility
754 * .MAKEFLAGS gets set to the empty string just in case.
755 * MFLAGS also gets initialized empty, for compatibility.
758 InitVariables(MakeFlags *mf, int argc, char *argv[], char curdir[], char objdir[])
761 const char *machine_arch;
762 const char *machine_cpu;
767 Var_SetGlobal("MAKE", argv[0]);
768 Var_SetGlobal(".MAKEFLAGS", "");
769 Var_SetGlobal("MFLAGS", "");
771 Var_SetGlobal(".DIRECTIVE_MAKEENV", "YES");
772 Var_SetGlobal(".ST_EXPORTVAR", "YES");
774 Var_SetGlobal("MAKE_VERSION", MAKE_VERSION);
778 * Get the name of this type of MACHINE from utsname
779 * so we can share an executable for similar machines.
780 * (i.e. m68k: amiga hp300, mac68k, sun3, ...)
782 * Note that while MACHINE is decided at run-time,
783 * MACHINE_ARCH is always known at compile time.
785 if ((machine = getenv("MACHINE")) == NULL) {
789 static struct utsname utsname;
790 if (uname(&utsname) == -1)
792 machine = utsname.machine;
796 if ((machine_arch = getenv("MACHINE_ARCH")) == NULL) {
798 machine_arch = MACHINE_ARCH;
800 machine_arch = "unknown";
805 * Set machine_cpu to the minumum supported CPU revision based
806 * on the target architecture, if not already set.
808 if ((machine_cpu = getenv("MACHINE_CPU")) == NULL) {
809 if (!strcmp(machine_arch, "i386"))
810 machine_cpu = "i386";
811 else if (!strcmp(machine_arch, "alpha"))
814 machine_cpu = "unknown";
817 Var_SetGlobal("MACHINE", machine);
818 Var_SetGlobal("MACHINE_ARCH", machine_arch);
819 Var_SetGlobal("MACHINE_CPU", machine_cpu);
822 * First snag things out of the MAKEFLAGS environment
823 * variable. Then parse the command line arguments.
825 Main_ParseArgLine(mf, getenv("MAKEFLAGS"), 1);
827 MainParseArgs(mf, argc, argv);
829 determine_objdir(machine, curdir, objdir);
830 Var_SetGlobal(".CURDIR", curdir);
831 Var_SetGlobal(".OBJDIR", objdir);
834 * Set up the .TARGETS variable to contain the list of targets to be
835 * created. If none specified, make the variable empty -- the parser
836 * will fill the thing in with the default or .MAIN target.
838 if (Lst_IsEmpty(&create)) {
839 Var_SetGlobal(".TARGETS", "");
843 for (ln = Lst_First(&create); ln != NULL; ln = Lst_Succ(ln)) {
844 char *name = Lst_Datum(ln);
846 Var_Append(".TARGETS", name, VAR_GLOBAL);
853 * The main function, for obvious reasons. Initializes variables
854 * and a few modules, then parses the arguments give it in the
855 * environment and on the command line. Reads the system makefile
856 * followed by either Makefile, makefile or the file given by the
857 * -f argument. Sets the .MAKEFLAGS PMake variable based on all the
858 * flags it has received by then uses either the Make or the Compat
859 * module to create the initial list of targets.
862 * If -q was given, exits -1 if anything was out-of-date. Else it exits
866 * The program exits when done. Targets are created. etc. etc. etc.
869 main(int argc, char **argv)
872 Boolean outOfDate = TRUE; /* FALSE if all targets up to date */
874 char curdir[MAXPATHLEN]; /* startup directory */
875 char objdir[MAXPATHLEN]; /* where we chdir'ed to */
878 * Initialize program global variables.
880 beSilent = FALSE; /* Print commands as executed */
881 ignoreErrors = FALSE; /* Pay attention to non-zero returns */
882 noExecute = FALSE; /* Execute all commands */
883 keepgoing = FALSE; /* Stop on error */
884 allPrecious = FALSE; /* Remove targets when interrupted */
885 touchFlag = FALSE; /* Actually update targets */
886 usePipes = TRUE; /* Catch child output in pipes */
887 debug = 0; /* No debug verbosity, please. */
890 jobLimit = DEFMAXJOBS;
891 compatMake = FALSE; /* No compat mode */
894 * Initialize make flags variable.
896 Lst_Init(&mf.makefiles);
897 Lst_Init(&mf.variables);
899 mf.expandVars = TRUE;
900 mf.noBuiltins = FALSE; /* Read the built-in rules */
901 mf.queryFlag = FALSE;
903 if (getenv("MAKE_JOBS_FIFO") == NULL)
904 mf.forceJobs = FALSE;
909 * Initialize the parsing, directory and variable modules to prepare
910 * for the reading of inclusion paths and variable settings on the
916 InitVariables(&mf, argc, argv, curdir, objdir);
919 * Once things are initialized, add the original directory to the
920 * search path. The current directory is also placed as a variable
925 Dir_InitDot(); /* Initialize the "." directory */
927 if (strcmp(objdir, curdir) != 0)
928 Path_AddDir(&dirSearchPath, curdir);
931 * Be compatible if user did not specify -j and did not explicitly
932 * turned compatibility on
934 if (!compatMake && !mf.forceJobs)
938 * Initialize target and suffix modules in preparation for
939 * parsing the makefile(s)
948 * If no user-supplied system path was given (through the -m option)
949 * add the directories from the DEFSYSPATH (more than one may be given
950 * as dir1:...:dirn) to the system include path.
952 if (TAILQ_EMPTY(&sysIncPath)) {
953 char syspath[] = PATH_DEFSYSPATH;
957 for (start = syspath; *start != '\0'; start = cp) {
958 for (cp = start; *cp != '\0' && *cp != ':'; cp++)
961 Path_AddDir(&sysIncPath, start);
964 Path_AddDir(&sysIncPath, start);
970 ReadInputFiles(&mf, curdir, objdir);
972 /* Install all the flags into the MAKE envariable. */
976 if (((p = Var_Value(".MAKEFLAGS", VAR_GLOBAL)) != NULL) && *p)
977 setenv("MAKEFLAGS", p, 1);
981 * For compatibility, look at the directories in the VPATH variable
982 * and add them to the search path, if the variable is defined. The
983 * variable's value is in the same format as the PATH envariable, i.e.
984 * <directory>:<directory>:<directory>...
986 if (Var_Exists("VPATH", VAR_CMD)) {
991 buf = Var_Subst("${VPATH}", VAR_CMD, FALSE);
992 vpath = Buf_Data(buf);
995 /* skip to end of directory */
996 for (ptr = vpath; *ptr != ':' && *ptr != '\0'; ptr++)
999 /* Save terminator character so know when to stop */
1003 /* Add directory to search path */
1004 Path_AddDir(&dirSearchPath, vpath);
1007 } while (savec != '\0');
1009 Buf_Destroy(buf, TRUE);
1013 * Now that all search paths have been read for suffixes et al, it's
1014 * time to add the default search path to their lists...
1018 /* print the initial graph, if the user requested it */
1022 /* print the values of any variables requested by the user */
1023 if (Lst_IsEmpty(&mf.variables)) {
1025 * Since the user has not requested that any variables
1026 * be printed, we can build targets.
1028 * Have read the entire graph and need to make a list of targets
1029 * to create. If none was given on the command line, we consult
1030 * the parsing module to find the main target(s) to create.
1032 Lst targs = Lst_Initializer(targs);
1034 if (Lst_IsEmpty(&create))
1035 Parse_MainName(&targs);
1037 Targ_FindList(&targs, &create, TARG_CREATE);
1039 /* Traverse the graph, checking on all the targets */
1041 outOfDate = Compat_Run(&targs, mf.queryFlag);
1043 outOfDate = Make_Run(&targs, mf.queryFlag);
1045 Lst_Destroy(&targs, NOFREE);
1048 Var_Print(&mf.variables, mf.expandVars);
1051 Lst_Destroy(&mf.variables, free);
1052 Lst_Destroy(&mf.makefiles, free);
1053 Lst_Destroy(&create, free);
1055 /* print the graph now it's been processed if the user requested it */
1059 if (mf.queryFlag && outOfDate)