1 files changed, 237 insertions, 79 deletions

diff --git a/miscutils/make.c b/miscutils/make.c
index 7316408bf..a165274aa 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 {
@@ -320,11 +325,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.
@@ -469,8 +471,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;
 }
 
@@ -993,38 +994,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 +1022,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 +1034,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 +1057,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 +1855,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 +1869,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 +1923,6 @@ enum {
 static int
 target_type(char *s)
 {
-        char *sfx;
         int ret;
         static const char *s_name =
                 ".DEFAULT\0"
@@ -1854,9 +1952,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 +1959,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 +2171,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 +2403,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';
@@ -2585,9 +2701,34 @@ docmds(struct name *np, struct cmd *cp)
         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 +2744,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 +2755,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 +2819,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 +2843,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 +2861,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 +2895,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 +2933,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 +2949,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 +2958,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) {