Bi-directional string tree match for non-vars.

There is an inconsistency in @(bind) in that
given @(bind x y) where x is a variable, both
directions are tried for a string tree match.
x could be tree of strings and y a string atom,
or vice versa. But if x is just an atom, or
a Lisp evaluation, then only one direction is
tried. @(bind @(list "a" "b") "a") succeeds,
but @(bind "a" @(list "a" "b")) fails.

* match.c (dest_bind): Test both directions
in the scalar and Lisp evaluated cases of the
left hand side. Subject to compatibility,
just in case.

* txr.1: Compat note added.

1 files changed, 12 insertions, 2 deletions

diff --git a/match.c b/match.c
index c77a4e7d..6f151c7b 100644
--- a/match.c
+++ b/match.c
@@ -366,8 +366,14 @@ static val dest_bind(val spec, val bindings, val pattern,
       lisp_evaled = t;
     }
 
-    if (lisp_evaled)
-      return if3(tree_find(value, ret, swap_12_21(testfun)), bindings, t);
+    if (lisp_evaled) {
+      if (!opt_compat || opt_compat >= 184)
+        if (tree_find(ret, value, testfun))
+          return bindings;
+      if (tree_find(value, ret, swap_12_21(testfun)))
+        return bindings;
+      return t;
+    }
 
     while (consp(piter) && consp(viter))
     {
@@ -386,6 +392,10 @@ static val dest_bind(val spec, val bindings, val pattern,
       return funcall2(testfun, piter, viter) ? bindings : t;
     }
     return bindings;
+  } else if ((!opt_compat || opt_compat >= 184) &&
+             tree_find(pattern, value, testfun))
+  {
+    return bindings;
   } else if (tree_find(value, pattern, swap_12_21(testfun))) {
     return bindings;
   }