GNU make shell assignment patch by David A. Wheeler, 2010-10-23

I propose adding support for the BSD "shell assignment" operator, and I've attached a patch to add this support.

Many "make" implementations support the shell assignment operator "!=".  This includes the "make" of FreeBSD, OpenBSD, and NetBSD:
http://www.freebsd.org/cgi/man.cgi?query=make&sektion=1
http://www.openbsd.org/cgi-bin/man.cgi?query=make&apropos=0&sektion=0&manpath=OpenBSD+Current&arch=i386&format=html
http://netbsd.gw.com/cgi-bin/man-cgi?make+1+NetBSD-current
It is also supported by the "pmake" program of Adam de Boor:
http://www.freebsd.org/doc/en/books/pmake/variables.html

The semantics are not complicated.  Given:
  string1 != string2
The macro named string1 is a recursively-defined variable, with a value determined by the following process: First, string2 is *immediately* evaluated. Second, that resulting evaluation is passed to the shell for execution. Third, that result is modified removing a single trailing newline (if there is one), and then replacing all remaining newlines with spaces.

GNU make can't currently handle BSD makefiles with "!=", since it doesn't have the operator.  It's not even easy to simulate with the current GNU make constructs.  In many cases, this GNU make construct will have the same final result:
  VAR = ${system echo "$(STUFF)" | sed -e 's/://'}
but notice that $(VAR) is re-evaluated *EVERY TIME*, creating efficiency problems, and the change in result may be surprising.  GNU make's ":=" doesn't quite do it either:
  VAR := ${system echo "$(STUFF)" | sed -e 's/://'}
In this case, in GNU make it's executed only once, while with BSD make the result is recursively evaluated.  Thus, in GNU make using := you cannot insert $(VAR2) as the output of the shell script and have it be re-evaluated.  Nothing in GNU make does this exactly... so those wanting this functionality will want it added.

The following patch adds this capability to GNU make, and includes test cases.  This patch works against GNU make per its CVS repository of 2010-10-23.

This patch is released under either GNU GPL version 2 or later, or
the BSD 3-clause license.  Thus, it's compatible with lots of licenses
including the current and older licenses used by GNU make.

This is also available from:
 http://www.dwheeler.com/misc/shell-assignment.patch


==================================================

--- ./read.c.orig	2010-08-13 22:50:14.000000000 -0400
+++ ./read.c	2010-10-23 18:52:42.285751829 -0400
@@ -2470,7 +2470,7 @@
      w_colon        A colon
      w_dcolon       A double-colon
      w_semicolon    A semicolon
-     w_varassign    A variable assignment operator (=, :=, +=, or ?=)
+     w_varassign    A variable assignment operator (=, :=, +=, ?=, or !=)
 
    Note that this function is only used when reading certain parts of the
    makefile.  Don't use it where special rules hold sway (RHS of a variable,
@@ -2521,6 +2521,7 @@
 
     case '+':
     case '?':
+    case '!':
       if (*p == '=')
         {
           ++p;
@@ -2540,7 +2541,7 @@
 
   /* This is some non-operator word.  A word consists of the longest
      string of characters that doesn't contain whitespace, one of [:=#],
-     or [?+]=, or one of the chars in the DELIM string.  */
+     or [?+!]=, or one of the chars in the DELIM string.  */
 
   /* We start out assuming a static word; if we see a variable we'll
      adjust our assumptions then.  */
--- ./tests/scripts/features/shell_assignment.orig	2010-10-23 23:14:22.797322744 -0400
+++ ./tests/scripts/features/shell_assignment	2010-10-23 23:11:33.714947475 -0400
@@ -0,0 +1,48 @@
+#                                                                    -*-perl-*-
+
+$description = "Test BSD-style shell assignments (VAR != VAL) for variables.";
+
+$details = "";
+
+# TEST 0: Basic shell assignment (!=).
+
+run_make_test('
+.POSIX:
+
+demo1!=printf \'  1   2 3\n4\n\n5 \n \n 6\n\n\n\n\'
+demo2 != printf \'7 8\n \'
+demo3 != printf \'$$(demo2)\'
+all: ; @echo "<$(demo1)> <$(demo2)> <$(demo3)>"
+',
+              '', "<  1   2 3 4  5     6   > <7 8  > <7 8  >\n");
+
+# TEST 1: Handle '#' the same way as BSD make
+
+run_make_test('
+foo1!=echo bar#baz
+hash != printf \'\043\'
+foo2!= echo "bar$(hash)baz"
+
+all: ; @echo "<$(foo1)> <$(hash)> <$(foo2)>"
+',
+              '', "<bar> <#> <bar#baz>\n");
+
+# TEST 2: shell assignment variables (from !=) should be recursive.
+# Note that variables are re-evaluated later, so the shell can output
+# a value like $(XYZZY) as part of !=.  The $(XYZZY) will be EVALUATED
+# when the value containing it is evaluated.  On the negative side, this
+# means if you don't want this, you need to escape dollar signs as $$.
+# On the positive side, it means that shell programs can output macros
+# that are then evaluated as they are traditionally evaluated.. and that
+# you can use traditional macro evaluation semantics to implement !=.
+
+run_make_test('
+XYZZY = fiddle-dee-dee
+dollar = $$
+VAR3 != printf \'%s\' \'$(dollar)(XYZZY)\'
+
+all: ; @echo "<$(VAR3)>"
+',
+              '', "<fiddle-dee-dee>\n");
+
+1;
--- ./variable.c.orig	2010-08-27 11:01:42.000000000 -0400
+++ ./variable.c	2010-10-23 22:45:33.899545348 -0400
@@ -1111,6 +1111,52 @@
   return var;
 }
 
