5 files changed, 280 insertions, 91 deletions

diff --git a/miscutils/crond.c b/miscutils/crond.c
index b3762d327..6a384fdfb 100644
--- a/miscutils/crond.c
+++ b/miscutils/crond.c
@@ -177,7 +177,7 @@ static void crondlog(unsigned level, const char *msg, va_list va)
 {
         if (level >= G.log_level) {
                 /*
-                 * We are called only for info meesages.
+                 * We are called only for info messages.
                  * Warnings/errors use plain bb_[p]error_msg's, which
                  * need not touch syslog_level
                  * (they are ok with LOG_ERR default).
@@ -989,7 +989,7 @@ static int check_completions(void)
                         if (line->cl_pid <= 0)
                                 continue;
 
-                        r = waitpid(line->cl_pid, NULL, WNOHANG);
+                        r = safe_waitpid(line->cl_pid, NULL, WNOHANG);
                         if (r < 0 || r == line->cl_pid) {
                                 process_finished_job(file->cf_username, line);
                                 if (line->cl_pid == 0) {
@@ -1001,6 +1001,14 @@ static int check_completions(void)
                         /* else: r == 0: "process is still running" */
                         file->cf_has_running = 1;
                 }
+
+                /* Reap any other children we don't actively track.
+                 * Reportedly, some people run crond as init process!
+                 * Thus, we need to reap orphans, like init does.
+                 */
+                while (wait_any_nohang(NULL) > 0)
+                        continue;
+
 //FIXME: if !file->cf_has_running && file->deleted: delete it!
 //otherwise deleted entries will stay forever, right?
                 num_still_running += file->cf_has_running;
diff --git a/miscutils/fbsplash.c b/miscutils/fbsplash.c
index 2934d8eb7..912a501a3 100644
--- a/miscutils/fbsplash.c
+++ b/miscutils/fbsplash.c
@@ -382,7 +382,7 @@ static void fb_drawimage(void)
         if (LONE_DASH(G.image_filename)) {
                 theme_file = stdin;
         } else {
-                int fd = open_zipped(G.image_filename, /*fail_if_not_compressed:*/ 0);
+                int fd = open_zipped(G.image_filename, /*die_if_not_compressed:*/ 0);
                 if (fd < 0)
                         bb_simple_perror_msg_and_die(G.image_filename);
                 theme_file = xfdopen_for_read(fd);
diff --git a/miscutils/less.c b/miscutils/less.c
index 467c76e2a..5a8fc5a74 100644
--- a/miscutils/less.c
+++ b/miscutils/less.c
@@ -1178,7 +1178,7 @@ static int64_t getch_nowait(void)
 
         /* We have kbd_fd in O_NONBLOCK mode, read inside safe_read_key()
          * would not block even if there is no input available */
-        key64 = safe_read_key(kbd_fd, kbd_input, /*timeout off:*/ -2);
+        key64 = safe_read_key(kbd_fd, kbd_input, /*do not poll:*/ -2);
         if ((int)key64 == -1) {
                 if (errno == EAGAIN) {
                         /* No keyboard input available. Since poll() did return,
diff --git a/miscutils/make.c b/miscutils/make.c
index 7316408bf..8026917b3 100644
--- a/miscutils/make.c
+++ b/miscutils/make.c
@@ -257,6 +257,11 @@ enum {
 #define MAKE_FAILURE            0x01
 #define MAKE_DIDSOMETHING       0x02
 
+// Return TRUE if c is allowed in a POSIX 2017 macro or target name
+#define ispname(c) (isalpha(c) || isdigit(c) || c == '.' || c == '_')
+// Return TRUE if c is in the POSIX 'portable filename character set'
+#define isfname(c) (ispname(c) || c == '-')
+
 #define HTABSIZE 39
 
 struct globals {
@@ -271,6 +276,7 @@ struct globals {
         time_t ar_mtime;
         int lineno;     // Physical line number in file
         int dispno;     // Line number for display purposes
+        struct cmd *curr_cmd;
         const char *rulepos;
         int rule_idx;
 #define IF_MAX 10
@@ -302,6 +308,7 @@ struct globals {
 #define ar_mtime        (G.ar_mtime)
 #define lineno          (G.lineno)
 #define dispno          (G.dispno)
+#define curr_cmd        (G.curr_cmd)
 #define rulepos         (G.rulepos)
 #define rule_idx        (G.rule_idx)
 #define clevel          (G.clevel)
@@ -320,11 +327,8 @@ struct globals {
 #endif
 
 static int make(struct name *np, int level);
-
-// Return TRUE if c is allowed in a POSIX 2017 macro or target name
-#define ispname(c) (isalpha(c) || isdigit(c) || c == '.' || c == '_')
-// Return TRUE if c is in the POSIX 'portable filename character set'
-#define isfname(c) (ispname(c) || c == '-')
+static struct name *dyndep(struct name *np, struct rule *infrule,
+                                                                const char **ptsuff);
 
 /*
  * Utility functions.
@@ -336,9 +340,20 @@ static int make(struct name *np, int level);
 static void
 vwarning(FILE *stream, const char *msg, va_list list)
 {
+        const char *m = NULL;
+        int d = 0;
+
+        if (curr_cmd) {
+                m = curr_cmd->c_makefile;
+                d = curr_cmd->c_dispno;
+        } else if (makefile) {
+                m = makefile;
+                d = dispno;
+        }
+
         fprintf(stream, "%s: ", applet_name);
-        if (makefile)
-                fprintf(stream, "(%s:%d): ", makefile, dispno);
+        if (m)
+                fprintf(stream, "(%s:%d): ", m, d);
         vfprintf(stream, msg, list);
         fputc('\n', stream);
 }
@@ -469,8 +484,7 @@ newcmd(struct cmd **cphead, char *str)
         /*(*cphead)->c_next = NULL; - xzalloc did it */
         (*cphead)->c_cmd = xstrdup(str);
         /*(*cphead)->c_refcnt = 0; */
-        if (makefile)
-                (*cphead)->c_makefile = xstrdup(makefile);
+        (*cphead)->c_makefile = xstrdup(makefile);
         (*cphead)->c_dispno = dispno;
 }
 
@@ -725,6 +739,7 @@ addrule(struct name *np, struct depend *dp, struct cmd *cp, int flag)
 {
         struct rule *rp;
         struct rule **rpp;
+        struct cmd *old_cp;
 
         // Can't mix single-colon and double-colon rules
         if (!posix && (np->n_flag & N_TARGET)) {
@@ -741,7 +756,7 @@ addrule(struct name *np, struct depend *dp, struct cmd *cp, int flag)
                 return;
         }
 
-        if (cp && !(np->n_flag & N_DOUBLE) && getcmd(np)) {
+        if (cp && !(np->n_flag & N_DOUBLE) && (old_cp = getcmd(np))) {
                 // Handle the inference rule redefinition case
                 // .DEFAULT rule can also be redefined (as an extension).
                 if ((np->n_flag & N_INFERENCE)
@@ -750,7 +765,17 @@ addrule(struct name *np, struct depend *dp, struct cmd *cp, int flag)
                         freerules(np->n_rule);
                         np->n_rule = NULL;
                 } else {
-                        error("commands defined twice for target %s", np->n_name);
+                        // We're adding commands to a single colon rule which
+                        // already has some.  Clear the old ones first.
+                        warning("overriding rule for target %s", np->n_name);
+                        curr_cmd = old_cp;
+                        warning("previous rule for target %s", np->n_name);
+                        curr_cmd = NULL;
+
+                        for (rp = np->n_rule; rp; rp = rp->r_next) {
+                                freecmds(rp->r_cmd);
+                                rp->r_cmd = NULL;
+                        }
                 }
         }
 
@@ -993,38 +1018,27 @@ suffix(const char *name)
 }
 
 /*
- * Dynamic dependency.  This routine applies the suffix rules
- * to try and find a source and a set of rules for a missing
- * target.  NULL is returned on failure.  On success the name of
- * the implicit prerequisite is returned and the details are
- * placed in the imprule structure provided by the caller.
+ * Search for an inference rule to convert some suffix ('psuff')
+ * to the target suffix 'tsuff'.  The basename of the prerequisite
+ * is 'base'.
  */
 static struct name *
-dyndep(struct name *np, struct rule *imprule)
+dyndep0(char *base, const char *tsuff, struct rule *infrule)
 {
-        char *suff, *newsuff;
-        char *base, *name, *member;
+        char *psuff;
         struct name *xp;                // Suffixes
         struct name *sp;                // Suffix rule
-        struct name *pp = NULL; // Implicit prerequisite
         struct rule *rp;
         struct depend *dp;
         bool chain = FALSE;
 
-        member = NULL;
-        name = splitlib(np->n_name, &member);
-
-        suff = xstrdup(suffix(name));
-        base = member ? member : name;
-        *suffix(base) = '\0';
-
         xp = newname(".SUFFIXES");
  retry:
         for (rp = xp->n_rule; rp; rp = rp->r_next) {
                 for (dp = rp->r_dep; dp; dp = dp->d_next) {
                         // Generate new suffix rule to try
-                        newsuff = dp->d_name->n_name;
-                        sp = findname(auto_concat(newsuff, suff));
+                        psuff = dp->d_name->n_name;
+                        sp = findname(auto_concat(psuff, tsuff));
                         if (sp && sp->n_rule) {
                                 struct name *ip;
                                 int got_ip;
@@ -1032,9 +1046,8 @@ dyndep(struct name *np, struct rule *imprule)
                                 // Has rule already been used in this chain?
                                 if ((sp->n_flag & N_MARK))
                                         continue;
-
                                 // Generate a name for an implicit prerequisite
-                                ip = newname(auto_concat(base, newsuff));
+                                ip = newname(auto_concat(base, psuff));
                                 if ((ip->n_flag & N_DOING))
                                         continue;
 
@@ -1045,20 +1058,19 @@ dyndep(struct name *np, struct rule *imprule)
                                         got_ip = ip->n_tim.tv_sec || (ip->n_flag & N_TARGET);
                                 } else {
                                         sp->n_flag |= N_MARK;
-                                        got_ip = dyndep(ip, NULL) != NULL;
+                                        got_ip = dyndep(ip, NULL, NULL) != NULL;
                                         sp->n_flag &= ~N_MARK;
                                 }
 
                                 if (got_ip) {
                                         // Prerequisite exists or we know how to make it
-                                        if (imprule) {
+                                        if (infrule) {
                                                 dp = NULL;
                                                 newdep(&dp, ip);
-                                                imprule->r_dep = dp;
-                                                imprule->r_cmd = sp->n_rule->r_cmd;
+                                                infrule->r_dep = dp;
+                                                infrule->r_cmd = sp->n_rule->r_cmd;
                                         }
-                                        pp = ip;
-                                        goto finish;
+                                        return ip;
                                 }
                         }
                 }
@@ -1069,9 +1081,87 @@ dyndep(struct name *np, struct rule *imprule)
                 chain = TRUE;
                 goto retry;
         }
- finish:
-        free(suff);
+        return NULL;
+}
+
+/*
+ * If 'name' ends with 'suffix' return an allocated string containing
+ * the name with the suffix removed, else return NULL.
+ */
+static char *
+has_suffix(const char *name, const char *suffix)
+{
+        ssize_t delta = strlen(name) - strlen(suffix);
+        char *base = NULL;
+
+        if (delta > 0 && strcmp(name + delta, suffix) == 0) {
+                base = xstrdup(name);
+                base[delta] = '\0';
+        }
+
+        return base;
+}
+
+/*
+ * Dynamic dependency.  This routine applies the suffix rules
+ * to try and find a source and a set of rules for a missing
+ * target.  NULL is returned on failure.  On success the name of
+ * the implicit prerequisite is returned and the rule used is
+ * placed in the infrule structure provided by the caller.
+ */
+static struct name *
+dyndep(struct name *np, struct rule *infrule, const char **ptsuff)
+{
+        const char *tsuff;
+        char *base, *name, *member;
+        struct name *pp = NULL; // Implicit prerequisite
+
+        member = NULL;
+        name = splitlib(np->n_name, &member);
+
+        // POSIX only allows inference rules with one or two periods.
+        // As an extension this restriction is lifted, but not for
+        // targets of the form lib.a(member.o).
+        if (!posix && member == NULL) {
+                struct name *xp = newname(".SUFFIXES");
+                int found_suffix = FALSE;
+
+                for (struct rule *rp = xp->n_rule; rp; rp = rp->r_next) {
+                        for (struct depend *dp = rp->r_dep; dp; dp = dp->d_next) {
+                                tsuff = dp->d_name->n_name;
+                                base = has_suffix(name, tsuff);
+                                if (base) {
+                                        found_suffix = TRUE;
+                                        pp = dyndep0(base, tsuff, infrule);
+                                        free(base);
+                                        if (pp) {
+                                                goto done;
+                                        }
+                                }
+                        }
+                }
+
+                if (!found_suffix) {
+                        // The name didn't have a known suffix. Try single-suffix rule.
+                        tsuff = "";
+                        pp = dyndep0(name, tsuff, infrule);
+                        if (pp) {
+ done:
+                                if (ptsuff) {
+                                        *ptsuff = tsuff;
+                                }
+                        }
+                }
+        } else {
+                tsuff = xstrdup(suffix(name));
+                base = member ? member : name;
+                *suffix(base) = '\0';
+
+                pp = dyndep0(base, tsuff, infrule);
+                free((void *)tsuff);
+        }
         free(name);
+
         return pp;
 }
 
@@ -1789,9 +1879,10 @@ readline(FILE *fd, int want_command)
 }
 
 /*
- * Return TRUE if the argument is a known suffix.
+ * Return a pointer to the suffix name if the argument is a known suffix
+ * or NULL if it isn't.
  */
-static int
+static const char *
 is_suffix(const char *s)
 {
         struct name *np;
@@ -1802,7 +1893,39 @@ is_suffix(const char *s)
         for (rp = np->n_rule; rp; rp = rp->r_next) {
                 for (dp = rp->r_dep; dp; dp = dp->d_next) {
                         if (strcmp(s, dp->d_name->n_name) == 0) {
-                                return TRUE;
+                                return dp->d_name->n_name;
+                        }
+                }
+        }
+        return NULL;
+}
+
+/*
+ * Return TRUE if the argument is formed by concatenating two
+ * known suffixes.
+ */
+static int
+is_inference_target(const char *s)
+{
+        struct name *np;
+        struct rule *rp1, *rp2;
+        struct depend *dp1, *dp2;
+
+        np = newname(".SUFFIXES");
+        for (rp1 = np->n_rule; rp1; rp1 = rp1->r_next) {
+                for (dp1 = rp1->r_dep; dp1; dp1 = dp1->d_next) {
+                        const char *suff1 = dp1->d_name->n_name;
+                        size_t len = strlen(suff1);
+
+                        if (strncmp(s, suff1, len) == 0) {
+                                for (rp2 = np->n_rule; rp2; rp2 = rp2->r_next) {
+                                        for (dp2 = rp2->r_dep; dp2; dp2 = dp2->d_next) {
+                                                const char *suff2 = dp2->d_name->n_name;
+                                                if (strcmp(s + len, suff2) == 0) {
+                                                        return TRUE;
+                                                }
+                                        }
+                                }
                         }
                 }
         }
@@ -1824,7 +1947,6 @@ enum {
 static int
 target_type(char *s)
 {
-        char *sfx;
         int ret;
         static const char *s_name =
                 ".DEFAULT\0"
@@ -1854,9 +1976,6 @@ target_type(char *s)
                 T_SPECIAL,
         };
 
-        if (*s != '.')
-                return T_NORMAL;
-
         // Check for one of the known special targets
         ret = index_in_strings(s_name, s);
         if (ret >= 0)
@@ -1864,16 +1983,23 @@ target_type(char *s)
 
         // Check for an inference rule
         ret = T_NORMAL;
-        sfx = suffix(s);
-        if (is_suffix(sfx)) {
-                if (s == sfx) { // Single suffix rule
+        if (!posix) {
+                if (is_suffix(s) || is_inference_target(s)) {
                         ret = T_INFERENCE | T_NOPREREQ | T_COMMAND;
-                } else {
-                        // Suffix is valid, check that prefix is too
-                        *sfx = '\0';
-                        if (is_suffix(s))
+                }
+        } else {
+                // In POSIX inference rule targets must contain one or two dots
+                char *sfx = suffix(s);
+                if (*s == '.' && is_suffix(sfx)) {
+                        if (s == sfx) { // Single suffix rule
                                 ret = T_INFERENCE | T_NOPREREQ | T_COMMAND;
-                        *sfx = '.';
+                        } else {
+                                // Suffix is valid, check that prefix is too
+                                *sfx = '\0';
+                                if (is_suffix(s))
+                                        ret = T_INFERENCE | T_NOPREREQ | T_COMMAND;
+                                *sfx = '.';
+                        }
                 }
         }
         return ret;
@@ -2069,6 +2195,20 @@ pragmas_from_env(void)
 #endif
 
 /*
+ * Determine if a line is a target rule with an inline command.
+ * Return a pointer to the semicolon separator if it is, else NULL.
+ */
+static char *
+inline_command(char *line)
+{
+        char *p = find_char(line, ':');
+
+        if (p)
+                p = strchr(p, ';');
+        return p;
+}
+
+/*
  * Parse input from the makefile and construct a tree structure of it.
  */
 static void
@@ -2287,9 +2427,9 @@ input(FILE *fd, int ilevel)
                 cp = NULL;
                 s = strchr(q, ';');
                 if (s) {
-                        // Retrieve command from expanded copy of line
+                        // Retrieve command from original or expanded copy of line
                         char *copy3 = expand_macros(copy, FALSE);
-                        if ((p = find_colon(copy3)) && (p = strchr(p, ';')))
+                        if ((p = inline_command(copy)) || (p = inline_command(copy3)))
                                 newcmd(&cp, process_command(p + 1));
                         free(copy3);
                         *s = '\0';
@@ -2486,8 +2626,7 @@ docmds(struct name *np, struct cmd *cp)
                 uint32_t ssilent, signore, sdomake;
 
                 // Location of command in makefile (for use in error messages)
-                makefile = cp->c_makefile;
-                dispno = cp->c_dispno;
+                curr_cmd = cp;
                 opts &= ~OPT_make;      // We want to know if $(MAKE) is expanded
                 q = command = expand_macros(cp->c_cmd, FALSE);
                 ssilent = silent || (np->n_flag & N_SILENT) || dotouch;
@@ -2581,13 +2720,38 @@ docmds(struct name *np, struct cmd *cp)
                 estat = MAKE_DIDSOMETHING;
         }
 
-        makefile = NULL;
+        curr_cmd = NULL;
         return estat;
 }
 
+/*
+ * Remove the suffix from a name, either the one provided in 'tsuff'
+ * or, if 'tsuff' is NULL, one of the known suffixes.
+ */
+static char *
+remove_suffix(const char *name, const char *tsuff)
+{
+        char *base = NULL;
+
+        if (tsuff != NULL) {
+                base = has_suffix(name, tsuff);
+        } else {
+                struct name *xp = newname(".SUFFIXES");
+                for (struct rule *rp = xp->n_rule; rp; rp = rp->r_next) {
+                        for (struct depend *dp = rp->r_dep; dp; dp = dp->d_next) {
+                                base = has_suffix(name, dp->d_name->n_name);
+                                if (base) {
+                                        return base;
+                                }
+                        }
+                }
+        }
+        return base;
+}
+
 static int
 make1(struct name *np, struct cmd *cp, char *oodate, char *allsrc,
-                char *dedup, struct name *implicit)
+                char *dedup, struct name *implicit, const char *tsuff)
 {
         char *name, *member = NULL, *base = NULL, *prereq = NULL;
 
@@ -2603,7 +2767,7 @@ make1(struct name *np, struct cmd *cp, char *oodate, char *allsrc,
                 char *s;
 
                 // As an extension, if we're not dealing with an implicit
-                // rule set $< to the first out-of-date prerequisite.
+                // prerequisite set $< to the first out-of-date prerequisite.
                 if (implicit == NULL) {
                         if (oodate) {
                                 s = strchr(oodate, ' ');
@@ -2614,15 +2778,26 @@ make1(struct name *np, struct cmd *cp, char *oodate, char *allsrc,
                 } else
                         prereq = implicit->n_name;
 
-                base = member ? member : name;
-                s = suffix(base);
-                // As an extension, if we're not dealing with an implicit
-                // rule and the target ends with a known suffix, remove it
-                // and set $* to the stem, else to an empty string.
-                if (implicit == NULL && !is_suffix(s))
-                        base = NULL;
-                else
-                        *s = '\0';
+                if (!posix && member == NULL) {
+                        // As an extension remove a suffix that doesn't necessarily
+                        // start with a period from a target, but not for targets
+                        // of the form lib.a(member.o).
+                        base = remove_suffix(name, tsuff);
+                        if (base) {
+                                free(name);
+                                name = base;
+                        }
+                } else {
+                        base = member ? member : name;
+                        s = suffix(base);
+                        // As an extension, if we're not dealing with an implicit
+                        // prerequisite and the target ends with a known suffix,
+                        // remove it and set $* to the stem, else to an empty string.
+                        if (implicit == NULL && !is_suffix(s))
+                                base = NULL;
+                        else
+                                *s = '\0';
+                }
         }
         setmacro("<", prereq, 0 | M_VALID);
         setmacro("*", base, 0 | M_VALID);
@@ -2667,11 +2842,12 @@ make(struct name *np, int level)
         struct depend *dp;
         struct rule *rp;
         struct name *impdep = NULL;     // implicit prerequisite
-        struct rule imprule;
+        struct rule infrule;
         struct cmd *sc_cmd = NULL;      // commands for single-colon rule
         char *oodate = NULL;
         char *allsrc = NULL;
         char *dedup = NULL;
+        const char *tsuff = NULL;
         struct timespec dtim = {1, 0};
         int estat = 0;
 
@@ -2690,10 +2866,10 @@ make(struct name *np, int level)
                 // as an extension, not for phony targets)
                 sc_cmd = getcmd(np);
                 if (!sc_cmd && (posix || !(np->n_flag & N_PHONY))) {
-                        impdep = dyndep(np, &imprule);
+                        impdep = dyndep(np, &infrule, &tsuff);
                         if (impdep) {
-                                sc_cmd = imprule.r_cmd;
-                                addrule(np, imprule.r_dep, NULL, FALSE);
+                                sc_cmd = infrule.r_cmd;
+                                addrule(np, infrule.r_dep, NULL, FALSE);
                         }
                 }
 
@@ -2708,14 +2884,15 @@ make(struct name *np, int level)
                         }
                         impdep = np;
                 }
-        }
-        else {
+        } else {
                 // If any double-colon rule has no commands we need
-                // an inference rule (but, as an extension, not for phony targets)
+                // an inference rule.
                 for (rp = np->n_rule; rp; rp = rp->r_next) {
                         if (!rp->r_cmd) {
-                                if (posix || !(np->n_flag & N_PHONY))
-                                        impdep = dyndep(np, &imprule);
+                                // Phony targets don't need an inference rule.
+                                if (!posix && (np->n_flag & N_PHONY))
+                                        continue;
+                                impdep = dyndep(np, &infrule, &tsuff);
                                 if (!impdep) {
                                         if (doinclude)
                                                 return 1;
@@ -2741,11 +2918,14 @@ make(struct name *np, int level)
                 // Each double-colon rule is handled separately.
                 if ((np->n_flag & N_DOUBLE)) {
                         // If the rule has no commands use the inference rule.
+                        // Unless there isn't one, as allowed for phony targets.
                         if (!rp->r_cmd) {
-                                locdep = impdep;
-                                imprule.r_dep->d_next = rp->r_dep;
-                                rp->r_dep = imprule.r_dep;
-                                rp->r_cmd = imprule.r_cmd;
+                                if (impdep) {
+                                        locdep = impdep;
+                                        infrule.r_dep->d_next = rp->r_dep;
+                                        rp->r_dep = infrule.r_dep;
+                                        rp->r_cmd = infrule.r_cmd;
+                                }
                         }
                         // A rule with no prerequisities is executed unconditionally.
                         if (!rp->r_dep)
@@ -2776,7 +2956,7 @@ make(struct name *np, int level)
                         if (((np->n_flag & N_PHONY) || timespec_le(&np->n_tim, &dtim))) {
                                 if (!(estat & MAKE_FAILURE)) {
                                         estat |= make1(np, rp->r_cmd, oodate, allsrc,
-                                                                                dedup, locdep);
+                                                                                dedup, locdep, tsuff);
                                         dtim = (struct timespec){1, 0};
                                 }
                                 free(oodate);
@@ -2792,7 +2972,7 @@ make(struct name *np, int level)
                 }
         }
         if ((np->n_flag & N_DOUBLE) && impdep)
-                free(imprule.r_dep);
+                free(infrule.r_dep);
 
         np->n_flag |= N_DONE;
         np->n_flag &= ~N_DOING;
@@ -2801,7 +2981,8 @@ make(struct name *np, int level)
                                 ((np->n_flag & N_PHONY) || (timespec_le(&np->n_tim, &dtim)))) {
                 if (!(estat & MAKE_FAILURE)) {
                         if (sc_cmd)
-                                estat |= make1(np, sc_cmd, oodate, allsrc, dedup, impdep);
+                                estat |= make1(np, sc_cmd, oodate, allsrc, dedup,
+                                                                impdep, tsuff);
                         else if (!doinclude && level == 0 && !(estat & MAKE_DIDSOMETHING))
                                 warning("nothing to be done for %s", np->n_name);
                 } else if (!doinclude && !quest) {
diff --git a/miscutils/man.c b/miscutils/man.c
index 3954455b4..38c1b9aa3 100644
--- a/miscutils/man.c
+++ b/miscutils/man.c
@@ -143,7 +143,7 @@ static int run_pipe(char *man_filename, int man, int level)
 
  ordinary_manpage:
         close(STDIN_FILENO);
-        open_zipped(man_filename, /*fail_if_not_compressed:*/ 0); /* guaranteed to use fd 0 (STDIN_FILENO) */
+        open_zipped(man_filename, /*die_if_not_compressed:*/ 0); /* guaranteed to use fd 0 (STDIN_FILENO) */
         if (man) {
                 int w = get_terminal_width(-1);
                 if (w > 10)