summaryrefslogtreecommitdiffstats
path: root/src/kmk/commands.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/kmk/commands.c')
-rw-r--r--src/kmk/commands.c954
1 files changed, 954 insertions, 0 deletions
diff --git a/src/kmk/commands.c b/src/kmk/commands.c
new file mode 100644
index 0000000..619839c
--- /dev/null
+++ b/src/kmk/commands.c
@@ -0,0 +1,954 @@
+/* Command processing for GNU Make.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
+This file is part of GNU Make.
+
+GNU Make is free software; you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free Software
+Foundation; either version 3 of the License, or (at your option) any later
+version.
+
+GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program. If not, see <http://www.gnu.org/licenses/>. */
+
+#include "makeint.h"
+#include "filedef.h"
+#include "dep.h"
+#include "variable.h"
+#include "job.h"
+#include "commands.h"
+#ifdef WINDOWS32
+#include <windows.h>
+#include "w32err.h"
+# ifdef CONFIG_NEW_WIN_CHILDREN
+# include "w32/winchildren.h"
+# endif
+#endif
+#ifdef CONFIG_WITH_LAZY_DEPS_VARS
+# include <assert.h>
+#endif
+
+#if VMS
+# define FILE_LIST_SEPARATOR (vms_comma_separator ? ',' : ' ')
+#else
+# define FILE_LIST_SEPARATOR ' '
+#endif
+
+#ifndef HAVE_UNISTD_H
+int getpid ();
+#endif
+
+#ifndef CONFIG_WITH_STRCACHE2
+
+static unsigned long
+dep_hash_1 (const void *key)
+{
+ const struct dep *d = key;
+ return_STRING_HASH_1 (dep_name (d));
+}
+
+static unsigned long
+dep_hash_2 (const void *key)
+{
+ const struct dep *d = key;
+ return_STRING_HASH_2 (dep_name (d));
+}
+
+static int
+dep_hash_cmp (const void *x, const void *y)
+{
+ const struct dep *dx = x;
+ const struct dep *dy = y;
+ return strcmp (dep_name (dx), dep_name (dy));
+}
+
+
+#else /* CONFIG_WITH_STRCACHE2 */
+
+/* Exploit the fact that all names are in the string cache. This means equal
+ names shall have the same storage and there is no need for hashing or
+ comparing. Use the address as the first hash, avoiding any touching of
+ the name, and the length as the second. */
+
+static unsigned long
+dep_hash_1 (const void *key)
+{
+ const char *name = dep_name ((struct dep const *) key);
+ assert (strcache2_is_cached (&file_strcache, name));
+ return (size_t) name / sizeof(void *);
+}
+
+static unsigned long
+dep_hash_2 (const void *key)
+{
+ const char *name = dep_name ((struct dep const *) key);
+ return strcache2_get_len (&file_strcache, name);
+}
+
+static int
+dep_hash_cmp (const void *x, const void *y)
+{
+ struct dep *dx = (struct dep *) x;
+ struct dep *dy = (struct dep *) y;
+ const char *dxname = dep_name (dx);
+ const char *dyname = dep_name (dy);
+ int cmp = dxname == dyname ? 0 : 1;
+
+ /* check preconds: both cached and the cache contains no duplicates. */
+ assert (strcache2_is_cached (&file_strcache, dxname));
+ assert (strcache2_is_cached (&file_strcache, dyname));
+ assert (cmp == 0 || strcmp (dxname, dyname) != 0);
+
+ /* If the names are the same but ignore_mtimes are not equal, one of these
+ is an order-only prerequisite and one isn't. That means that we should
+ remove the one that isn't and keep the one that is. */
+
+ if (!cmp && dx->ignore_mtime != dy->ignore_mtime)
+ dx->ignore_mtime = dy->ignore_mtime = 0;
+
+ return cmp;
+}
+
+#endif /* CONFIG_WITH_STRCACHE2 */
+
+#ifdef CONFIG_WITH_LAZY_DEPS_VARS
+/* Create as copy of DEPS without duplicates, similar to what
+ set_file_variables does. Used by func_deps. */
+
+struct dep *create_uniqute_deps_chain (struct dep *deps)
+{
+ struct dep *d;
+ struct dep *head = NULL;
+ struct dep **ppnext= &head;
+ struct hash_table dep_hash;
+ void **slot;
+
+ hash_init (&dep_hash, 500, dep_hash_1, dep_hash_2, dep_hash_cmp);
+
+ for (d = deps; d != 0; d = d->next)
+ {
+ if (d->need_2nd_expansion)
+ continue;
+
+ slot = hash_find_slot (&dep_hash, d);
+ if (HASH_VACANT (*slot))
+ {
+ struct dep *n = alloc_dep();
+ *n = *d;
+ n->next = NULL;
+ *ppnext = n;
+ ppnext = &n->next;
+ hash_insert_at (&dep_hash, n, slot);
+ }
+ else
+ {
+ /* Upgrade order only if a normal dep exists.
+ Note! Elected not to upgrade the original, only the sanitized
+ list, need to check that out later. FIXME TODO */
+ struct dep *d2 = (struct dep *)*slot;
+ if (d->ignore_mtime != d2->ignore_mtime)
+ d->ignore_mtime = d2->ignore_mtime = 0;
+ }
+ }
+
+ return head;
+}
+#endif /* CONFIG_WITH_LAZY_DEPS_VARS */
+
+/* Set FILE's automatic variables up. */
+
+void
+#if defined(CONFIG_WITH_COMMANDS_FUNC) || defined (CONFIG_WITH_DOT_MUST_MAKE)
+set_file_variables (struct file *file, int called_early)
+#else
+set_file_variables (struct file *file)
+#endif
+{
+ struct dep *d;
+ const char *at, *percent, *star, *less;
+#ifdef CONFIG_WITH_STRCACHE2
+ const char *org_stem = file->stem;
+#endif
+
+#ifndef NO_ARCHIVES
+ /* If the target is an archive member 'lib(member)',
+ then $@ is 'lib' and $% is 'member'. */
+
+ if (ar_name (file->name))
+ {
+ unsigned int len;
+ const char *cp;
+ char *p;
+
+ cp = strchr (file->name, '(');
+ p = alloca (cp - file->name + 1);
+ memcpy (p, file->name, cp - file->name);
+ p[cp - file->name] = '\0';
+ at = p;
+ len = strlen (cp + 1);
+ p = alloca (len);
+ memcpy (p, cp + 1, len - 1);
+ p[len - 1] = '\0';
+ percent = p;
+ }
+ else
+#endif /* NO_ARCHIVES. */
+ {
+ at = file->name;
+ percent = "";
+ }
+
+ /* $* is the stem from an implicit or static pattern rule. */
+ if (file->stem == 0)
+ {
+ /* In Unix make, $* is set to the target name with
+ any suffix in the .SUFFIXES list stripped off for
+ explicit rules. We store this in the 'stem' member. */
+ const char *name;
+ unsigned int len;
+
+#ifndef NO_ARCHIVES
+ if (ar_name (file->name))
+ {
+ name = strchr (file->name, '(') + 1;
+ len = strlen (name) - 1;
+ }
+ else
+#endif
+ {
+ name = file->name;
+#ifndef CONFIG_WITH_STRCACHE2
+ len = strlen (name);
+#else
+ len = strcache2_get_len (&file_strcache, name);
+#endif
+ }
+
+#ifndef CONFIG_WITH_STRCACHE2
+ for (d = enter_file (strcache_add (".SUFFIXES"))->deps; d ; d = d->next)
+ {
+ unsigned int slen = strlen (dep_name (d));
+#else
+ for (d = enter_file (suffixes_strcached)->deps; d ; d = d->next)
+ {
+ unsigned int slen = strcache2_get_len (&file_strcache, dep_name (d));
+#endif
+ if (len > slen && strneq (dep_name (d), name + (len - slen), slen))
+ {
+ file->stem = strcache_add_len (name, len - slen);
+ break;
+ }
+ }
+ if (d == 0)
+ file->stem = "";
+ }
+ star = file->stem;
+
+ /* $< is the first not order-only dependency. */
+ less = "";
+ for (d = file->deps; d != 0; d = d->next)
+ if (!d->ignore_mtime)
+ {
+ if (!d->need_2nd_expansion)
+ less = dep_name (d);
+ break;
+ }
+
+ if (file->cmds == default_file->cmds)
+ /* This file got its commands from .DEFAULT.
+ In this case $< is the same as $@. */
+ less = at;
+
+#define DEFINE_VARIABLE(name, len, value) \
+ (void) define_variable_for_file (name,len,value,o_automatic,0,file)
+
+ /* Define the variables. */
+
+#ifndef CONFIG_WITH_RDONLY_VARIABLE_VALUE
+ DEFINE_VARIABLE ("<", 1, less);
+ DEFINE_VARIABLE ("*", 1, star);
+ DEFINE_VARIABLE ("@", 1, at);
+ DEFINE_VARIABLE ("%", 1, percent);
+#else /* CONFIG_WITH_RDONLY_VARIABLE_VALUE */
+# define DEFINE_VARIABLE_RO_VAL(name, len, value, value_len) \
+ define_variable_in_set((name), (len), (value), (value_len), -1, \
+ (o_automatic), 0, (file)->variables->set, NILF)
+
+ if (*less == '\0')
+ DEFINE_VARIABLE_RO_VAL ("<", 1, "", 0);
+ else if (less != at || at == file->name)
+ DEFINE_VARIABLE_RO_VAL ("<", 1, less, strcache_get_len (less));
+ else
+ DEFINE_VARIABLE ("<", 1, less);
+
+ if (*star == '\0')
+ DEFINE_VARIABLE_RO_VAL ("*", 1, "", 0);
+ else if (file->stem != org_stem)
+ DEFINE_VARIABLE_RO_VAL ("*", 1, star, strcache_get_len (star));
+ else
+ DEFINE_VARIABLE ("*", 1, star);
+
+ if (at == file->name)
+ DEFINE_VARIABLE_RO_VAL ("@", 1, at, strcache_get_len (at));
+ else
+ DEFINE_VARIABLE ("@", 1, at);
+
+ if (*percent == '\0')
+ DEFINE_VARIABLE_RO_VAL ("%", 1, "", 0);
+ else
+ DEFINE_VARIABLE ("%", 1, percent);
+#endif /* CONFIG_WITH_RDONLY_VARIABLE_VALUE */
+
+#if defined(CONFIG_WITH_COMMANDS_FUNC) || defined (CONFIG_WITH_DOT_MUST_MAKE)
+ /* The $^, $+, $? and $| variables should not be set if we're called
+ early by a .MUST_MAKE invocation or $(commands ). */
+ if (called_early)
+ return;
+#endif
+
+ /* Compute the values for $^, $+, $?, and $|. */
+#ifdef CONFIG_WITH_LAZY_DEPS_VARS
+ /* Lazy doesn't work for double colon rules with multiple files with
+ commands, nor for files that has been thru rehash_file() (vpath). */
+ if ( ( file->double_colon
+ && ( file->double_colon != file
+ || file->last != file))
+ || file->name != file->hname) /* XXX: Rehashed files should be fixable! */
+#endif
+ {
+ static char *plus_value=0, *bar_value=0, *qmark_value=0;
+ static unsigned int plus_max=0, bar_max=0, qmark_max=0;
+
+ unsigned int qmark_len, plus_len, bar_len;
+ char *cp;
+ char *caret_value;
+ char *qp;
+ char *bp;
+ unsigned int len;
+
+ struct hash_table dep_hash;
+ void **slot;
+
+ /* Compute first the value for $+, which is supposed to contain
+ duplicate dependencies as they were listed in the makefile. */
+
+ plus_len = 0;
+ bar_len = 0;
+ for (d = file->deps; d != 0; d = d->next)
+ {
+ if (!d->need_2nd_expansion)
+ {
+ if (d->ignore_mtime)
+#ifndef CONFIG_WITH_STRCACHE2
+ bar_len += strlen (dep_name (d)) + 1;
+#else
+ bar_len += strcache2_get_len (&file_strcache, dep_name (d)) + 1;
+#endif
+ else
+#ifndef CONFIG_WITH_STRCACHE2
+ plus_len += strlen (dep_name (d)) + 1;
+#else
+ plus_len += strcache2_get_len (&file_strcache, dep_name (d)) + 1;
+#endif
+ }
+ }
+
+ if (bar_len == 0)
+ bar_len++;
+ if (plus_len == 0)
+ plus_len++;
+
+ if (plus_len > plus_max)
+ plus_value = xrealloc (plus_value, plus_max = plus_len);
+
+ cp = plus_value;
+
+ qmark_len = plus_len + 1; /* Will be this or less. */
+ for (d = file->deps; d != 0; d = d->next)
+ if (! d->ignore_mtime && ! d->need_2nd_expansion)
+ {
+ const char *c = dep_name (d);
+
+#ifndef NO_ARCHIVES
+ if (ar_name (c))
+ {
+ c = strchr (c, '(') + 1;
+ len = strlen (c) - 1;
+ }
+ else
+#endif
+#ifndef CONFIG_WITH_STRCACHE2
+ len = strlen (c);
+#else
+ len = strcache2_get_len (&file_strcache, c);
+#endif
+
+ memcpy (cp, c, len);
+ cp += len;
+ *cp++ = FILE_LIST_SEPARATOR;
+ if (! (d->changed || always_make_flag))
+ qmark_len -= len + 1; /* Don't space in $? for this one. */
+ }
+
+ /* Kill the last space and define the variable. */
+
+ cp[cp > plus_value ? -1 : 0] = '\0';
+ DEFINE_VARIABLE ("+", 1, plus_value);
+
+ /* Compute the values for $^, $?, and $|. */
+
+ cp = caret_value = plus_value; /* Reuse the buffer; it's big enough. */
+
+ if (qmark_len > qmark_max)
+ qmark_value = xrealloc (qmark_value, qmark_max = qmark_len);
+ qp = qmark_value;
+
+ if (bar_len > bar_max)
+ bar_value = xrealloc (bar_value, bar_max = bar_len);
+ bp = bar_value;
+
+ /* Make sure that no dependencies are repeated in $^, $?, and $|. It
+ would be natural to combine the next two loops but we can't do it
+ because of a situation where we have two dep entries, the first
+ is order-only and the second is normal (see below). */
+
+ hash_init (&dep_hash, 500, dep_hash_1, dep_hash_2, dep_hash_cmp);
+
+ for (d = file->deps; d != 0; d = d->next)
+ {
+ if (d->need_2nd_expansion)
+ continue;
+
+ slot = hash_find_slot (&dep_hash, d);
+ if (HASH_VACANT (*slot))
+ hash_insert_at (&dep_hash, d, slot);
+ else
+ {
+ /* Check if the two prerequisites have different ignore_mtime.
+ If so then we need to "upgrade" one that is order-only. */
+
+ struct dep* hd = (struct dep*) *slot;
+
+ if (d->ignore_mtime != hd->ignore_mtime)
+ d->ignore_mtime = hd->ignore_mtime = 0;
+ }
+ }
+
+ for (d = file->deps; d != 0; d = d->next)
+ {
+ const char *c;
+
+ if (d->need_2nd_expansion || hash_find_item (&dep_hash, d) != d)
+ continue;
+
+ c = dep_name (d);
+#ifndef NO_ARCHIVES
+ if (ar_name (c))
+ {
+ c = strchr (c, '(') + 1;
+ len = strlen (c) - 1;
+ }
+ else
+#endif
+#ifndef CONFIG_WITH_STRCACHE2
+ len = strlen (c);
+#else
+ len = strcache2_get_len (&file_strcache, c);
+#endif
+
+ if (d->ignore_mtime)
+ {
+ memcpy (bp, c, len);
+ bp += len;
+ *bp++ = FILE_LIST_SEPARATOR;
+ }
+ else
+ {
+ memcpy (cp, c, len);
+ cp += len;
+ *cp++ = FILE_LIST_SEPARATOR;
+ if (d->changed || always_make_flag)
+ {
+ memcpy (qp, c, len);
+ qp += len;
+ *qp++ = FILE_LIST_SEPARATOR;
+ }
+ }
+ }
+
+ hash_free (&dep_hash, 0);
+
+ /* Kill the last spaces and define the variables. */
+
+ cp[cp > caret_value ? -1 : 0] = '\0';
+ DEFINE_VARIABLE ("^", 1, caret_value);
+
+ qp[qp > qmark_value ? -1 : 0] = '\0';
+ DEFINE_VARIABLE ("?", 1, qmark_value);
+
+ bp[bp > bar_value ? -1 : 0] = '\0';
+ DEFINE_VARIABLE ("|", 1, bar_value);
+ }
+#undef DEFINE_VARIABLE
+}
+
+/* Chop CMDS up into individual command lines if necessary.
+ Also set the 'lines_flags' and 'any_recurse' members. */
+
+void
+chop_commands (struct commands *cmds)
+{
+ unsigned int nlines, idx;
+ char **lines;
+
+ /* If we don't have any commands,
+ or we already parsed them, never mind. */
+
+ if (!cmds || cmds->command_lines != 0)
+ return;
+
+ /* Chop CMDS->commands up into lines in CMDS->command_lines. */
+
+ if (one_shell)
+ {
+ int l = strlen (cmds->commands);
+
+ nlines = 1;
+ lines = xmalloc (nlines * sizeof (char *));
+ lines[0] = xstrdup (cmds->commands);
+
+ /* Strip the trailing newline. */
+ if (l > 0 && lines[0][l-1] == '\n')
+ lines[0][l-1] = '\0';
+ }
+ else
+ {
+ const char *p;
+
+ nlines = 5;
+ lines = xmalloc (nlines * sizeof (char *));
+ idx = 0;
+ p = cmds->commands;
+ while (*p != '\0')
+ {
+ const char *end = p;
+ find_end:;
+ end = strchr (end, '\n');
+ if (end == 0)
+ end = p + strlen (p);
+ else if (end > p && end[-1] == '\\')
+ {
+ int backslash = 1;
+ const char *b;
+ for (b = end - 2; b >= p && *b == '\\'; --b)
+ backslash = !backslash;
+ if (backslash)
+ {
+ ++end;
+ goto find_end;
+ }
+ }
+
+ if (idx == nlines)
+ {
+ nlines += 2;
+ lines = xrealloc (lines, nlines * sizeof (char *));
+ }
+ lines[idx++] = xstrndup (p, end - p);
+ p = end;
+ if (*p != '\0')
+ ++p;
+ }
+
+ if (idx != nlines)
+ {
+ nlines = idx;
+ lines = xrealloc (lines, nlines * sizeof (char *));
+ }
+ }
+
+ /* Finally, set the corresponding CMDS->lines_flags elements and the
+ CMDS->any_recurse flag. */
+
+ if (nlines > USHRT_MAX)
+ ON (fatal, &cmds->fileinfo, _("Recipe has too many lines (%ud)"), nlines);
+
+ cmds->ncommand_lines = nlines;
+ cmds->command_lines = lines;
+
+ cmds->any_recurse = 0;
+#ifndef CONFIG_WITH_COMMANDS_FUNC
+ cmds->lines_flags = xmalloc (nlines);
+#else
+ cmds->lines_flags = xmalloc (nlines * sizeof (cmds->lines_flags[0]));
+#endif
+
+ for (idx = 0; idx < nlines; ++idx)
+ {
+ unsigned char flags = 0;
+ const char *p = lines[idx];
+
+ while (ISBLANK (*p) || *p == '-' || *p == '@' || *p == '+' IF_WITH_COMMANDS_FUNC(|| *p == '%'))
+ switch (*(p++))
+ {
+ case '+':
+ flags |= COMMANDS_RECURSE;
+ break;
+ case '@':
+ flags |= COMMANDS_SILENT;
+ break;
+ case '-':
+ flags |= COMMANDS_NOERROR;
+ break;
+#ifdef CONFIG_WITH_COMMANDS_FUNC
+ case '%':
+ flags |= COMMAND_GETTER_SKIP_IT;
+ break;
+#endif
+ }
+
+ /* If no explicit '+' was given, look for MAKE variable references. */
+ if (!(flags & COMMANDS_RECURSE)
+#ifndef KMK
+ && (strstr (p, "$(MAKE)") != 0 || strstr (p, "${MAKE}") != 0))
+#else
+ && (strstr (p, "$(KMK)") != 0 || strstr (p, "${KMK}") != 0 ||
+ strstr (p, "$(MAKE)") != 0 || strstr (p, "${MAKE}") != 0))
+#endif
+ flags |= COMMANDS_RECURSE;
+
+#ifdef CONFIG_WITH_KMK_BUILTIN
+ /* check if kmk builtin command */
+ if (!strncmp(p, "kmk_builtin_", sizeof("kmk_builtin_") - 1))
+ flags |= COMMANDS_KMK_BUILTIN;
+#endif
+
+ cmds->lines_flags[idx] = flags;
+ cmds->any_recurse |= flags & COMMANDS_RECURSE ? 1 : 0;
+ }
+}
+
+#ifdef CONFIG_WITH_MEMORY_OPTIMIZATIONS
+/* This is for saving memory in func_commands. */
+void
+free_chopped_commands (struct commands *cmds)
+{
+ if ( cmds
+ && cmds->command_lines != 0
+ && cmds->refs == 0)
+ {
+ unsigned idx = cmds->ncommand_lines;
+ while (idx-- > 0)
+ free (cmds->command_lines[idx]);
+ free (cmds->command_lines);
+ free (cmds->lines_flags);
+ cmds->command_lines = 0;
+ cmds->lines_flags = 0;
+ cmds->ncommand_lines = 0;
+ }
+}
+
+#endif /* CONFIG_WITH_MEMORY_OPTIMIZATIONS */
+/* Execute the commands to remake FILE. If they are currently executing,
+ return or have already finished executing, just return. Otherwise,
+ fork off a child process to run the first command line in the sequence. */
+
+void
+execute_file_commands (struct file *file)
+{
+ const char *p;
+
+ /* Don't go through all the preparations if
+ the commands are nothing but whitespace. */
+
+ for (p = file->cmds->commands; *p != '\0'; ++p)
+ if (!ISSPACE (*p) && *p != '-' && *p != '@' && *p != '+')
+ break;
+ if (*p == '\0')
+ {
+ /* If there are no commands, assume everything worked. */
+#ifdef CONFIG_WITH_EXTENDED_NOTPARALLEL
+ file->command_flags |= COMMANDS_NO_COMMANDS;
+#endif
+ set_command_state (file, cs_running);
+ file->update_status = us_success;
+ notice_finished_file (file);
+ return;
+ }
+
+ /* First set the automatic variables according to this file. */
+
+ initialize_file_variables (file, 0);
+
+#if defined(CONFIG_WITH_COMMANDS_FUNC) || defined (CONFIG_WITH_DOT_MUST_MAKE)
+ set_file_variables (file, 0 /* final call */);
+#else
+ set_file_variables (file);
+#endif
+
+ /* If this is a loaded dynamic object, unload it before remaking.
+ Some systems don't support overwriting a loaded object. */
+ if (file->loaded)
+ unload_file (file->name);
+
+ /* Start the commands running. */
+ new_job (file);
+}
+
+/* This is set while we are inside fatal_error_signal,
+ so things can avoid nonreentrant operations. */
+
+int handling_fatal_signal = 0;
+
+/* Handle fatal signals. */
+
+RETSIGTYPE
+fatal_error_signal (int sig)
+{
+#ifdef __MSDOS__
+ extern int dos_status, dos_command_running;
+
+ if (dos_command_running)
+ {
+ /* That was the child who got the signal, not us. */
+ dos_status |= (sig << 8);
+ return;
+ }
+ remove_intermediates (1);
+ exit (EXIT_FAILURE);
+#else /* not __MSDOS__ */
+#ifdef _AMIGA
+ remove_intermediates (1);
+ if (sig == SIGINT)
+ fputs (_("*** Break.\n"), stderr);
+
+ exit (10);
+#else /* not Amiga */
+#if defined (WINDOWS32) && !defined (CONFIG_NEW_WIN32_CTRL_EVENT)
+ extern HANDLE main_thread;
+
+ /* Windows creates a sperate thread for handling Ctrl+C, so we need
+ to suspend the main thread, or else we will have race conditions
+ when both threads call reap_children. */
+ if (main_thread)
+ {
+ DWORD susp_count = SuspendThread (main_thread);
+
+ if (susp_count != 0)
+ fprintf (stderr, "SuspendThread: suspend count = %ld\n", susp_count);
+ else if (susp_count == (DWORD)-1)
+ {
+ DWORD ierr = GetLastError ();
+
+ fprintf (stderr, "SuspendThread: error %ld: %s\n",
+ ierr, map_windows32_error_to_string (ierr));
+ }
+ }
+#endif
+ handling_fatal_signal = 1;
+
+ /* Set the handling for this signal to the default.
+ It is blocked now while we run this handler. */
+ signal (sig, SIG_DFL);
+
+ /* A termination signal won't be sent to the entire
+ process group, but it means we want to kill the children. */
+
+ if (sig == SIGTERM)
+ {
+ struct child *c;
+ for (c = children; c != 0; c = c->next)
+ if (!c->remote)
+# if defined (CONFIG_NEW_WIN_CHILDREN) && defined (WINDOWS32)
+ MkWinChildKill (c->pid, SIGTERM, c);
+# else
+ (void) kill (c->pid, SIGTERM);
+# endif
+ }
+
+ /* If we got a signal that means the user
+ wanted to kill make, remove pending targets. */
+
+ if (sig == SIGTERM || sig == SIGINT
+#ifdef SIGHUP
+ || sig == SIGHUP
+#endif
+#ifdef SIGQUIT
+ || sig == SIGQUIT
+#endif
+ )
+ {
+ struct child *c;
+
+ /* Remote children won't automatically get signals sent
+ to the process group, so we must send them. */
+ for (c = children; c != 0; c = c->next)
+ if (c->remote)
+ (void) remote_kill (c->pid, sig);
+
+ for (c = children; c != 0; c = c->next)
+ delete_child_targets (c);
+
+ /* Clean up the children. We don't just use the call below because
+ we don't want to print the "Waiting for children" message. */
+ while (job_slots_used > 0)
+ reap_children (1, 0);
+ }
+ else
+ /* Wait for our children to die. */
+ while (job_slots_used > 0)
+ reap_children (1, 1);
+
+ /* Delete any non-precious intermediate files that were made. */
+
+ remove_intermediates (1);
+#ifdef SIGQUIT
+ if (sig == SIGQUIT)
+ /* We don't want to send ourselves SIGQUIT, because it will
+ cause a core dump. Just exit instead. */
+ exit (MAKE_TROUBLE);
+#endif
+
+#ifdef WINDOWS32
+# ifndef CONFIG_NEW_WIN32_CTRL_EVENT
+ if (main_thread)
+ CloseHandle (main_thread);
+# endif /* !CONFIG_NEW_WIN32_CTRL_EVENT */
+ /* Cannot call W32_kill with a pid (it needs a handle). The exit
+ status of 130 emulates what happens in Bash. */
+ exit (130);
+#else
+ /* Signal the same code; this time it will really be fatal. The signal
+ will be unblocked when we return and arrive then to kill us. */
+ if (kill (getpid (), sig) < 0)
+ pfatal_with_name ("kill");
+#endif /* not WINDOWS32 */
+#endif /* not Amiga */
+#endif /* not __MSDOS__ */
+}
+
+/* Delete FILE unless it's precious or not actually a file (phony),
+ and it has changed on disk since we last stat'd it. */
+
+static void
+delete_target (struct file *file, const char *on_behalf_of)
+{
+ struct stat st;
+ int e;
+
+ if (file->precious || file->phony)
+ return;
+#ifdef CONFIG_WITH_EXPLICIT_MULTITARGET
+ assert (!file->multi_maybe);
+#endif
+
+#ifndef NO_ARCHIVES
+ if (ar_name (file->name))
+ {
+ time_t file_date = (file->last_mtime == NONEXISTENT_MTIME
+ ? (time_t) -1
+ : (time_t) FILE_TIMESTAMP_S (file->last_mtime));
+ if (ar_member_date (file->name) != file_date)
+ {
+ if (on_behalf_of)
+ OSS (error, NILF,
+ _("*** [%s] Archive member '%s' may be bogus; not deleted"),
+ on_behalf_of, file->name);
+ else
+ OS (error, NILF,
+ _("*** Archive member '%s' may be bogus; not deleted"),
+ file->name);
+ }
+ return;
+ }
+#endif
+
+ EINTRLOOP (e, stat (file->name, &st));
+ if (e == 0
+ && S_ISREG (st.st_mode)
+ && FILE_TIMESTAMP_STAT_MODTIME (file->name, st) != file->last_mtime)
+ {
+ if (on_behalf_of)
+ OSS (error, NILF,
+ _("*** [%s] Deleting file '%s'"), on_behalf_of, file->name);
+ else
+ OS (error, NILF, _("*** Deleting file '%s'"), file->name);
+ if (unlink (file->name) < 0
+ && errno != ENOENT) /* It disappeared; so what. */
+ perror_with_name ("unlink: ", file->name);
+ }
+}
+
+
+/* Delete all non-precious targets of CHILD unless they were already deleted.
+ Set the flag in CHILD to say they've been deleted. */
+
+void
+delete_child_targets (struct child *child)
+{
+ struct dep *d;
+
+ if (child->deleted)
+ return;
+
+ /* Delete the target file if it changed. */
+ delete_target (child->file, NULL);
+
+ /* Also remove any non-precious targets listed in the 'also_make' member. */
+ for (d = child->file->also_make; d != 0; d = d->next)
+ delete_target (d->file, child->file->name);
+
+#ifdef CONFIG_WITH_EXPLICIT_MULTITARGET
+ /* Also remove any multi target siblings, except for the 'maybe' ones (we
+ handle that here) and precious ones (delete_target deals with that).
+ Note that CHILD is always the multi target head (see remake.c). */
+ if (child->file == child->file->multi_head)
+ {
+ struct file *f2;
+ for (f2 = child->file->multi_next; f2; f2 = f2->multi_next)
+ if (!f2->multi_maybe)
+ delete_target (f2, child->file->name);
+ }
+#endif
+
+ child->deleted = 1;
+}
+
+/* Print out the commands in CMDS. */
+
+void
+print_commands (const struct commands *cmds)
+{
+ const char *s;
+
+ fputs (_("# recipe to execute"), stdout);
+
+ if (cmds->fileinfo.filenm == 0)
+ puts (_(" (built-in):"));
+ else
+ printf (_(" (from '%s', line %lu):\n"),
+ cmds->fileinfo.filenm, cmds->fileinfo.lineno);
+
+ s = cmds->commands;
+ while (*s != '\0')
+ {
+ const char *end;
+ int bs;
+
+ /* Print one full logical recipe line: find a non-escaped newline. */
+ for (end = s, bs = 0; *end != '\0'; ++end)
+ {
+ if (*end == '\n' && !bs)
+ break;
+
+ bs = *end == '\\' ? !bs : 0;
+ }
+
+ printf ("%c%.*s\n", cmd_prefix, (int) (end - s), s);
+
+ s = end + (end[0] == '\n');
+ }
+}