+/* Given a string, shell-execute it and return a malloc'ed string of the
+ * result. If it fails, returns NULL. */
+
+char *
+shell_result (const char *p)
+{
+  size_t length = 0;     /* Length of actual result */
+  size_t alloc_size = 0; /* size of buffer we've allocated */
+  FILE *result_file;
+  char *buffer = NULL;   /* We read our results into this */
+  size_t length_read;
+  unsigned i;
+
+  result_file = popen(p, "r");
+  if (!result_file)
+    return NULL;
+
+  while (!feof(result_file) && !ferror(result_file)) {
+    if (length >= alloc_size) { /* Need to (re)allocate a result buffer */
+      alloc_size += 8192; /* This size amount is arbitrary */
+      buffer = xrealloc(buffer, alloc_size); /* No return on fail */
+    }
+
+    length_read = fread(buffer + length, (size_t) 1, (size_t)
+                     (size_t) (alloc_size - length), result_file);
+    /* Defend against fread implementations that incorrectly return -1: */
+    if (length_read != (size_t) -1)
+      length += length_read;
+  }
+  pclose(result_file);
+
+  /* Per http://austingroupbugs.net/view.php?id=337 the semantics are:
+     result is modified removing a single trailing newline (if there is one),
+     and then replacing all remaining newlines with spaces." */
+  if (length > 0 && buffer[length-1]=='\n') {
+    buffer[length-1] = '\0';
+    length--;
+  }
+  for (i = 0; i < length; i++)
+    if (buffer[i] == '\n')
+      buffer[i] = ' ';
+
+  return buffer;
+}
+
+
 /* Given a variable, a value, and a flavor, define the variable.
    See the try_variable_definition() function for details on the parameters. */
 
@@ -1120,7 +1166,9 @@
                         enum variable_flavor flavor, int target_var)
 {
   const char *p;
+  char *q;
   char *alloc_value = NULL;
+  char *alloc_value2 = NULL;
   struct variable *v;
   int append = 0;
   int conditional = 0;
@@ -1140,6 +1188,11 @@
          target-specific variable.  */
       p = alloc_value = allocated_variable_expand (value);
       break;
+    case f_shell:
+      q = alloc_value = allocated_variable_expand (value);
+      p = alloc_value2 = shell_result (q);
+      flavor = f_recursive;
+      break;
     case f_conditional:
       /* A conditional variable definition "var ?= value".
          The value is set IFF the variable is not defined yet. */
@@ -1357,6 +1410,8 @@
 
   if (alloc_value)
     free (alloc_value);
+  if (alloc_value2)
+    free (alloc_value2);
 
   return v->special ? set_special_var (v) : v;
 }
@@ -1432,7 +1487,7 @@
 	  return (char *)p;
 	}
 
-      /* Match assignment variants (:=, +=, ?=)  */
+      /* Match assignment variants (:=, +=, ?=, !=)  */
       if (*p == '=')
         {
           switch (c)
@@ -1446,6 +1501,9 @@
               case '?':
                 *flavor = f_conditional;
                 break;
+              case '!':
+                *flavor = f_shell;
+                break;
               default:
                 /* If we skipped whitespace, non-assignments means no var.  */
                 if (wspace)
--- ./variable.h.orig	2010-07-12 21:20:43.000000000 -0400
+++ ./variable.h	2010-10-23 11:08:36.036623200 -0400
@@ -38,7 +38,8 @@
     f_simple,           /* Simple definition (:=) */
     f_recursive,        /* Recursive definition (=) */
     f_append,           /* Appending definition (+=) */
-    f_conditional       /* Conditional definition (?=) */
+    f_conditional,      /* Conditional definition (?=) */
+    f_shell             /* Shell definition (!=) */
   };
 
 /* Structure that represents one variable definition.

