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  * @(#) 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.134 2005/07/02 10:48:42 okumoto Exp $
  42  */
  43
  44 /*
  45  * main.c
  46  *      The main file for this entire program. Exit routines etc
  47  *      reside here.
  48  *
  49  * Utility functions defined in this file:
  50  *      Main_ParseArgLine
  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
  54  *                      the .MFLAGS target.
  55  */
  56
  57 #ifndef MACHINE
  58 #include <sys/utsname.h>
  59 #endif
  60 #include <sys/param.h>
  61 #include <sys/stat.h>
  62 #include <sys/time.h>
  63 #include <sys/queue.h>
  64 #include <sys/resource.h>
  65 #include <sys/wait.h>
  66 #include <err.h>
  67 #include <errno.h>
  68 #include <stdlib.h>
  69 #include <string.h>
  70 #include <unistd.h>
  71
  72 #include "arch.h"
  73 #include "buf.h"
  74 #include "config.h"
  75 #include "dir.h"
  76 #include "globals.h"
  77 #include "job.h"
  78 #include "make.h"
  79 #include "parse.h"
  80 #include "pathnames.h"
  81 #include "shell.h"
  82 #include "str.h"
  83 #include "suff.h"
  84 #include "targ.h"
  85 #include "util.h"
  86 #include "var.h"
  87
  88 extern char **environ;  /* XXX what header declares this variable? */
  89
  90 /*
  91  * DEFMAXJOBS
  92  *      This control the default concurrency. On no occasion will more
  93  *      than DEFMAXJOBS targets be created at once.
  94  */
  95 #define DEFMAXJOBS      1
  96
  97 typedef struct CLI {
  98         /** ordered list of makefiles to read */
  99         Lst makefiles;
 100
 101         /** list of variables to print */
 102         Lst variables;
 103
 104         /** Targets to be made */
 105         Lst create;
 106
 107         /** directories to search when looking for includes */
 108         struct Path     parseIncPath;
 109
 110         /** directories to search when looking for system includes */
 111         struct Path     sysIncPath;
 112
 113         Boolean expandVars;     /* fully expand printed variables */
 114         Boolean builtins;       /* -r flag */
 115         Boolean forceJobs;      /* -j argument given */
 116
 117         /**
 118          * -q flag:
 119          * TRUE if we aren't supposed to really make anything, just
 120          * see if the targets are out-of-date
 121          */
 122         Boolean         queryFlag;
 123 } CLI;
 124
 125 /* (-E) vars to override from env */
 126 Lst envFirstVars = Lst_Initializer(envFirstVars);
 127
 128 Boolean         allPrecious;    /* .PRECIOUS given on line by itself */
 129 Boolean         beSilent;       /* -s flag */
 130 Boolean         beVerbose;      /* -v flag */
 131 Boolean         compatMake;     /* -B argument */
 132 Boolean         debug;          /* -d flag */
 133 Boolean         ignoreErrors;   /* -i flag */
 134 int             jobLimit;       /* -j argument */
 135 Boolean         jobsRunning;    /* TRUE if the jobs might be running */
 136 Boolean         keepgoing;      /* -k flag */
 137 Boolean         noExecute;      /* -n flag */
 138 Boolean         touchFlag;      /* -t flag */
 139 Boolean         usePipes;       /* !-P flag */
 140 uint32_t        warn_cmd;       /* command line warning flags */
 141 uint32_t        warn_flags;     /* actual warning flags */
 142 uint32_t        warn_nocmd;     /* command line no-warning flags */
 143
 144 time_t          now;            /* Time at start of make */
 145 struct GNode    *DEFAULT;       /* .DEFAULT node */
 146
 147
 148 /**
 149  * Exit with usage message.
 150  */
 151 static void
 152 usage(void)
 153 {
 154         fprintf(stderr,
 155             "usage: make [-BPSXeiknqrstv] [-C directory] [-D variable]\n"
 156             "\t[-d flags] [-E variable] [-f makefile] [-I directory]\n"
 157             "\t[-j max_jobs] [-m directory] [-V variable]\n"
 158             "\t[variable=value] [target ...]\n");
 159         exit(2);
 160 }
 161
 162 /**
 163  * MFLAGS_append
 164  *      Append a flag with an optional argument to MAKEFLAGS and MFLAGS
 165  */
 166 static void
 167 MFLAGS_append(const char *flag, char *arg)
 168 {
 169         char *str;
 170
 171         Var_Append(".MAKEFLAGS", flag, VAR_GLOBAL);
 172         if (arg != NULL) {
 173                 str = MAKEFLAGS_quote(arg);
 174                 Var_Append(".MAKEFLAGS", str, VAR_GLOBAL);
 175                 free(str);
 176         }
 177
 178         Var_Append("MFLAGS", flag, VAR_GLOBAL);
 179         if (arg != NULL) {
 180                 str = MAKEFLAGS_quote(arg);
 181                 Var_Append("MFLAGS", str, VAR_GLOBAL);
 182                 free(str);
 183         }
 184 }
 185
 186 /**
 187  * Open and parse the given makefile.
 188  *
 189  * Results:
 190  *      TRUE if ok. FALSE if couldn't open file.
 191  */
 192 static Boolean
 193 ReadMakefile(Parser *parser, CLI *cli, const char file[], const char curdir[], const char objdir[])
 194 {
 195         char    path[MAXPATHLEN];
 196         FILE    *stream;
 197         char    *fname;
 198         char    *name;
 199
 200         if (!strcmp(file, "-")) {
 201                 Parse_File(parser, cli, "(stdin)", stdin);
 202                 Var_SetGlobal("MAKEFILE", "");
 203                 return (TRUE);
 204         }
 205
 206         if (strcmp(curdir, objdir) == 0 || file[0] == '/') {
 207                 strcpy(path, file);
 208         } else {
 209                 /*
 210                  * we've chdir'd, rebuild the path name
 211                  */
 212                 snprintf(path, MAXPATHLEN, "%s/%s", curdir, file);
 213         }
 214 #if THIS_BREAKS_THINGS
 215         /*
 216          * XXX The realpath stuff breaks relative includes
 217          * XXX in some cases.   The problem likely is in
 218          * XXX parse.c where it does special things in
 219          * XXX ParseDoInclude if the file is relateive
 220          * XXX or absolute and not a system file.  There
 221          * XXX it assumes that if the current file that's
 222          * XXX being included is absolute, that any files
 223          * XXX that it includes shouldn't do the -I path
 224          * XXX stuff, which is inconsistant with historical
 225          * XXX behavior.  However, I can't pentrate the mists
 226          * XXX further, so I'm putting this workaround in
 227          * XXX here until such time as the underlying bug
 228          * XXX can be fixed.
 229          */
 230         if (realpath(path, path) == NULL) {
 231                 stream = NULL;
 232         } else {
 233                 stream = fopen(path, "r");
 234         }
 235 #else
 236         stream = fopen(path, "r");
 237 #endif
 238         if (stream != NULL) {
 239                 if (strcmp(file, ".depend") != 0)
 240                         Var_SetGlobal("MAKEFILE", file);
 241                 Parse_File(parser, cli, path, stream);
 242                 fclose(stream);
 243                 return (TRUE);
 244         }
 245
 246         /* look in -I and system include directories. */
 247         fname = estrdup(file);
 248         name = NULL;
 249         if (name == NULL)
 250                 name = Path_FindFile(fname, &cli->parseIncPath);
 251         if (name == NULL)
 252                 name = Path_FindFile(fname, &cli->sysIncPath);
 253
 254         if (name != NULL) {
 255                 stream = fopen(name, "r");
 256                 if (stream != NULL) {
 257                         /*
 258                          * set the MAKEFILE variable desired by System V fans
 259                          * -- the placement of the setting here means it gets
 260                          * set to the last makefile specified, as it is set
 261                          * by SysV make.
 262                          */
 263                         if (strcmp(file, ".depend") != 0)
 264                                 Var_SetGlobal("MAKEFILE", name);
 265                         Parse_File(parser, cli, name, stream);
 266                         fclose(stream);
 267                         return (TRUE);
 268                 }
 269         }
 270
 271         return (FALSE); /* no makefile found */
 272 }
 273
 274 /**
 275  * Read in the built-in rules first, followed by the specified
 276  * makefiles or the one of the default makefiles.  Finally .depend
 277  * makefile.
 278  */
 279 static void
 280 ReadInputFiles(Parser *parser, CLI *cli, const char curdir[], const char objdir[])
 281 {
 282         if (cli->builtins) {
 283                 char    defsysmk[] = PATH_DEFSYSMK;     /* Path of sys.mk */
 284                 Lst     sysMkPath = Lst_Initializer(sysMkPath);
 285                 LstNode *ln;
 286
 287                 Path_Expand(defsysmk, &cli->sysIncPath, &sysMkPath);
 288                 if (Lst_IsEmpty(&sysMkPath))
 289                         Fatal("make: no system rules (%s).", PATH_DEFSYSMK);
 290
 291                 LST_FOREACH(ln, &sysMkPath) {
 292                         char *name = Lst_Datum(ln);
 293                         if (!ReadMakefile(parser, cli, name, curdir, objdir))
 294                                 Fatal("make: cannot open %s.", name);
 295                 }
 296                 Lst_Destroy(&sysMkPath, free);
 297         }
 298
 299         if (!Lst_IsEmpty(&cli->makefiles)) {
 300                 LstNode *ln;
 301
 302                 LST_FOREACH(ln, &cli->makefiles) {
 303                         char *name = Lst_Datum(ln);
 304                         if (!ReadMakefile(parser, cli, name, curdir, objdir))
 305                                 Fatal("make: cannot open %s.", name);
 306                 }
 307         } else if (ReadMakefile(parser, cli, "BSDmakefile", curdir, objdir)) {
 308                 /* read BSDmakefile */
 309         } else if (ReadMakefile(parser, cli, "makefile", curdir, objdir)) {
 310                 /* read makefile */
 311         } else if (ReadMakefile(parser, cli, "Makefile", curdir, objdir)) {
 312                 /* read Makefile */
 313         } else {
 314                 /* No Makefile found */
 315         }
 316
 317         ReadMakefile(parser, cli, ".depend", curdir, objdir);
 318 }
 319
 320 /**
 321  * Main_ParseWarn
 322  *
 323  *      Handle argument to warning option.
 324  */
 325 int
 326 Main_ParseWarn(const char *arg, int iscmd)
 327 {
 328         int i, neg;
 329
 330         static const struct {
 331                 const char      *option;
 332                 uint32_t        flag;
 333         } options[] = {
 334                 { "dirsyntax",  WARN_DIRSYNTAX },
 335                 { NULL,         0 }
 336         };
 337
 338         neg = 0;
 339         if (arg[0] == 'n' && arg[1] == 'o') {
 340                 neg = 1;
 341                 arg += 2;
 342         }
 343
 344         for (i = 0; options[i].option != NULL; i++)
 345                 if (strcmp(arg, options[i].option) == 0)
 346                         break;
 347
 348         if (options[i].option == NULL)
 349                 /* unknown option */
 350                 return (-1);
 351
 352         if (iscmd) {
 353                 if (!neg) {
 354                         warn_cmd |= options[i].flag;
 355                         warn_nocmd &= ~options[i].flag;
 356                         warn_flags |= options[i].flag;
 357                 } else {
 358                         warn_nocmd |= options[i].flag;
 359                         warn_cmd &= ~options[i].flag;
 360                         warn_flags &= ~options[i].flag;
 361                 }
 362         } else {
 363                 if (!neg) {
 364                         warn_flags |= (options[i].flag & ~warn_nocmd);
 365                 } else {
 366                         warn_flags &= ~(options[i].flag | warn_cmd);
 367                 }
 368         }
 369         return (0);
 370 }
 371
 372 /**
 373  * MainParseArgs
 374  *      Parse a given argument vector. Called from main() and from
 375  *      Main_ParseArgLine() when the .MAKEFLAGS target is used.
 376  *
 377  *      XXX: Deal with command line overriding .MAKEFLAGS in makefile
 378  *
 379  * Side Effects:
 380  *      Various global and local flags will be set depending on the flags
 381  *      given
 382  */
 383 static void
 384 MainParseArgs(CLI *cli, int argc, char **argv)
 385 {
 386         int c;
 387         Boolean found_dd = FALSE;
 388
 389 rearg:
 390         optind = 1;     /* since we're called more than once */
 391         optreset = 1;
 392 #define OPTFLAGS "ABC:D:E:I:PSV:Xd:ef:ij:km:nqrstvx:"
 393         for (;;) {
 394                 if ((optind < argc) && strcmp(argv[optind], "--") == 0) {
 395                         found_dd = TRUE;
 396                 }
 397                 if ((c = getopt(argc, argv, OPTFLAGS)) == -1) {
 398                         break;
 399                 }
 400                 switch(c) {
 401
 402                 case 'A':
 403                         arch_fatal = FALSE;
 404                         MFLAGS_append("-A", NULL);
 405                         break;
 406                 case 'C':
 407                         if (chdir(optarg) == -1)
 408                                 err(1, "chdir %s", optarg);
 409                         break;
 410                 case 'D':
 411                         Var_SetGlobal(optarg, "1");
 412                         MFLAGS_append("-D", optarg);
 413                         break;
 414                 case 'I':
 415                         Path_AddDir(&cli->parseIncPath, optarg);
 416                         MFLAGS_append("-I", optarg);
 417                         break;
 418                 case 'V':
 419                         Lst_AtEnd(&cli->variables, estrdup(optarg));
 420                         MFLAGS_append("-V", optarg);
 421                         break;
 422                 case 'X':
 423                         cli->expandVars = FALSE;
 424                         break;
 425                 case 'B':
 426                         compatMake = TRUE;
 427                         MFLAGS_append("-B", NULL);
 428                         unsetenv("MAKE_JOBS_FIFO");
 429                         break;
 430                 case 'P':
 431                         usePipes = FALSE;
 432                         MFLAGS_append("-P", NULL);
 433                         break;
 434                 case 'S':
 435                         keepgoing = FALSE;
 436                         MFLAGS_append("-S", NULL);
 437                         break;
 438                 case 'd': {
 439                         char *modules = optarg;
 440
 441                         for (; *modules; ++modules)
 442                                 switch (*modules) {
 443                                 case 'A':
 444                                         debug = ~0;
 445                                         break;
 446                                 case 'a':
 447                                         debug |= DEBUG_ARCH;
 448                                         break;
 449                                 case 'c':
 450                                         debug |= DEBUG_COND;
 451                                         break;
 452                                 case 'd':
 453                                         debug |= DEBUG_DIR;
 454                                         break;
 455                                 case 'f':
 456                                         debug |= DEBUG_FOR;
 457                                         break;
 458                                 case 'g':
 459                                         if (modules[1] == '1') {
 460                                                 debug |= DEBUG_GRAPH1;
 461                                                 ++modules;
 462                                         }
 463                                         else if (modules[1] == '2') {
 464                                                 debug |= DEBUG_GRAPH2;
 465                                                 ++modules;
 466                                         }
 467                                         break;
 468                                 case 'j':
 469                                         debug |= DEBUG_JOB;
 470                                         break;
 471                                 case 'l':
 472                                         debug |= DEBUG_LOUD;
 473                                         break;
 474                                 case 'm':
 475                                         debug |= DEBUG_MAKE;
 476                                         break;
 477                                 case 's':
 478                                         debug |= DEBUG_SUFF;
 479                                         break;
 480                                 case 't':
 481                                         debug |= DEBUG_TARG;
 482                                         break;
 483                                 case 'v':
 484                                         debug |= DEBUG_VAR;
 485                                         break;
 486                                 default:
 487                                         warnx("illegal argument to d option "
 488                                             "-- %c", *modules);
 489                                         usage();
 490                                 }
 491                         MFLAGS_append("-d", optarg);
 492                         break;
 493                 }
 494                 case 'E':
 495                         Lst_AtEnd(&envFirstVars, estrdup(optarg));
 496                         MFLAGS_append("-E", optarg);
 497                         break;
 498                 case 'e':
 499                         checkEnvFirst = TRUE;
 500                         MFLAGS_append("-e", NULL);
 501                         break;
 502                 case 'f':
 503                         Lst_AtEnd(&cli->makefiles, estrdup(optarg));
 504                         break;
 505                 case 'i':
 506                         ignoreErrors = TRUE;
 507                         MFLAGS_append("-i", NULL);
 508                         break;
 509                 case 'j': {
 510                         char *endptr;
 511
 512                         cli->forceJobs = TRUE;
 513                         jobLimit = strtol(optarg, &endptr, 10);
 514                         if (jobLimit <= 0 || *endptr != '\0') {
 515                                 warnx("illegal number, -j argument -- %s",
 516                                     optarg);
 517                                 usage();
 518                         }
 519                         MFLAGS_append("-j", optarg);
 520                         break;
 521                 }
 522                 case 'k':
 523                         keepgoing = TRUE;
 524                         MFLAGS_append("-k", NULL);
 525                         break;
 526                 case 'm':
 527                         Path_AddDir(&cli->sysIncPath, optarg);
 528                         MFLAGS_append("-m", optarg);
 529                         break;
 530                 case 'n':
 531                         noExecute = TRUE;
 532                         MFLAGS_append("-n", NULL);
 533                         break;
 534                 case 'q':
 535                         cli->queryFlag = TRUE;
 536                         /* Kind of nonsensical, wot? */
 537                         MFLAGS_append("-q", NULL);
 538                         break;
 539                 case 'r':
 540                         cli->builtins = FALSE;
 541                         MFLAGS_append("-r", NULL);
 542                         break;
 543                 case 's':
 544                         beSilent = TRUE;
 545                         MFLAGS_append("-s", NULL);
 546                         break;
 547                 case 't':
 548                         touchFlag = TRUE;
 549                         MFLAGS_append("-t", NULL);
 550                         break;
 551                 case 'v':
 552                         beVerbose = TRUE;
 553                         MFLAGS_append("-v", NULL);
 554                         break;
 555                 case 'x':
 556                         if (Main_ParseWarn(optarg, 1) != -1)
 557                                 MFLAGS_append("-x", optarg);
 558                         break;
 559                 default:
 560                 case '?':
 561                         usage();
 562                 }
 563         }
 564         argv += optind;
 565         argc -= optind;
 566
 567         oldVars = TRUE;
 568
 569         /*
 570          * Parse the rest of the arguments.
 571          *      o Check for variable assignments and perform them if so.
 572          *      o Check for more flags and restart getopt if so.
 573          *      o Anything else is taken to be a target and added
 574          *        to the end of the "create" list.
 575          */
 576         for (; *argv != NULL; ++argv, --argc) {
 577                 if (Parse_IsVar(*argv)) {
 578                         char *ptr = MAKEFLAGS_quote(*argv);
 579
 580                         Var_Append(".MAKEFLAGS", ptr, VAR_GLOBAL);
 581                         Parse_DoVar(*argv, VAR_CMD);
 582                         free(ptr);
 583
 584                 } else if ((*argv)[0] == '-') {
 585                         if ((*argv)[1] == '\0') {
 586                                 /*
 587                                  * (*argv) is a single dash, so we
 588                                  * just ignore it.
 589                                  */
 590                         } else if (found_dd) {
 591                                 /*
 592                                  * Double dash has been found, ignore
 593                                  * any more options.  But what do we do
 594                                  * with it?  For now treat it like a target.
 595                                  */
 596                                 Lst_AtEnd(&cli->create, estrdup(*argv));
 597                         } else {
 598                                 /*
 599                                  * (*argv) is a -flag, so backup argv and
 600                                  * argc.  getopt() expects options to start
 601                                  * in the 2nd position.
 602                                  */
 603                                 argc++;
 604                                 argv--;
 605                                 goto rearg;
 606                         }
 607
 608                 } else if ((*argv)[0] == '\0') {
 609                         Punt("illegal (null) argument.");
 610
 611                 } else {
 612                         Lst_AtEnd(&cli->create, estrdup(*argv));
 613                 }
 614         }
 615 }
 616
 617 /**
 618  * Main_ParseArgLine
 619  *      Used by the parse module when a .MFLAGS or .MAKEFLAGS target
 620  *      is encountered and by main() when reading the .MAKEFLAGS envariable.
 621  *      Takes a line of arguments and breaks it into its
 622  *      component words and passes those words and the number of them to the
 623  *      MainParseArgs function.
 624  *      The line should have all its leading whitespace removed.
 625  *
 626  * Side Effects:
 627  *      Only those that come from the various arguments.
 628  */
 629 void
 630 Main_ParseArgLine(CLI *cli, const char line[], int mflags)
 631 {
 632         ArgArray        aa;
 633
 634         if (mflags) {
 635                 MAKEFLAGS_break(&aa, line);
 636         } else {
 637                 brk_string(&aa, line, TRUE);
 638         }
 639         MainParseArgs(cli, aa.argc, aa.argv);
 640         ArgArray_Done(&aa);
 641 }
 642
 643 /**
 644  * Try to change the current working directory to path, and return
 645  * the whole path using getcwd().
 646  *
 647  * @note for amd managed mount points we really should use pawd(1).
 648  */
 649 static int
 650 chdir_verify_path(const char path[], char newdir[])
 651 {
 652         struct stat sb;
 653
 654         /*
 655          * Check if the path is a directory.  If not fail without reporting
 656          * an error.
 657          */
 658         if (stat(path, &sb) < 0) {
 659                 return (0);
 660         }
 661         if (S_ISDIR(sb.st_mode) == 0) {
 662                 return (0);
 663         }
 664
 665         /*
 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.
 669          */
 670         if (chdir(path) < 0) {
 671                 warn("warning: %s", path);
 672                 return (0);
 673         }
 674         if (getcwd(newdir, MAXPATHLEN) == NULL) {
 675                 warn("warning: %s", path);
 676                 return (0);
 677         }
 678         return (1);
 679 }
 680
 681 static void
 682 determine_objdir(const char machine[], char curdir[], char objdir[])
 683 {
 684         struct stat     sa;
 685         char            newdir[MAXPATHLEN];
 686         char            mdpath[MAXPATHLEN];
 687         const char      *env;
 688
 689         /*
 690          * Find a path to where we are... [-C directory] might have changed
 691          * our current directory.
 692          */
 693         if (getcwd(curdir, MAXPATHLEN) == NULL)
 694                 err(2, NULL);
 695
 696         if (stat(curdir, &sa) == -1)
 697                 err(2, "%s", curdir);
 698
 699         /*
 700          * The object directory location is determined using the
 701          * following order of preference:
 702          *
 703          *      1. MAKEOBJDIRPREFIX`cwd`
 704          *      2. MAKEOBJDIR
 705          *      3. PATH_OBJDIR.${MACHINE}
 706          *      4. PATH_OBJDIR
 707          *      5. PATH_OBJDIRPREFIX`cwd`
 708          *
 709          * If one of the first two fails, use the current directory.
 710          * If the remaining three all fail, use the current directory.
 711          */
 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);
 716                         return;
 717                 }
 718                 strcpy(objdir, curdir);
 719                 return;
 720         }
 721
 722         if ((env = getenv("MAKEOBJDIR")) != NULL) {
 723                 if (chdir_verify_path(env, newdir)) {
 724                         strcpy(objdir, newdir);
 725                         return;
 726                 }
 727                 strcpy(objdir, curdir);
 728                 return;
 729         }
 730
 731         snprintf(mdpath, MAXPATHLEN, "%s.%s", PATH_OBJDIR, machine);
 732         if (chdir_verify_path(mdpath, newdir)) {
 733                 strcpy(objdir, newdir);
 734                 return;
 735         }
 736
 737         if (chdir_verify_path(PATH_OBJDIR, newdir)) {
 738                 strcpy(objdir, newdir);
 739                 return;
 740         }
 741
 742         snprintf(mdpath, MAXPATHLEN, "%s%s", PATH_OBJDIRPREFIX, curdir);
 743         if (chdir_verify_path(mdpath, newdir)) {
 744                 strcpy(objdir, newdir);
 745                 return;
 746         }
 747
 748         strcpy(objdir, curdir);
 749 }
 750
 751 /**
 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.
 756  */
 757 static void
 758 InitVariables(const char progname[])
 759 {
 760         const char      *machine;
 761         const char      *machine_arch;
 762         const char      *machine_cpu;
 763
 764         Var_SetGlobal("MAKE", progname);
 765         Var_SetGlobal(".MAKEFLAGS", "");
 766         Var_SetGlobal("MFLAGS", "");
 767
 768         Var_SetGlobal(".DIRECTIVE_MAKEENV", "YES");
 769         Var_SetGlobal(".ST_EXPORTVAR", "YES");
 770 #ifdef MAKE_VERSION
 771         Var_SetGlobal("MAKE_VERSION", MAKE_VERSION);
 772 #endif
 773
 774         /*
 775          * Get the name of this type of MACHINE from utsname
 776          * so we can share an executable for similar machines.
 777          * (i.e. m68k: amiga hp300, mac68k, sun3, ...)
 778          *
 779          * Note that while MACHINE is decided at run-time,
 780          * MACHINE_ARCH is always known at compile time.
 781          */
 782         if ((machine = getenv("MACHINE")) == NULL) {
 783 #ifdef MACHINE
 784                 machine = MACHINE;
 785 #else
 786                 static struct utsname   utsname;
 787                 if (uname(&utsname) == -1)
 788                         err(2, "uname");
 789                 machine = utsname.machine;
 790 #endif
 791         }
 792
 793         if ((machine_arch = getenv("MACHINE_ARCH")) == NULL) {
 794 #ifdef MACHINE_ARCH
 795                 machine_arch = MACHINE_ARCH;
 796 #else
 797                 machine_arch = "unknown";
 798 #endif
 799         }
 800
 801         /*
 802          * Set machine_cpu to the minumum supported CPU revision based
 803          * on the target architecture, if not already set.
 804          */
 805         if ((machine_cpu = getenv("MACHINE_CPU")) == NULL) {
 806                 if (!strcmp(machine_arch, "i386"))
 807                         machine_cpu = "i386";
 808                 else if (!strcmp(machine_arch, "alpha"))
 809                         machine_cpu = "ev4";
 810                 else
 811                         machine_cpu = "unknown";
 812         }
 813
 814         Var_SetGlobal("MACHINE", machine);
 815         Var_SetGlobal("MACHINE_ARCH", machine_arch);
 816         Var_SetGlobal("MACHINE_CPU", machine_cpu);
 817 }
 818
 819 /**
 820  * Build targets.
 821  *
 822  * We have read the entire graph and need to make
 823  * a list of targets to create.  If none were given
 824  * on the command line, we consult the parsing
 825  * module to find the main target(s) to create.
 826  */
 827 static int
 828 build_stuff(CLI *cli)
 829 {
 830         int     status;
 831         Lst     targs = Lst_Initializer(targs);
 832
 833         if (Lst_IsEmpty(&cli->create))
 834                 Parse_MainName(&targs);
 835         else
 836                 Targ_FindList(&targs, &cli->create, TARG_CREATE);
 837
 838         /* Traverse the graph, checking on all the targets */
 839         if (compatMake) {
 840                 status = Compat_Run(&targs, cli->queryFlag);
 841         } else {
 842                 status = Make_Run(&targs, cli->queryFlag);
 843         }
 844
 845         Lst_Destroy(&targs, NOFREE);
 846         return (status);
 847 }
 848
 849 /**
 850  * main
 851  *      The main function, for obvious reasons. Initializes variables
 852  *      and a few modules, then parses the arguments give it in the
 853  *      environment and on the command line. Reads the system makefile
 854  *      followed by either Makefile, makefile or the file given by the
 855  *      -f argument. Sets the .MAKEFLAGS PMake variable based on all the
 856  *      flags it has received by then uses either the Make or the Compat
 857  *      module to create the initial list of targets.
 858  *
 859  * Results:
 860  *      If -q was given, exits -1 if anything was out-of-date. Else it exits
 861  *      0.
 862  *
 863  * Side Effects:
 864  *      The program exits when done. Targets are created. etc. etc. etc.
 865  */
 866 int
 867 main(int argc, char **argv)
 868 {
 869         CLI             cli;
 870         Parser          parser;
 871         int             status;         /* exit status */
 872         char            curdir[MAXPATHLEN];     /* startup directory */
 873         char            objdir[MAXPATHLEN];     /* where we chdir'ed to */
 874         const char      *make_flags;
 875
 876         /*------------------------------------------------------------*
 877          * This section initializes stuff that require no input.
 878          *------------------------------------------------------------*/
 879         /*
 880          * Initialize program globals.
 881          */
 882         beSilent = FALSE;               /* Print commands as executed */
 883         ignoreErrors = FALSE;           /* Pay attention to non-zero returns */
 884         noExecute = FALSE;              /* Execute all commands */
 885         keepgoing = FALSE;              /* Stop on error */
 886         allPrecious = FALSE;            /* Remove targets when interrupted */
 887         touchFlag = FALSE;              /* Actually update targets */
 888         usePipes = TRUE;                /* Catch child output in pipes */
 889         debug = 0;                      /* No debug verbosity, please. */
 890         jobsRunning = FALSE;
 891
 892         jobLimit = DEFMAXJOBS;
 893         compatMake = FALSE;             /* No compat mode */
 894
 895         /*
 896          * Initialize program flags.
 897          */
 898         Lst_Init(&cli.makefiles);
 899         Lst_Init(&cli.variables);
 900         Lst_Init(&cli.create);
 901         TAILQ_INIT(&cli.parseIncPath);
 902         TAILQ_INIT(&cli.sysIncPath);
 903
 904         cli.expandVars = TRUE;
 905         cli.builtins = TRUE;            /* Read the built-in rules */
 906         cli.queryFlag = FALSE;
 907         cli.forceJobs = FALSE;
 908
 909         /*
 910          * Initialize the various modules.
 911          */
 912         Proc_Init();
 913         Shell_Init(DEFSHELLNAME);
 914         Targ_Init();
 915         Suff_Init();
 916         Dir_Init();
 917
 918         /*------------------------------------------------------------*
 919          * This section initializes stuff that depend on things
 920          * in the enviornment, command line, or a input file.
 921          *------------------------------------------------------------*/
 922         Var_Init(environ);
 923
 924         InitVariables(argv[0]);
 925
 926         /*
 927          * First snag things out of the MAKEFLAGS environment
 928          * variable.  Then parse the command line arguments.
 929          */
 930         if ((make_flags = getenv("MAKEFLAGS")) != NULL) {
 931                 Main_ParseArgLine(&cli, make_flags, 1);
 932         }
 933         MainParseArgs(&cli, argc, argv);
 934
 935         determine_objdir(Var_Value("MACHINE", VAR_GLOBAL), curdir, objdir);
 936         Var_SetGlobal(".CURDIR", curdir);
 937         Var_SetGlobal(".OBJDIR", objdir);
 938
 939         /*
 940          * Set up the .TARGETS variable to contain the list of targets to be
 941          * created. If none specified, make the variable empty -- the parser
 942          * will fill the thing in with the default or .MAIN target.
 943          */
 944         if (Lst_IsEmpty(&cli.create)) {
 945                 Var_SetGlobal(".TARGETS", "");
 946         } else {
 947                 LstNode *ln;
 948
 949                 LST_FOREACH(ln, &cli.create) {
 950                         char *name = Lst_Datum(ln);
 951
 952                         Var_Append(".TARGETS", name, VAR_GLOBAL);
 953                 }
 954         }
 955
 956         Dir_CurObj(curdir, objdir);
 957
 958         /*
 959          * If no user-supplied system path was given (through the -m option)
 960          * add the directories from the DEFSYSPATH (more than one may be given
 961          * as dir1:...:dirn) to the system include path.
 962          */
 963         if (TAILQ_EMPTY(&cli.sysIncPath)) {
 964                 char syspath[] = PATH_DEFSYSPATH;
 965                 char *start = syspath;
 966                 char *cp;
 967
 968                 while ((cp = strsep(&start, ":")) != NULL) {
 969                         Path_AddDir(&cli.sysIncPath, cp);
 970                 }
 971         }
 972
 973         if (getenv("MAKE_JOBS_FIFO") != NULL)
 974                 cli.forceJobs = TRUE;
 975
 976         /*
 977          * Be compatible if user did not specify -j and did not explicitly
 978          * turned compatibility on
 979          */
 980         if (compatMake == FALSE && cli.forceJobs == FALSE)
 981                 compatMake = TRUE;
 982
 983         DEFAULT = NULL;
 984         time(&now);
 985
 986         parser.create = &cli.create;
 987         parser.parseIncPath = &cli.parseIncPath;
 988         parser.sysIncPath = &cli.sysIncPath;
 989
 990         ReadInputFiles(&parser, &cli, curdir, objdir);
 991
 992         /*------------------------------------------------------------*
 993          * We are finished processing inputs.
 994          *------------------------------------------------------------*/
 995
 996         /* Install all the flags into the MAKE envariable. */
 997         {
 998                 const char *p;
 999
1000                 p = Var_Value(".MAKEFLAGS", VAR_GLOBAL);
1001                 if (p != NULL && *p != '\0')
1002                         setenv("MAKEFLAGS", p, 1);
1003         }
1004
1005         /*
1006          * For compatibility, look at the directories in the VPATH variable
1007          * and add them to the search path, if the variable is defined. The
1008          * variable's value is in the same format as the PATH envariable, i.e.
1009          * <directory>:<directory>:<directory>...
1010          */
1011         if (Var_Exists("VPATH", VAR_CMD)) {
1012                 Buffer  *buf = Var_Subst("${VPATH}", VAR_CMD, FALSE);
1013                 char    *start = Buf_Data(buf);
1014                 char    *cp;
1015
1016                 while ((cp = strsep(&start, ":")) != NULL) {
1017                         Path_AddDir(&dirSearchPath, cp);
1018                 }
1019
1020                 Buf_Destroy(buf, TRUE);
1021         }
1022
1023         /*
1024          * Now that all search paths have been read for suffixes et al, it's
1025          * time to add the default search path to their lists...
1026          */
1027         Suff_DoPaths();
1028
1029         /* print the initial graph, if the user requested it */
1030         if (DEBUG(GRAPH1))
1031                 Targ_PrintGraph(1);
1032
1033         if (Lst_IsEmpty(&cli.variables)) {
1034                 status = build_stuff(&cli);
1035         } else {
1036                 /* Print the values of variables requested by the user. */
1037                 Var_Print(&cli.variables, cli.expandVars);
1038
1039                 /*
1040                  * XXX
1041                  * This should be a "don't care", we do not check
1042                  * the status of any files.  It might make sense to
1043                  * modify Var_Print() to indicate that one of the
1044                  * requested variables did not exist, and use that
1045                  * as the return status.
1046                  * XXX
1047                  */
1048                 status = cli.queryFlag ? 1 : 0;
1049         }
1050
1051         /* print the graph now it's been processed if the user requested it */
1052         if (DEBUG(GRAPH2))
1053                 Targ_PrintGraph(2);
1054
1055 #if 0
1056         TAILQ_DESTROY(&cli.sysIncPath);
1057         TAILQ_DESTROY(&cli.parseIncPath);
1058 #endif
1059         Lst_Destroy(&cli.create, free);
1060         Lst_Destroy(&cli.variables, free);
1061         Lst_Destroy(&cli.makefiles, free);
1062
1063         return (status);
1064 }
1065