usr.bin/make/main.c

   1 /*
   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
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to Berkeley by
   8  * Adam de Boor.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  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.
  25  *
  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
  36  * SUCH DAMAGE.
  37  *
  38  * @(#)main.c      8.3 (Berkeley) 3/19/94
  39  */
  40
  41 #ifndef lint
  42 #if 0
  43 static char copyright[] =
  44 "@(#) Copyright (c) 1988, 1989, 1990, 1993\n\
  45         The Regents of the University of California.  All rights reserved.\n";
  46 #endif
  47 #endif /* not lint */
  48 #include <sys/cdefs.h>
  49 __FBSDID("$FreeBSD$");
  50
  51 /*-
  52  * main.c --
  53  *      The main file for this entire program. Exit routines etc
  54  *      reside here.
  55  *
  56  * Utility functions defined in this file:
  57  *      Main_ParseArgLine       Takes a line of arguments, breaks them and
  58  *                              treats them as if they were given when first
  59  *                              invoked. Used by the parse module to implement
  60  *                              the .MFLAGS target.
  61  *
  62  *      Error                   Print a tagged error message. The global
  63  *                              MAKE variable must have been defined. This
  64  *                              takes a format string and two optional
  65  *                              arguments for it.
  66  *
  67  *      Fatal                   Print an error message and exit. Also takes
  68  *                              a format string and two arguments.
  69  *
  70  *      Punt                    Aborts all jobs and exits with a message. Also
  71  *                              takes a format string and two arguments.
  72  *
  73  *      Finish                  Finish things up by printing the number of
  74  *                              errors which occured, as passed to it, and
  75  *                              exiting.
  76  */
  77
  78 #include <sys/types.h>
  79 #include <sys/time.h>
  80 #include <sys/param.h>
  81 #include <sys/resource.h>
  82 #include <sys/signal.h>
  83 #include <sys/stat.h>
  84 #if defined(__i386__)
  85 #include <sys/sysctl.h>
  86 #endif
  87 #ifndef MACHINE
  88 #include <sys/utsname.h>
  89 #endif
  90 #include <sys/wait.h>
  91 #include <err.h>
  92 #include <stdlib.h>
  93 #include <errno.h>
  94 #include <fcntl.h>
  95 #include <stdio.h>
  96 #include <sysexits.h>
  97 #include <stdarg.h>
  98 #include <unistd.h>
  99 #include "make.h"
 100 #include "hash.h"
 101 #include "dir.h"
 102 #include "job.h"
 103 #include "pathnames.h"
 104
 105 #ifndef DEFMAXLOCAL
 106 #define DEFMAXLOCAL DEFMAXJOBS
 107 #endif  /* DEFMAXLOCAL */
 108
 109 #define MAKEFLAGS       ".MAKEFLAGS"
 110
 111 Lst                     create;         /* Targets to be made */
 112 time_t                  now;            /* Time at start of make */
 113 GNode                   *DEFAULT;       /* .DEFAULT node */
 114 Boolean                 allPrecious;    /* .PRECIOUS given on line by itself */
 115
 116 static Boolean          noBuiltins;     /* -r flag */
 117 static Lst              makefiles;      /* ordered list of makefiles to read */
 118 static Boolean          printVars;      /* print value of one or more vars */
 119 static Boolean          expandVars;     /* fully expand printed variables */
 120 static Lst              variables;      /* list of variables to print */
 121 int                     maxJobs;        /* -j argument */
 122 static Boolean          forceJobs;      /* -j argument given */
 123 static int              maxLocal;       /* -L argument */
 124 Boolean                 compatMake;     /* -B argument */
 125 Boolean                 debug;          /* -d flag */
 126 Boolean                 noExecute;      /* -n flag */
 127 Boolean                 keepgoing;      /* -k flag */
 128 Boolean                 queryFlag;      /* -q flag */
 129 Boolean                 touchFlag;      /* -t flag */
 130 Boolean                 usePipes;       /* !-P flag */
 131 Boolean                 ignoreErrors;   /* -i flag */
 132 Boolean                 beSilent;       /* -s flag */
 133 Boolean                 beVerbose;      /* -v flag */
 134 Boolean                 oldVars;        /* variable substitution style */
 135 Boolean                 checkEnvFirst;  /* -e flag */
 136 Lst                     envFirstVars;   /* (-E) vars to override from env */
 137 static Boolean          jobsRunning;    /* TRUE if the jobs might be running */
 138
 139 static void             MainParseArgs(int, char **);
 140 char *                  chdir_verify_path(char *, char *);
 141 static int              ReadMakefile(void *, void *);
 142 static void             usage(void);
 143
 144 static char *curdir;                    /* startup directory */
 145 static char *objdir;                    /* where we chdir'ed to */
 146
 147 /*-
 148  * MainParseArgs --
 149  *      Parse a given argument vector. Called from main() and from
 150  *      Main_ParseArgLine() when the .MAKEFLAGS target is used.
 151  *
 152  *      XXX: Deal with command line overriding .MAKEFLAGS in makefile
 153  *
 154  * Results:
 155  *      None
 156  *
 157  * Side Effects:
 158  *      Various global and local flags will be set depending on the flags
 159  *      given
 160  */
 161 static void
 162 MainParseArgs(argc, argv)
 163         int argc;
 164         char **argv;
 165 {
 166         char *p;
 167         int c;
 168
 169         optind = 1;     /* since we're called more than once */
 170 #ifdef REMOTE
 171 # define OPTFLAGS "BD:E:I:L:PSV:Xd:ef:ij:km:nqrstv"
 172 #else
 173 # define OPTFLAGS "BD:E:I:PSV:Xd:ef:ij:km:nqrstv"
 174 #endif
 175 rearg:  while((c = getopt(argc, argv, OPTFLAGS)) != -1) {
 176                 switch(c) {
 177                 case 'D':
 178                         Var_Set(optarg, "1", VAR_GLOBAL);
 179                         Var_Append(MAKEFLAGS, "-D", VAR_GLOBAL);
 180                         Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
 181                         break;
 182                 case 'I':
 183                         Parse_AddIncludeDir(optarg);
 184                         Var_Append(MAKEFLAGS, "-I", VAR_GLOBAL);
 185                         Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
 186                         break;
 187                 case 'V':
 188                         printVars = TRUE;
 189                         (void)Lst_AtEnd(variables, (void *)optarg);
 190                         Var_Append(MAKEFLAGS, "-V", VAR_GLOBAL);
 191                         Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
 192                         break;
 193                 case 'X':
 194                         expandVars = FALSE;
 195                         break;
 196                 case 'B':
 197                         compatMake = TRUE;
 198                         Var_Append(MAKEFLAGS, "-B", VAR_GLOBAL);
 199                         break;
 200 #ifdef REMOTE
 201                 case 'L': {
 202                         char *endptr;
 203
 204                         maxLocal = strtol(optarg, &endptr, 10);
 205                         if (maxLocal < 0 || *endptr != '\0') {
 206                                 warnx("illegal number, -L argument -- %s",
 207                                     optarg);
 208                                 usage();
 209                         }
 210                         Var_Append(MAKEFLAGS, "-L", VAR_GLOBAL);
 211                         Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
 212                         break;
 213                 }
 214 #endif
 215                 case 'P':
 216                         usePipes = FALSE;
 217                         Var_Append(MAKEFLAGS, "-P", VAR_GLOBAL);
 218                         break;
 219                 case 'S':
 220                         keepgoing = FALSE;
 221                         Var_Append(MAKEFLAGS, "-S", VAR_GLOBAL);
 222                         break;
 223                 case 'd': {
 224                         char *modules = optarg;
 225
 226                         for (; *modules; ++modules)
 227                                 switch (*modules) {
 228                                 case 'A':
 229                                         debug = ~0;
 230                                         break;
 231                                 case 'a':
 232                                         debug |= DEBUG_ARCH;
 233                                         break;
 234                                 case 'c':
 235                                         debug |= DEBUG_COND;
 236                                         break;
 237                                 case 'd':
 238                                         debug |= DEBUG_DIR;
 239                                         break;
 240                                 case 'f':
 241                                         debug |= DEBUG_FOR;
 242                                         break;
 243                                 case 'g':
 244                                         if (modules[1] == '1') {
 245                                                 debug |= DEBUG_GRAPH1;
 246                                                 ++modules;
 247                                         }
 248                                         else if (modules[1] == '2') {
 249                                                 debug |= DEBUG_GRAPH2;
 250                                                 ++modules;
 251                                         }
 252                                         break;
 253                                 case 'j':
 254                                         debug |= DEBUG_JOB;
 255                                         break;
 256                                 case 'l':
 257                                         debug |= DEBUG_LOUD;
 258                                         break;
 259                                 case 'm':
 260                                         debug |= DEBUG_MAKE;
 261                                         break;
 262                                 case 's':
 263                                         debug |= DEBUG_SUFF;
 264                                         break;
 265                                 case 't':
 266                                         debug |= DEBUG_TARG;
 267                                         break;
 268                                 case 'v':
 269                                         debug |= DEBUG_VAR;
 270                                         break;
 271                                 default:
 272                                         warnx("illegal argument to d option -- %c", *modules);
 273                                         usage();
 274                                 }
 275                         Var_Append(MAKEFLAGS, "-d", VAR_GLOBAL);
 276                         Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
 277                         break;
 278                 }
 279                 case 'E':
 280                         p = emalloc(strlen(optarg) + 1);
 281                         (void)strcpy(p, optarg);
 282                         (void)Lst_AtEnd(envFirstVars, (void *)p);
 283                         Var_Append(MAKEFLAGS, "-E", VAR_GLOBAL);
 284                         Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
 285                         break;
 286                 case 'e':
 287                         checkEnvFirst = TRUE;
 288                         Var_Append(MAKEFLAGS, "-e", VAR_GLOBAL);
 289                         break;
 290                 case 'f':
 291                         (void)Lst_AtEnd(makefiles, (void *)optarg);
 292                         break;
 293                 case 'i':
 294                         ignoreErrors = TRUE;
 295                         Var_Append(MAKEFLAGS, "-i", VAR_GLOBAL);
 296                         break;
 297                 case 'j': {
 298                         char *endptr;
 299
 300                         forceJobs = TRUE;
 301                         maxJobs = strtol(optarg, &endptr, 10);
 302                         if (maxJobs <= 0 || *endptr != '\0') {
 303                                 warnx("illegal number, -j argument -- %s",
 304                                     optarg);
 305                                 usage();
 306                         }
 307 #ifndef REMOTE
 308                         maxLocal = maxJobs;
 309 #endif
 310                         Var_Append(MAKEFLAGS, "-j", VAR_GLOBAL);
 311                         Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
 312                         break;
 313                 }
 314                 case 'k':
 315                         keepgoing = TRUE;
 316                         Var_Append(MAKEFLAGS, "-k", VAR_GLOBAL);
 317                         break;
 318                 case 'm':
 319                         Dir_AddDir(sysIncPath, optarg);
 320                         Var_Append(MAKEFLAGS, "-m", VAR_GLOBAL);
 321                         Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
 322                         break;
 323                 case 'n':
 324                         noExecute = TRUE;
 325                         Var_Append(MAKEFLAGS, "-n", VAR_GLOBAL);
 326                         break;
 327                 case 'q':
 328                         queryFlag = TRUE;
 329                         /* Kind of nonsensical, wot? */
 330                         Var_Append(MAKEFLAGS, "-q", VAR_GLOBAL);
 331                         break;
 332                 case 'r':
 333                         noBuiltins = TRUE;
 334                         Var_Append(MAKEFLAGS, "-r", VAR_GLOBAL);
 335                         break;
 336                 case 's':
 337                         beSilent = TRUE;
 338                         Var_Append(MAKEFLAGS, "-s", VAR_GLOBAL);
 339                         break;
 340                 case 't':
 341                         touchFlag = TRUE;
 342                         Var_Append(MAKEFLAGS, "-t", VAR_GLOBAL);
 343                         break;
 344                 case 'v':
 345                         beVerbose = TRUE;
 346                         Var_Append(MAKEFLAGS, "-v", VAR_GLOBAL);
 347                         break;
 348                 default:
 349                 case '?':
 350                         usage();
 351                 }
 352         }
 353
 354         oldVars = TRUE;
 355
 356         /*
 357          * See if the rest of the arguments are variable assignments and
 358          * perform them if so. Else take them to be targets and stuff them
 359          * on the end of the "create" list.
 360          */
 361         for (argv += optind, argc -= optind; *argv; ++argv, --argc)
 362                 if (Parse_IsVar(*argv))
 363                         Parse_DoVar(*argv, VAR_CMD);
 364                 else {
 365                         if (!**argv)
 366                                 Punt("illegal (null) argument.");
 367                         if (**argv == '-') {
 368                                 if ((*argv)[1])
 369                                         optind = 0;     /* -flag... */
 370                                 else
 371                                         optind = 1;     /* - */
 372                                 goto rearg;
 373                         }
 374                         (void)Lst_AtEnd(create, (void *)estrdup(*argv));
 375                 }
 376 }
 377
 378 /*-
 379  * Main_ParseArgLine --
 380  *      Used by the parse module when a .MFLAGS or .MAKEFLAGS target
 381  *      is encountered and by main() when reading the .MAKEFLAGS envariable.
 382  *      Takes a line of arguments and breaks it into its
 383  *      component words and passes those words and the number of them to the
 384  *      MainParseArgs function.
 385  *      The line should have all its leading whitespace removed.
 386  *
 387  * Results:
 388  *      None
 389  *
 390  * Side Effects:
 391  *      Only those that come from the various arguments.
 392  */
 393 void
 394 Main_ParseArgLine(line)
 395         char *line;                     /* Line to fracture */
 396 {
 397         char **argv;                    /* Manufactured argument vector */
 398         int argc;                       /* Number of arguments in argv */
 399
 400         if (line == NULL)
 401                 return;
 402         for (; *line == ' '; ++line)
 403                 continue;
 404         if (!*line)
 405                 return;
 406
 407         argv = brk_string(line, &argc, TRUE);
 408         MainParseArgs(argc, argv);
 409 }
 410
 411 char *
 412 chdir_verify_path(path, obpath)
 413         char *path;
 414         char *obpath;
 415 {
 416         struct stat sb;
 417
 418         if (stat(path, &sb) == 0 && S_ISDIR(sb.st_mode)) {
 419                 if (chdir(path) == -1 || getcwd(obpath, MAXPATHLEN) == NULL) {
 420                         warn("warning: %s", path);
 421                         return 0;
 422                 }
 423                 return obpath;
 424         }
 425
 426         return 0;
 427 }
 428
 429
 430 /*-
 431  * main --
 432  *      The main function, for obvious reasons. Initializes variables
 433  *      and a few modules, then parses the arguments give it in the
 434  *      environment and on the command line. Reads the system makefile
 435  *      followed by either Makefile, makefile or the file given by the
 436  *      -f argument. Sets the .MAKEFLAGS PMake variable based on all the
 437  *      flags it has received by then uses either the Make or the Compat
 438  *      module to create the initial list of targets.
 439  *
 440  * Results:
 441  *      If -q was given, exits -1 if anything was out-of-date. Else it exits
 442  *      0.
 443  *
 444  * Side Effects:
 445  *      The program exits when done. Targets are created. etc. etc. etc.
 446  */
 447 int
 448 main(argc, argv)
 449         int argc;
 450         char **argv;
 451 {
 452         Lst targs;      /* target nodes to create -- passed to Make_Init */
 453         Boolean outOfDate = TRUE;       /* FALSE if all targets up to date */
 454         struct stat sa;
 455         char *p, *p1, *path, *pathp;
 456         char mdpath[MAXPATHLEN];
 457         char obpath[MAXPATHLEN];
 458         char cdpath[MAXPATHLEN];
 459         char *machine = getenv("MACHINE");
 460         char *machine_arch = getenv("MACHINE_ARCH");
 461         char *machine_cpu = getenv("MACHINE_CPU");
 462         Lst sysMkPath;                  /* Path of sys.mk */
 463         char *cp = NULL, *start;
 464                                         /* avoid faults on read-only strings */
 465         static char syspath[] = _PATH_DEFSYSPATH;
 466
 467 #if DEFSHELL == 2
 468         /*
 469          * Turn off ENV to make ksh happier.
 470          */
 471         unsetenv("ENV");
 472 #endif
 473
 474 #ifdef RLIMIT_NOFILE
 475         /*
 476          * get rid of resource limit on file descriptors
 477          */
 478         {
 479                 struct rlimit rl;
 480                 if (getrlimit(RLIMIT_NOFILE, &rl) != -1 &&
 481                     rl.rlim_cur != rl.rlim_max) {
 482                         rl.rlim_cur = rl.rlim_max;
 483                         (void) setrlimit(RLIMIT_NOFILE, &rl);
 484                 }
 485         }
 486 #endif
 487         /*
 488          * Find where we are...
 489          * All this code is so that we know where we are when we start up
 490          * on a different machine with pmake.
 491          */
 492         curdir = cdpath;
 493         if (getcwd(curdir, MAXPATHLEN) == NULL)
 494                 err(2, NULL);
 495
 496         if (stat(curdir, &sa) == -1)
 497             err(2, "%s", curdir);
 498
 499 #if defined(__i386__) && defined(__FreeBSD_version) && \
 500     __FreeBSD_version > 300003
 501         /*
 502          * PC-98 kernel sets the `i386' string to the utsname.machine and
 503          * it cannot be distinguished from IBM-PC by uname(3).  Therefore,
 504          * we check machine.ispc98 and adjust the machine variable before
 505          * using usname(3) below.
 506          * NOTE: machdep.ispc98 was defined on 1998/8/31. At that time,
 507          * __FreeBSD_version was defined as 300003. So, this check can
 508          * safely be done with any kernel with version > 300003.
 509          */
 510         if (!machine) {
 511                 int     ispc98;
 512                 size_t  len;
 513
 514                 len = sizeof(ispc98);
 515                 if (!sysctlbyname("machdep.ispc98", &ispc98, &len, NULL, 0)) {
 516                         if (ispc98)
 517                                 machine = "pc98";
 518                 }
 519         }
 520 #endif
 521
 522         /*
 523          * Get the name of this type of MACHINE from utsname
 524          * so we can share an executable for similar machines.
 525          * (i.e. m68k: amiga hp300, mac68k, sun3, ...)
 526          *
 527          * Note that while MACHINE is decided at run-time,
 528          * MACHINE_ARCH is always known at compile time.
 529          */
 530         if (!machine) {
 531 #ifndef MACHINE
 532             struct utsname utsname;
 533
 534             if (uname(&utsname) == -1)
 535                     err(2, "uname");
 536             machine = utsname.machine;
 537 #else
 538             machine = MACHINE;
 539 #endif
 540         }
 541
 542         if (!machine_arch) {
 543 #ifndef MACHINE_ARCH
 544                 machine_arch = "unknown";
 545 #else
 546                 machine_arch = MACHINE_ARCH;
 547 #endif
 548         }
 549
 550         /*
 551          * Set machine_cpu to the minumum supported CPU revision based
 552          * on the target architecture, if not already set.
 553          */
 554         if (!machine_cpu) {
 555                 if (!strcmp(machine_arch, "i386"))
 556                         machine_cpu = "i386";
 557                 else if (!strcmp(machine_arch, "alpha"))
 558                         machine_cpu = "ev4";
 559                 else
 560                         machine_cpu = "unknown";
 561         }
 562
 563         /*
 564          * The object directory location is determined using the
 565          * following order of preference:
 566          *
 567          *      1. MAKEOBJDIRPREFIX`cwd`
 568          *      2. MAKEOBJDIR
 569          *      3. _PATH_OBJDIR.${MACHINE}
 570          *      4. _PATH_OBJDIR
 571          *      5. _PATH_OBJDIRPREFIX`cwd`
 572          *
 573          * If one of the first two fails, use the current directory.
 574          * If the remaining three all fail, use the current directory.
 575          *
 576          * Once things are initted,
 577          * have to add the original directory to the search path,
 578          * and modify the paths for the Makefiles apropriately.  The
 579          * current directory is also placed as a variable for make scripts.
 580          */
 581         if (!(pathp = getenv("MAKEOBJDIRPREFIX"))) {
 582                 if (!(path = getenv("MAKEOBJDIR"))) {
 583                         path = _PATH_OBJDIR;
 584                         pathp = _PATH_OBJDIRPREFIX;
 585                         (void) snprintf(mdpath, MAXPATHLEN, "%s.%s",
 586                                         path, machine);
 587                         if (!(objdir = chdir_verify_path(mdpath, obpath)))
 588                                 if (!(objdir=chdir_verify_path(path, obpath))) {
 589                                         (void) snprintf(mdpath, MAXPATHLEN,
 590                                                         "%s%s", pathp, curdir);
 591                                         if (!(objdir=chdir_verify_path(mdpath,
 592                                                                        obpath)))
 593                                                 objdir = curdir;
 594                                 }
 595                 }
 596                 else if (!(objdir = chdir_verify_path(path, obpath)))
 597                         objdir = curdir;
 598         }
 599         else {
 600                 (void) snprintf(mdpath, MAXPATHLEN, "%s%s", pathp, curdir);
 601                 if (!(objdir = chdir_verify_path(mdpath, obpath)))
 602                         objdir = curdir;
 603         }
 604
 605         create = Lst_Init(FALSE);
 606         makefiles = Lst_Init(FALSE);
 607         envFirstVars = Lst_Init(FALSE);
 608         printVars = FALSE;
 609         expandVars = TRUE;
 610         variables = Lst_Init(FALSE);
 611         beSilent = FALSE;               /* Print commands as executed */
 612         ignoreErrors = FALSE;           /* Pay attention to non-zero returns */
 613         noExecute = FALSE;              /* Execute all commands */
 614         keepgoing = FALSE;              /* Stop on error */
 615         allPrecious = FALSE;            /* Remove targets when interrupted */
 616         queryFlag = FALSE;              /* This is not just a check-run */
 617         noBuiltins = FALSE;             /* Read the built-in rules */
 618         touchFlag = FALSE;              /* Actually update targets */
 619         usePipes = TRUE;                /* Catch child output in pipes */
 620         debug = 0;                      /* No debug verbosity, please. */
 621         jobsRunning = FALSE;
 622
 623         maxLocal = DEFMAXLOCAL;         /* Set default local max concurrency */
 624 #ifdef REMOTE
 625         maxJobs = DEFMAXJOBS;           /* Set default max concurrency */
 626 #else
 627         maxJobs = maxLocal;
 628 #endif
 629         forceJobs = FALSE;              /* No -j flag */
 630         compatMake = FALSE;             /* No compat mode */
 631
 632
 633         /*
 634          * Initialize the parsing, directory and variable modules to prepare
 635          * for the reading of inclusion paths and variable settings on the
 636          * command line
 637          */
 638         Dir_Init();             /* Initialize directory structures so -I flags
 639                                  * can be processed correctly */
 640         Parse_Init();           /* Need to initialize the paths of #include
 641                                  * directories */
 642         Var_Init();             /* As well as the lists of variables for
 643                                  * parsing arguments */
 644         str_init();
 645         if (objdir != curdir)
 646                 Dir_AddDir(dirSearchPath, curdir);
 647         Var_Set(".CURDIR", curdir, VAR_GLOBAL);
 648         Var_Set(".OBJDIR", objdir, VAR_GLOBAL);
 649
 650         /*
 651          * Initialize various variables.
 652          *      MAKE also gets this name, for compatibility
 653          *      .MAKEFLAGS gets set to the empty string just in case.
 654          *      MFLAGS also gets initialized empty, for compatibility.
 655          */
 656         Var_Set("MAKE", argv[0], VAR_GLOBAL);
 657         Var_Set(MAKEFLAGS, "", VAR_GLOBAL);
 658         Var_Set("MFLAGS", "", VAR_GLOBAL);
 659         Var_Set("MACHINE", machine, VAR_GLOBAL);
 660         Var_Set("MACHINE_ARCH", machine_arch, VAR_GLOBAL);
 661         Var_Set("MACHINE_CPU", machine_cpu, VAR_GLOBAL);
 662
 663         /*
 664          * First snag any flags out of the MAKE environment variable.
 665          * (Note this is *not* MAKEFLAGS since /bin/make uses that and it's
 666          * in a different format).
 667          */
 668 #ifdef POSIX
 669         Main_ParseArgLine(getenv("MAKEFLAGS"));
 670 #else
 671         Main_ParseArgLine(getenv("MAKE"));
 672 #endif
 673
 674         MainParseArgs(argc, argv);
 675
 676         /*
 677          * Be compatible if user did not specify -j and did not explicitly
 678          * turned compatibility on
 679          */
 680         if (!compatMake && !forceJobs)
 681                 compatMake = TRUE;
 682
 683         /*
 684          * Initialize archive, target and suffix modules in preparation for
 685          * parsing the makefile(s)
 686          */
 687         Arch_Init();
 688         Targ_Init();
 689         Suff_Init();
 690
 691         DEFAULT = NULL;
 692         (void)time(&now);
 693
 694         /*
 695          * Set up the .TARGETS variable to contain the list of targets to be
 696          * created. If none specified, make the variable empty -- the parser
 697          * will fill the thing in with the default or .MAIN target.
 698          */
 699         if (!Lst_IsEmpty(create)) {
 700                 LstNode ln;
 701
 702                 for (ln = Lst_First(create); ln != NULL;
 703                     ln = Lst_Succ(ln)) {
 704                         char *name = (char *)Lst_Datum(ln);
 705
 706                         Var_Append(".TARGETS", name, VAR_GLOBAL);
 707                 }
 708         } else
 709                 Var_Set(".TARGETS", "", VAR_GLOBAL);
 710
 711
 712         /*
 713          * If no user-supplied system path was given (through the -m option)
 714          * add the directories from the DEFSYSPATH (more than one may be given
 715          * as dir1:...:dirn) to the system include path.
 716          */
 717         if (Lst_IsEmpty(sysIncPath)) {
 718                 for (start = syspath; *start != '\0'; start = cp) {
 719                         for (cp = start; *cp != '\0' && *cp != ':'; cp++)
 720                                 continue;
 721                         if (*cp == '\0') {
 722                                 Dir_AddDir(sysIncPath, start);
 723                         } else {
 724                                 *cp++ = '\0';
 725                                 Dir_AddDir(sysIncPath, start);
 726                         }
 727                 }
 728         }
 729
 730         /*
 731          * Read in the built-in rules first, followed by the specified
 732          * makefile, if it was (makefile != (char *) NULL), or the default
 733          * Makefile and makefile, in that order, if it wasn't.
 734          */
 735         if (!noBuiltins) {
 736                 LstNode ln;
 737
 738                 sysMkPath = Lst_Init (FALSE);
 739                 Dir_Expand (_PATH_DEFSYSMK, sysIncPath, sysMkPath);
 740                 if (Lst_IsEmpty(sysMkPath))
 741                         Fatal("make: no system rules (%s).", _PATH_DEFSYSMK);
 742                 ln = Lst_Find(sysMkPath, (void *)NULL, ReadMakefile);
 743                 if (ln != NULL)
 744                         Fatal("make: cannot open %s.", (char *)Lst_Datum(ln));
 745         }
 746
 747         if (!Lst_IsEmpty(makefiles)) {
 748                 LstNode ln;
 749
 750                 ln = Lst_Find(makefiles, (void *)NULL, ReadMakefile);
 751                 if (ln != NULL)
 752                         Fatal("make: cannot open %s.", (char *)Lst_Datum(ln));
 753         } else if (!ReadMakefile("BSDmakefile", NULL))
 754             if (!ReadMakefile("makefile", NULL))
 755                 (void)ReadMakefile("Makefile", NULL);
 756
 757         (void)ReadMakefile(".depend", NULL);
 758
 759         Var_Append("MFLAGS", Var_Value(MAKEFLAGS, VAR_GLOBAL, &p1), VAR_GLOBAL);
 760         efree(p1);
 761
 762         /* Install all the flags into the MAKE envariable. */
 763         if (((p = Var_Value(MAKEFLAGS, VAR_GLOBAL, &p1)) != NULL) && *p)
 764 #ifdef POSIX
 765                 setenv("MAKEFLAGS", p, 1);
 766 #else
 767                 setenv("MAKE", p, 1);
 768 #endif
 769         efree(p1);
 770
 771         /*
 772          * For compatibility, look at the directories in the VPATH variable
 773          * and add them to the search path, if the variable is defined. The
 774          * variable's value is in the same format as the PATH envariable, i.e.
 775          * <directory>:<directory>:<directory>...
 776          */
 777         if (Var_Exists("VPATH", VAR_CMD)) {
 778                 char *vpath, *path, *cp, savec;
 779                 /*
 780                  * GCC stores string constants in read-only memory, but
 781                  * Var_Subst will want to write this thing, so store it
 782                  * in an array
 783                  */
 784                 static char VPATH[] = "${VPATH}";
 785
 786                 vpath = Var_Subst(NULL, VPATH, VAR_CMD, FALSE);
 787                 path = vpath;
 788                 do {
 789                         /* skip to end of directory */
 790                         for (cp = path; *cp != ':' && *cp != '\0'; cp++)
 791                                 continue;
 792                         /* Save terminator character so know when to stop */
 793                         savec = *cp;
 794                         *cp = '\0';
 795                         /* Add directory to search path */
 796                         Dir_AddDir(dirSearchPath, path);
 797                         *cp = savec;
 798                         path = cp + 1;
 799                 } while (savec == ':');
 800                 (void)free(vpath);
 801         }
 802
 803         /*
 804          * Now that all search paths have been read for suffixes et al, it's
 805          * time to add the default search path to their lists...
 806          */
 807         Suff_DoPaths();
 808
 809         /* print the initial graph, if the user requested it */
 810         if (DEBUG(GRAPH1))
 811                 Targ_PrintGraph(1);
 812
 813         /* print the values of any variables requested by the user */
 814         if (printVars) {
 815                 LstNode ln;
 816
 817                 for (ln = Lst_First(variables); ln != NULL;
 818                     ln = Lst_Succ(ln)) {
 819                         char *value;
 820                         if (expandVars) {
 821                                 p1 = emalloc(strlen((char *)Lst_Datum(ln)) + 1 + 3);
 822                                 /* This sprintf is safe, because of the malloc above */
 823                                 (void)sprintf(p1, "${%s}", (char *)Lst_Datum(ln));
 824                                 value = Var_Subst(NULL, p1, VAR_GLOBAL, FALSE);
 825                         } else {
 826                                 value = Var_Value((char *)Lst_Datum(ln),
 827                                                   VAR_GLOBAL, &p1);
 828                         }
 829                         printf("%s\n", value ? value : "");
 830                         if (p1)
 831                                 free(p1);
 832                 }
 833         }
 834
 835         /*
 836          * Have now read the entire graph and need to make a list of targets
 837          * to create. If none was given on the command line, we consult the
 838          * parsing module to find the main target(s) to create.
 839          */
 840         if (Lst_IsEmpty(create))
 841                 targs = Parse_MainName();
 842         else
 843                 targs = Targ_FindList(create, TARG_CREATE);
 844
 845         if (!compatMake && !printVars) {
 846                 /*
 847                  * Initialize job module before traversing the graph, now that
 848                  * any .BEGIN and .END targets have been read.  This is done
 849                  * only if the -q flag wasn't given (to prevent the .BEGIN from
 850                  * being executed should it exist).
 851                  */
 852                 if (!queryFlag) {
 853                         if (maxLocal == -1)
 854                                 maxLocal = maxJobs;
 855                         Job_Init(maxJobs, maxLocal);
 856                         jobsRunning = TRUE;
 857                 }
 858
 859                 /* Traverse the graph, checking on all the targets */
 860                 outOfDate = Make_Run(targs);
 861         } else if (!printVars) {
 862                 /*
 863                  * Compat_Init will take care of creating all the targets as
 864                  * well as initializing the module.
 865                  */
 866                 Compat_Run(targs);
 867         }
 868
 869         Lst_Destroy(targs, NOFREE);
 870         Lst_Destroy(variables, NOFREE);
 871         Lst_Destroy(makefiles, NOFREE);
 872         Lst_Destroy(create, (void (*)(void *)) free);
 873
 874         /* print the graph now it's been processed if the user requested it */
 875         if (DEBUG(GRAPH2))
 876                 Targ_PrintGraph(2);
 877
 878         Suff_End();
 879         Targ_End();
 880         Arch_End();
 881         str_end();
 882         Var_End();
 883         Parse_End();
 884         Dir_End();
 885
 886         if (queryFlag && outOfDate)
 887                 return(1);
 888         else
 889                 return(0);
 890 }
 891
 892 /*-
 893  * ReadMakefile  --
 894  *      Open and parse the given makefile.
 895  *
 896  * Results:
 897  *      TRUE if ok. FALSE if couldn't open file.
 898  *
 899  * Side Effects:
 900  *      lots
 901  */
 902 static Boolean
 903 ReadMakefile(p, q)
 904         void *p;
 905         void *q;
 906 {
 907         char *fname = p;                /* makefile to read */
 908         extern Lst parseIncPath;
 909         FILE *stream;
 910         char *name, path[MAXPATHLEN];
 911         int setMAKEFILE;
 912
 913         if (!strcmp(fname, "-")) {
 914                 Parse_File("(stdin)", stdin);
 915                 Var_Set("MAKEFILE", "", VAR_GLOBAL);
 916         } else {
 917                 setMAKEFILE = strcmp(fname, ".depend");
 918
 919                 /* if we've chdir'd, rebuild the path name */
 920                 if (curdir != objdir && *fname != '/') {
 921                         (void)snprintf(path, MAXPATHLEN, "%s/%s", curdir, fname);
 922                         if ((stream = fopen(path, "r")) != NULL) {
 923                                 fname = path;
 924                                 goto found;
 925                         }
 926                 } else if ((stream = fopen(fname, "r")) != NULL)
 927                         goto found;
 928                 /* look in -I and system include directories. */
 929                 name = Dir_FindFile(fname, parseIncPath);
 930                 if (!name)
 931                         name = Dir_FindFile(fname, sysIncPath);
 932                 if (!name || !(stream = fopen(name, "r")))
 933                         return(FALSE);
 934                 fname = name;
 935                 /*
 936                  * set the MAKEFILE variable desired by System V fans -- the
 937                  * placement of the setting here means it gets set to the last
 938                  * makefile specified, as it is set by SysV make.
 939                  */
 940 found:
 941                 if (setMAKEFILE)
 942                         Var_Set("MAKEFILE", fname, VAR_GLOBAL);
 943                 Parse_File(fname, stream);
 944                 (void)fclose(stream);
 945         }
 946         return(TRUE);
 947 }
 948
 949 /*-
 950  * Cmd_Exec --
 951  *      Execute the command in cmd, and return the output of that command
 952  *      in a string.
 953  *
 954  * Results:
 955  *      A string containing the output of the command, or the empty string
 956  *      If err is not NULL, it contains the reason for the command failure
 957  *
 958  * Side Effects:
 959  *      The string must be freed by the caller.
 960  */
 961 char *
 962 Cmd_Exec(cmd, err)
 963     char *cmd;
 964     char **err;
 965 {
 966     char        *args[4];       /* Args for invoking the shell */
 967     int         fds[2];         /* Pipe streams */
 968     int         cpid;           /* Child PID */
 969     int         pid;            /* PID from wait() */
 970     char        *res;           /* result */
 971     int         status;         /* command exit status */
 972     Buffer      buf;            /* buffer to store the result */
 973     char        *cp;
 974     int         cc;
 975
 976
 977     *err = NULL;
 978
 979     /*
 980      * Set up arguments for shell
 981      */
 982     args[0] = "sh";
 983     args[1] = "-c";
 984     args[2] = cmd;
 985     args[3] = NULL;
 986
 987     /*
 988      * Open a pipe for fetching its output
 989      */
 990     if (pipe(fds) == -1) {
 991         *err = "Couldn't create pipe for \"%s\"";
 992         goto bad;
 993     }
 994
 995     /*
 996      * Fork
 997      */
 998     switch (cpid = vfork()) {
 999     case 0:
1000         /*
1001          * Close input side of pipe
1002          */
1003         (void) close(fds[0]);
1004
1005         /*
1006          * Duplicate the output stream to the shell's output, then
1007          * shut the extra thing down. Note we don't fetch the error
1008          * stream...why not? Why?
1009          */
1010         (void) dup2(fds[1], 1);
1011         (void) close(fds[1]);
1012
1013 #if DEFSHELL == 1
1014         (void) execv("/bin/sh", args);
1015 #elif DEFSHELL == 2
1016         (void) execv("/bin/ksh", args);
1017 #else
1018 #error "DEFSHELL must be 1 or 2."
1019 #endif
1020         _exit(1);
1021         /*NOTREACHED*/
1022
1023     case -1:
1024         *err = "Couldn't exec \"%s\"";
1025         goto bad;
1026
1027     default:
1028         /*
1029          * No need for the writing half
1030          */
1031         (void) close(fds[1]);
1032
1033         buf = Buf_Init (MAKE_BSIZE);
1034
1035         do {
1036             char   result[BUFSIZ];
1037             cc = read(fds[0], result, sizeof(result));
1038             if (cc > 0)
1039                 Buf_AddBytes(buf, cc, (Byte *) result);
1040         }
1041         while (cc > 0 || (cc == -1 && errno == EINTR));
1042
1043         /*
1044          * Close the input side of the pipe.
1045          */
1046         (void) close(fds[0]);
1047
1048         /*
1049          * Wait for the process to exit.
1050          */
1051         while(((pid = wait(&status)) != cpid) && (pid >= 0))
1052             continue;
1053
1054         if (cc == -1)
1055             *err = "Error reading shell's output for \"%s\"";
1056
1057         res = (char *)Buf_GetAll (buf, &cc);
1058         Buf_Destroy (buf, FALSE);
1059
1060         if (status)
1061             *err = "\"%s\" returned non-zero status";
1062
1063         /*
1064          * Null-terminate the result, convert newlines to spaces and
1065          * install it in the variable.
1066          */
1067         res[cc] = '\0';
1068         cp = &res[cc] - 1;
1069
1070         if (*cp == '\n') {
1071             /*
1072              * A final newline is just stripped
1073              */
1074             *cp-- = '\0';
1075         }
1076         while (cp >= res) {
1077             if (*cp == '\n') {
1078                 *cp = ' ';
1079             }
1080             cp--;
1081         }
1082         break;
1083     }
1084     return res;
1085 bad:
1086     res = emalloc(1);
1087     *res = '\0';
1088     return res;
1089 }
1090
1091 /*-
1092  * Error --
1093  *      Print an error message given its format.
1094  *
1095  * Results:
1096  *      None.
1097  *
1098  * Side Effects:
1099  *      The message is printed.
1100  */
1101 /* VARARGS */
1102 void
1103 Error(char *fmt, ...)
1104 {
1105         va_list ap;
1106
1107         va_start(ap, fmt);
1108         (void)vfprintf(stderr, fmt, ap);
1109         va_end(ap);
1110         (void)fprintf(stderr, "\n");
1111         (void)fflush(stderr);
1112 }
1113
1114 /*-
1115  * Fatal --
1116  *      Produce a Fatal error message. If jobs are running, waits for them
1117  *      to finish.
1118  *
1119  * Results:
1120  *      None
1121  *
1122  * Side Effects:
1123  *      The program exits
1124  */
1125 /* VARARGS */
1126 void
1127 Fatal(char *fmt, ...)
1128 {
1129         va_list ap;
1130
1131         va_start(ap, fmt);
1132         if (jobsRunning)
1133                 Job_Wait();
1134
1135         (void)vfprintf(stderr, fmt, ap);
1136         va_end(ap);
1137         (void)fprintf(stderr, "\n");
1138         (void)fflush(stderr);
1139
1140         if (DEBUG(GRAPH2))
1141                 Targ_PrintGraph(2);
1142         exit(2);                /* Not 1 so -q can distinguish error */
1143 }
1144
1145 /*
1146  * Punt --
1147  *      Major exception once jobs are being created. Kills all jobs, prints
1148  *      a message and exits.
1149  *
1150  * Results:
1151  *      None
1152  *
1153  * Side Effects:
1154  *      All children are killed indiscriminately and the program Lib_Exits
1155  */
1156 /* VARARGS */
1157 void
1158 Punt(char *fmt, ...)
1159 {
1160         va_list ap;
1161
1162         va_start(ap, fmt);
1163         (void)fprintf(stderr, "make: ");
1164         (void)vfprintf(stderr, fmt, ap);
1165         va_end(ap);
1166         (void)fprintf(stderr, "\n");
1167         (void)fflush(stderr);
1168
1169         DieHorribly();
1170 }
1171
1172 /*-
1173  * DieHorribly --
1174  *      Exit without giving a message.
1175  *
1176  * Results:
1177  *      None
1178  *
1179  * Side Effects:
1180  *      A big one...
1181  */
1182 void
1183 DieHorribly()
1184 {
1185         if (jobsRunning)
1186                 Job_AbortAll();
1187         if (DEBUG(GRAPH2))
1188                 Targ_PrintGraph(2);
1189         exit(2);                /* Not 1, so -q can distinguish error */
1190 }
1191
1192 /*
1193  * Finish --
1194  *      Called when aborting due to errors in child shell to signal
1195  *      abnormal exit.
1196  *
1197  * Results:
1198  *      None
1199  *
1200  * Side Effects:
1201  *      The program exits
1202  */
1203 void
1204 Finish(errors)
1205         int errors;     /* number of errors encountered in Make_Make */
1206 {
1207         Fatal("%d error%s", errors, errors == 1 ? "" : "s");
1208 }
1209
1210 /*
1211  * emalloc --
1212  *      malloc, but die on error.
1213  */
1214 void *
1215 emalloc(len)
1216         size_t len;
1217 {
1218         void *p;
1219
1220         if ((p = malloc(len)) == NULL)
1221                 enomem();
1222         return(p);
1223 }
1224
1225 /*
1226  * estrdup --
1227  *      strdup, but die on error.
1228  */
1229 char *
1230 estrdup(str)
1231         const char *str;
1232 {
1233         char *p;
1234
1235         if ((p = strdup(str)) == NULL)
1236                 enomem();
1237         return(p);
1238 }
1239
1240 /*
1241  * erealloc --
1242  *      realloc, but die on error.
1243  */
1244 void *
1245 erealloc(ptr, size)
1246         void *ptr;
1247         size_t size;
1248 {
1249         if ((ptr = realloc(ptr, size)) == NULL)
1250                 enomem();
1251         return(ptr);
1252 }
1253
1254 /*
1255  * enomem --
1256  *      die when out of memory.
1257  */
1258 void
1259 enomem()
1260 {
1261         err(2, NULL);
1262 }
1263
1264 /*
1265  * enunlink --
1266  *      Remove a file carefully, avoiding directories.
1267  */
1268 int
1269 eunlink(file)
1270         const char *file;
1271 {
1272         struct stat st;
1273
1274         if (lstat(file, &st) == -1)
1275                 return -1;
1276
1277         if (S_ISDIR(st.st_mode)) {
1278                 errno = EISDIR;
1279                 return -1;
1280         }
1281         return unlink(file);
1282 }
1283
1284 /*
1285  * usage --
1286  *      exit with usage message
1287  */
1288 static void
1289 usage()
1290 {
1291         (void)fprintf(stderr, "%s\n%s\n%s\n",
1292 "usage: make [-Beiknqrstv] [-D variable] [-d flags] [-E variable] [-f makefile]",
1293 "            [-I directory] [-j max_jobs] [-m directory] [-V variable]",
1294 "            [variable=value] [target ...]");
1295         exit(2);
1296 }
1297
1298
1299 int
1300 PrintAddr(a, b)
1301     void * a;
1302     void * b;
1303 {
1304     printf("%lx ", (unsigned long) a);
1305     return b ? 0 : 0;
1306 }