src/usr.bin/make/main.c - diff

Return to main.c CVS log

Up to [cvs.NetBSD.org] / src / usr.bin / make

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/usr.bin/make/main.c between version 1.452 and 1.453

version 1.452, 2020/11/08 14:19:15

version 1.453, 2020/11/08 14:50:24

#endif

#ifndef DEFMAXLOCAL

#define DEFMAXLOCAL DEFMAXJOBS

#endif

CmdOpts opts;

time_t now; /* Time at start of make */

GNode *DEFAULT; /* .DEFAULT node */

Boolean allPrecious; /* .PRECIOUS given on line by itself */

Boolean deleteOnError; /* .DELETE_ON_ERROR: set */

static int maxJobTokens; /* -j argument */

Boolean enterFlagObj; /* -w and objdir != srcdir */

Boolean preserveUndefined;

static int jp_0 = -1, jp_1 = -1; /* ends of parent job pipe */

Boolean doing_depend; /* Set while reading .depend */

static Boolean jobsRunning; /* TRUE if the jobs might be running */

static const char * tracefile;

static const char *tracefile;

static int ReadMakefile(const char *);

static void purge_cached_realpaths(void);

static Boolean ignorePWD; /* if we use -C, PWD is meaningless */

static char objdir[MAXPATHLEN + 1]; /* where we chdir'ed to */

char curdir[MAXPATHLEN + 1]; /* Startup directory */

char *progname; /* the program name */

char *makeDependfile;

pid_t myPid;

int makelevel;

Line 155 static int errors = 0;

static char *

explode(const char *flags)

{

size_t len;

char *nf, *st;

const char *f;

if (flags == NULL)

return NULL;

for (f = flags; *f; f++)

if (!ch_isalpha(*f))

break;

if (*f)

return bmake_strdup(flags);

len = strlen(flags);

st = nf = bmake_malloc(len * 3 + 1);

while (*flags) {

*nf++ = '-';

*nf++ = *flags++;

*nf++ = ' ';

}

*nf = '\0';

return st;

}

Line 196 usage(void)

" [-C directory] [-D variable] [-d flags] [-f makefile]\n"

" [-I directory] [-J private] [-j max_jobs] [-m directory] [-T file]\n"

" [-V variable] [-v variable] [variable=value] [target ...]\n",

progname);

exit(2);

}

static void

parse_debug_option_F(const char *modules)

{

const char *mode;

size_t len;

char *fname;

if (opts.debug_file != stdout && opts.debug_file != stderr)

fclose(opts.debug_file);

if (*modules == '+') {

modules++;

mode = "a";

} else

mode = "w";

if (strcmp(modules, "stdout") == 0) {

opts.debug_file = stdout;

return;

}

if (strcmp(modules, "stderr") == 0) {

opts.debug_file = stderr;

return;

}

len = strlen(modules);

fname = bmake_malloc(len + 20);

memcpy(fname, modules, len + 1);

/* Let the filename be modified by the pid */

if (strcmp(fname + len - 3, ".%d") == 0)

snprintf(fname + len - 2, 20, "%d", getpid());

opts.debug_file = fopen(fname, mode);

if (opts.debug_file == NULL) {

fprintf(stderr, "Cannot open debug file %s\n",

fname);

usage();

}

free(fname);

}

static void

Line 253 parse_debug_options(const char *argvalue

opts.debug &= DEBUG_LINT;

break;

case 'A':

opts.debug = ~(0|DEBUG_LINT);

opts.debug = ~(0 | DEBUG_LINT);

break;

case 'a':

opts.debug |= DEBUG_ARCH;

Line 334 parse_debug_options(const char *argvalue

usage();

}

debug_setbuf:

* Make the debug_file unbuffered, and make

Line 359 is_relpath(const char *path)

Line 360 is_relpath(const char *path)

while ((cp = strstr(cp, "/.")) != NULL) {

cp += 2;

if (*cp == '.')

cp++;

if (cp[0] == '/' || cp[0] == '\0')

return TRUE;

}

Line 395 MainParseArgJobsInternal(const char *arg

Line 396 MainParseArgJobsInternal(const char *arg

char end;

if (sscanf(argvalue, "%d,%d%c", &jp_0, &jp_1, &end) != 2) {

(void)fprintf(stderr,

"%s: internal error -- J option malformed (%s)\n",

progname, argvalue);

usage();

}

if ((fcntl(jp_0, F_GETFD, 0) < 0) ||

Line 733 Main_SetObjdir(const char *fmt, ...)

Line 734 Main_SetObjdir(const char *fmt, ...)

if ((strcmp(path, curdir) != 0 && access(path, W_OK) != 0) ||

(chdir(path) != 0)) {

(void)fprintf(stderr, "make warning: %s: %s.\n",

path, strerror(errno));

} else {

snprintf(objdir, sizeof objdir, "%s", path);

Var_Set(".OBJDIR", objdir, VAR_GLOBAL);

Line 781 Main_SetVarObjdir(const char *var, const

Line 782 Main_SetVarObjdir(const char *var, const

int

str2Lst_Append(StringList *lp, char *str, const char *sep)

{

char *cp;

int n;

if (!sep)

sep = " \t";

for (n = 0, cp = strtok(str, sep); cp; cp = strtok(NULL, sep)) {

Lst_Append(lp, cp);

n++;

}

return n;

}

#ifdef SIGINFO

Line 816 siginfo(int signo MAKE_ATTR_UNUSED)

Line 817 siginfo(int signo MAKE_ATTR_UNUSED)

void

MakeMode(const char *mode)

{

char *mode_freeIt = NULL;

if (mode == NULL) {

(void)Var_Subst("${" MAKE_MODE ":tl}",

VAR_GLOBAL, VARE_WANTRES, &mode_freeIt);

/* TODO: handle errors */

mode = mode_freeIt;

}

if (mode[0] != '\0') {

if (strstr(mode, "compat")) {

opts.compatMake = TRUE;

forceJobs = FALSE;

}

if (mode[0] != '\0') {

if (strstr(mode, "compat")) {

opts.compatMake = TRUE;

forceJobs = FALSE;

}

#if USE_META

if (strstr(mode, "meta"))

meta_mode_init(mode);

#endif

}

free(mode_freeIt);

}

static void

Line 876 PrintVar(const char *varname, Boolean ex

Line 877 PrintVar(const char *varname, Boolean ex

static Boolean

GetBooleanVar(const char *varname, Boolean fallback)

{

char *expr = str_concat3("${", varname, ":U}");

char *value;

Boolean res;

(void)Var_Subst(expr, VAR_GLOBAL, VARE_WANTRES, &value);

/* TODO: handle errors */

res = ParseBoolean(value, fallback);

free(value);

free(expr);

return res;

}

static void

Line 910 doPrintVars(void)

Line 911 doPrintVars(void)

static Boolean

runTargets(void)

{

GNodeList *targs; /* target nodes to create -- passed to Make_Init */

GNodeList *targs; /* target nodes to create */

Boolean outOfDate; /* FALSE if all targets up to date */

Line 1060 HandlePWD(const struct stat *curdir_st)

Line 1061 HandlePWD(const struct stat *curdir_st)

if (ignorePWD || (pwd = getenv("PWD")) == NULL)

return;

if (Var_Value("MAKEOBJDIRPREFIX", VAR_CMDLINE, &prefix_freeIt) != NULL) {

if (Var_Value("MAKEOBJDIRPREFIX", VAR_CMDLINE, &prefix_freeIt) !=

NULL) {

bmake_free(prefix_freeIt);

return;

}

Line 1211 ReadBuiltinRules(void)

Line 1213 ReadBuiltinRules(void)

StringList *sysMkPath = Lst_New();

Dir_Expand(_PATH_DEFSYSMK,

Lst_IsEmpty(sysIncPath) ? defSysIncPath : sysIncPath,

sysMkPath);

if (Lst_IsEmpty(sysMkPath))

Fatal("%s: no system rules (%s).", progname, _PATH_DEFSYSMK);

Line 1222 ReadBuiltinRules(void)

Line 1224 ReadBuiltinRules(void)

if (ln == NULL)

Fatal("%s: cannot open %s.",

progname, (const char *)sysMkPath->first->datum);

/* Free the list but not the actual filenames since these may still

* be used in GNodes. */

Line 1244 InitMaxJobs(void)

Line 1246 InitMaxJobs(void)

n = (int)strtol(value, NULL, 0);

if (n < 1) {

(void)fprintf(stderr,

"%s: illegal value for .MAKE.JOBS "

"-- must be positive integer!\n",

progname);

exit(1);

}

Line 1312 ReadFirstDefaultMakefile(void)

Line 1314 ReadFirstDefaultMakefile(void)

char *prefs;

(void)Var_Subst("${" MAKE_MAKEFILE_PREFERENCE "}",

VAR_CMDLINE, VARE_WANTRES, &prefs);

/* TODO: handle errors */

/* XXX: This should use a local list instead of opts.makefiles

Line 1358 main_Init(int argc, char **argv)

Line 1360 main_Init(int argc, char **argv)

if (uname(&utsname) == -1) {

(void)fprintf(stderr, "%s: uname failed (%s).\n", progname,

strerror(errno));

exit(2);

}

Line 1393 main_Init(int argc, char **argv)

Line 1395 main_Init(int argc, char **argv)

#ifndef MAKEFILE_PREFERENCE_LIST

# define MAKEFILE_PREFERENCE_LIST "makefile Makefile"

#endif

Var_Set(MAKE_MAKEFILE_PREFERENCE, MAKEFILE_PREFERENCE_LIST,

Var_Set(MAKE_MAKEFILE_PREFERENCE, MAKEFILE_PREFERENCE_LIST, VAR_GLOBAL);

VAR_GLOBAL);

Var_Set(MAKE_DEPENDFILE, ".depend", VAR_GLOBAL);

CmdOpts_Init();

Line 1472 main_Init(int argc, char **argv)

Line 1473 main_Init(int argc, char **argv)

if (getcwd(curdir, MAXPATHLEN) == NULL) {

(void)fprintf(stderr, "%s: getcwd: %s.\n",

progname, strerror(errno));

exit(2);

}

Line 1486 main_Init(int argc, char **argv)

Line 1487 main_Init(int argc, char **argv)

if (stat(curdir, &sa) == -1) {

(void)fprintf(stderr, "%s: %s: %s.\n",

progname, curdir, strerror(errno));

exit(2);

}

Line 1539 main_PrepareMaking(void)

Line 1540 main_PrepareMaking(void)

if (!opts.noBuiltins || opts.printVars == PVM_NONE) {

/* ignore /dev/null and anything starting with "no" */

(void)Var_Subst("${.MAKE.DEPENDFILE:N/dev/null:Nno*:T}",

VAR_CMDLINE, VARE_WANTRES, &makeDependfile);

if (makeDependfile[0] != '\0') {

/* TODO: handle errors */

doing_depend = TRUE;

Line 1556 main_PrepareMaking(void)

Line 1557 main_PrepareMaking(void)

{

void *freeIt;

Var_Append("MFLAGS", Var_Value(MAKEFLAGS, VAR_GLOBAL, &freeIt),

VAR_GLOBAL);

bmake_free(freeIt);

}

InitMaxJobs();

Line 1573 main_PrepareMaking(void)

if (!opts.compatMake)

Job_ServerStart(maxJobTokens, jp_0, jp_1);

DEBUG5(JOB, "job_pipe %d %d, maxjobs %d, tokens %d, compat %d\n",

jp_0, jp_1, opts.maxJobs, maxJobTokens, opts.compatMake ? 1 : 0);

if (opts.printVars == PVM_NONE)

Main_ExportMAKEFLAGS(TRUE); /* initial export */

Line 1731 found:

return 0;

}

/*-

* Cmd_Exec --

* Execute the command in cmd, and return the output of that command

Line 1749 found:

Line 1747 found:

char *

Cmd_Exec(const char *cmd, const char **errfmt)

{

const char *args[4]; /* Args for invoking the shell */

int fds[2]; /* Pipe streams */

int cpid; /* Child PID */

int pid; /* PID from wait() */

int status; /* command exit status */

Buffer buf; /* buffer to store the result */

ssize_t bytes_read;

char *res; /* result */

size_t res_len;

char *cp;

int savederr; /* saved errno */

*errfmt = NULL;

if (!shellName)

Shell_Init();

* Set up arguments for shell

args[0] = shellName;

args[1] = "-c";

args[2] = cmd;

args[3] = NULL;

* Open a pipe for fetching its output

if (pipe(fds) == -1) {

*errfmt = "Couldn't create pipe for \"%s\"";

goto bad;

}

* Fork

switch (cpid = vFork()) {

case 0:

(void)close(fds[0]); /* Close input side of pipe */

* Duplicate the output stream to the shell's output, then

* shut the extra thing down. Note we don't fetch the error

* stream...why not? Why?

(void)dup2(fds[1], 1);

args[0] = shellName;

(void)close(fds[1]);

args[1] = "-c";

args[2] = cmd;

args[3] = NULL;

Var_ExportVars();

* Open a pipe for fetching its output

if (pipe(fds) == -1) {

*errfmt = "Couldn't create pipe for \"%s\"";

goto bad;

}

(void)execv(shellPath, UNCONST(args));

_exit(1);

* Fork

/*NOTREACHED*/

switch (cpid = vFork()) {

case 0:

(void)close(fds[0]); /* Close input side of pipe */

* Duplicate the output stream to the shell's output, then

* shut the extra thing down. Note we don't fetch the error

* stream...why not? Why?

(void)dup2(fds[1], 1);

(void)close(fds[1]);

case -1:

Var_ExportVars();

*errfmt = "Couldn't exec \"%s\"";

goto bad;

default:

(void)execv(shellPath, UNCONST(args));

(void)close(fds[1]); /* No need for the writing half */

_exit(1);

/*NOTREACHED*/

case -1:

*errfmt = "Couldn't exec \"%s\"";

goto bad;

savederr = 0;

default:

Buf_Init(&buf);

(void)close(fds[1]); /* No need for the writing half */

do {

savederr = 0;

char result[BUFSIZ];

Buf_Init(&buf);

bytes_read = read(fds[0], result, sizeof result);

if (bytes_read > 0)

do {

Buf_AddBytes(&buf, result, (size_t)bytes_read);

char result[BUFSIZ];

} while (bytes_read > 0 || (bytes_read == -1 && errno == EINTR));

bytes_read = read(fds[0], result, sizeof result);

if (bytes_read == -1)

if (bytes_read > 0)

savederr = errno;

Buf_AddBytes(&buf, result, (size_t)bytes_read);

} while (bytes_read > 0 ||

(void)close(fds[0]); /* Close the input side of the pipe. */

(bytes_read == -1 && errno == EINTR));

if (bytes_read == -1)

/* Wait for the process to exit. */

savederr = errno;

while((pid = waitpid(cpid, &status, 0)) != cpid && pid >= 0)

JobReapChild(pid, status, FALSE);

(void)close(

fds[0]); /* Close the input side of the pipe. */

res_len = Buf_Len(&buf);

res = Buf_Destroy(&buf, FALSE);

/* Wait for the process to exit. */

while ((pid = waitpid(cpid, &status, 0)) != cpid && pid >= 0)

if (savederr != 0)

JobReapChild(pid, status, FALSE);

*errfmt = "Couldn't read shell's output for \"%s\"";

res_len = Buf_Len(&buf);

if (WIFSIGNALED(status))

res = Buf_Destroy(&buf, FALSE);

*errfmt = "\"%s\" exited on a signal";

else if (WEXITSTATUS(status) != 0)

if (savederr != 0)

*errfmt = "\"%s\" returned non-zero status";

*errfmt = "Couldn't read shell's output for \"%s\"";

/* Convert newlines to spaces. A final newline is just stripped */

if (WIFSIGNALED(status))

if (res_len > 0 && res[res_len - 1] == '\n')

*errfmt = "\"%s\" exited on a signal";

res[res_len - 1] = '\0';

else if (WEXITSTATUS(status) != 0)

for (cp = res; *cp != '\0'; cp++)

*errfmt = "\"%s\" returned non-zero status";

if (*cp == '\n')

*cp = ' ';

/* Convert newlines to spaces. A final newline is just stripped */

break;

if (res_len > 0 && res[res_len - 1] == '\n')

}

res[res_len - 1] = '\0';

return res;

for (cp = res; *cp != '\0'; cp++)

if (*cp == '\n')

*cp = ' ';

break;

}

return res;

bad:

return bmake_strdup("");

}

/* Print a printf-style error message.

Line 2017 static GNode *

get_cached_realpaths(void)

{

if (!cached_realpaths) {

cached_realpaths = Targ_NewGN("Realpath");

#ifndef DEBUG_REALPATH_CACHE

cached_realpaths->flags = INTERNAL;

#endif

}

return cached_realpaths;

}

/* purge any relative paths */

static void

purge_cached_realpaths(void)

{

GNode *cache = get_cached_realpaths();

HashEntry *he, *nhe;

HashIter hi;

HashIter_Init(&hi, &cache->context);

he = HashIter_Next(&hi);

while (he != NULL) {

nhe = HashIter_Next(&hi);

if (he->key[0] != '/') {

if (DEBUG(DIR))

fprintf(stderr, "cached_realpath: purging %s\n", he->key);

fprintf(stderr, "cached_realpath: purging %s\n",

HashTable_DeleteEntry(&cache->context, he);

he->key);

HashTable_DeleteEntry(&cache->context, he);

}

he = nhe;

}

he = nhe;

}

char *

cached_realpath(const char *pathname, char *resolved)

{

GNode *cache;

const char *rp;

void *freeIt;

if (pathname == NULL || pathname[0] == '\0')

return NULL;

cache = get_cached_realpaths();

if ((rp = Var_Value(pathname, cache, &freeIt)) != NULL) {

/* a hit */

strncpy(resolved, rp, MAXPATHLEN);

resolved[MAXPATHLEN - 1] = '\0';

} else if ((rp = realpath(pathname, resolved)) != NULL) {

Var_Set(pathname, rp, cache);

} /* else should we negative-cache? */

bmake_free(freeIt);

return rp ? resolved : NULL;

}

Line 2079 cached_realpath(const char *pathname, ch

Line 2080 cached_realpath(const char *pathname, ch

Boolean

shouldDieQuietly(GNode *gn, int bf)

{

static int quietly = -1;

if (quietly < 0) {

if (DEBUG(JOB) || !GetBooleanVar(".MAKE.DIE_QUIETLY", TRUE))

quietly = 0;

else if (bf >= 0)

quietly = bf;

else

quietly = gn != NULL && (gn->type & OP_MAKE);

}

return quietly;

}

static void

SetErrorVars(GNode *gn)

{

StringListNode *ln;

* We can print this even if there is no .ERROR target.

Var_Set(".ERROR_TARGET", gn->name, VAR_GLOBAL);

Var_Delete(".ERROR_CMD", VAR_GLOBAL);

for (ln = gn->commands->first; ln != NULL; ln = ln->next) {

const char *cmd = ln->datum;

if (cmd == NULL)

break;

Var_Append(".ERROR_CMD", cmd, VAR_GLOBAL);

}

void

PrintOnError(GNode *gn, const char *s)

{

static GNode *en = NULL;

const char *expr;

char *cp;

if (DEBUG(HASH)) {

Targ_Stats();

Var_Stats();

}

/* we generally want to keep quiet if a sub-make died */

if (DEBUG(HASH)) {

if (shouldDieQuietly(gn, -1))

Targ_Stats();

return;

Var_Stats();

}

/* we generally want to keep quiet if a sub-make died */

if (shouldDieQuietly(gn, -1))

return;

if (s)

printf("%s", s);

printf("\n%s: stopped in %s\n", progname, curdir);

if (en)

return; /* we've been here! */

if (gn)

SetErrorVars(gn);

expr = "${MAKE_PRINT_VAR_ON_ERROR:@v@$v='${$v}'\n@}";

(void)Var_Subst(expr, VAR_GLOBAL, VARE_WANTRES, &cp);

/* TODO: handle errors */

printf("%s", cp);

free(cp);

fflush(stdout);

* Finally, see if there is a .ERROR target, and run it if so.

en = Targ_FindNode(".ERROR");

if (en) {

en->type |= OP_SPECIAL;

Compat_Make(en, en);

}

void

Main_ExportMAKEFLAGS(Boolean first)

{

static Boolean once = TRUE;

const char *expr;

char *s;

if (once != first)

return;

once = FALSE;

expr = "${.MAKEFLAGS} ${.MAKEOVERRIDES:O:u:@v@$v=${$v:Q}@}";

(void)Var_Subst(expr, VAR_CMDLINE, VARE_WANTRES, &s);

/* TODO: handle errors */

if (s[0] != '\0') {

#ifdef POSIX

setenv("MAKEFLAGS", s, 1);

#else

setenv("MAKE", s, 1);

#endif

}

char *

getTmpdir(void)

{

static char *tmpdir = NULL;

if (!tmpdir) {

struct stat st;

* Honor $TMPDIR but only if it is valid.

* Ensure it ends with /.

(void)Var_Subst("${TMPDIR:tA:U" _PATH_TMP "}/", VAR_GLOBAL,

VARE_WANTRES, &tmpdir);

/* TODO: handle errors */

if (stat(tmpdir, &st) < 0 || !S_ISDIR(st.st_mode)) {

free(tmpdir);

tmpdir = bmake_strdup(_PATH_TMP);

}

return tmpdir;

}

Line 2208 getTmpdir(void)

Line 2209 getTmpdir(void)

int

mkTempFile(const char *pattern, char **out_fname)

{

static char *tmpdir = NULL;

char tfile[MAXPATHLEN];

int fd;

if (pattern == NULL)

pattern = TMPPAT;

if (tmpdir == NULL)

tmpdir = getTmpdir();

if (pattern[0] == '/') {

snprintf(tfile, sizeof tfile, "%s", pattern);

} else {

snprintf(tfile, sizeof tfile, "%s%s", tmpdir, pattern);

}

if ((fd = mkstemp(tfile)) < 0)

Punt("Could not create temporary file %s: %s", tfile, strerror(errno));

Punt("Could not create temporary file %s: %s", tfile,

if (out_fname) {

strerror(errno));

*out_fname = bmake_strdup(tfile);

if (out_fname) {

} else {

*out_fname = bmake_strdup(tfile);

unlink(tfile); /* we just want the descriptor */

} else {

}

unlink(

return fd;

tfile); /* we just want the descriptor */

}

return fd;

}

Line 2239 mkTempFile(const char *pattern, char **o

Line 2242 mkTempFile(const char *pattern, char **o

Boolean

ParseBoolean(const char *s, Boolean bf)

{

switch(s[0]) {

switch (s[0]) {

case '\0': /* not set - the default wins */

break;

case '0':

case 'F':

case 'f':

case 'N':

case 'n':

return FALSE;

case 'O':

case 'o':

return s[1] != 'F' && s[1] != 'f';

default:

return TRUE;

}

return bf;

}

CVSweb <webmaster@jp.NetBSD.org>