hash: support both semantics of weak keys + values.

Hash tables with weak keys and values now support a choice of both
possible semantics: under and-semantics, an entry lapses when both the
key and value are unreachable. Under or-semantics, an entry lapses if
either the key or value is unreachable.

The and-semantics is new. Until TXR 266, only or-semantics was
supported. This will be the default: when a hash table is specified
as :weak-keys and :weak-vals, it will have or-semantics.

The keywords :weak-or and :weak-and specify weak keys and values,
with the specific semantics. They are utually exclusive, but tolerate
the presence of :weak-keys and :weak-vals.

The make-hash function is being extended such that if its leftmost
argument, <weak-keys>, is specified as one of the keywords :weak-and
or :weak-or, then the hash table will have weak keys and values with the
specified semantics, and the <weak-vals> argument is ignored
(values are weak even if that argument is false).

* eval.c (eval_init): Initially register the top_vb,
top_mb, top_smb, special and builtin hashes as ordinary hashes: no weak
keys or values. Then use tweak_hash to switch to weak keys+vals
with and-semantics. We do it this way because the keywords are not yet
initialized; we cannot use them.

* hash.h (enum hash_flags, hash_flags_t): Moved to header. Member
hash_weak_both renamed to hash_weak_or. New member hash_weak_and.
(weak_and_k, weak_or_k): New keyword variables.
(hash_print_op): Handle hash_weak_and by printing :weak-and.
(hash_mark): Handle hash_weak_and by marking nothing, like hash_weak_or.
(do_make_hash): Check first argument against the two new keywords and
set flags accordingly. This function is called from eval_init before
the keywords have been initialized, in which case weak_keys ==
weak_and_k is true when both are nil; we watch for that.
(tweak_hash): Now returns void and takes a hash_flags_t argument which
is simply planted.
(do_wak_tables): Implement hash_weak_and case. Remove the compat 266
stuff from hash_weak_or. Compatibility is no longer required since we
are not changing the default semantics of hash tables. Phew; that's a
load of worry off the plate.
(hashv): Parse the two new keywords, validate and provide semantics.
(hash_init): Initialize weak_and_k and weak_or_k kewyords.

* hash.h (enum hash_flags, hash_flags_t): Moved here now.
(weak_and_k, weak_or_k): Declared.

* lib.c (compat_fixup): Remove call to parse_compat_fixup.

* parser.c (parse_init): Create stream_parser_hash with and-semantics.
(parse_compat_fixup): Function removed.

* parser.h (parse_compat_fixup): Declaration removed.

* txr.1: Hash documentation updated.

1 files changed, 66 insertions, 13 deletions

diff --git a/txr.1 b/txr.1
index 71da5676..5d91050b 100644
--- a/txr.1
+++ b/txr.1
@@ -51064,15 +51064,18 @@ entries disappear. This happens even if the values are themselves reachable.
 Vice versa, when an object appearing as a value in one or more weak-value hash
 tables becomes unreachable, those entries disappear, even if the keys are
 reachable. When a hash table has both weak keys and weak values, then an
-entry is removed when neither its key nor its value is reachable.  In other
-words, if either the key or value is reachable, the entry is retained.
-Note: this behavior differed in \*(TX 266 and earlier versions.
+the behavior is one of two possible semantics. Under the
+.codn or -semantics,
+the hash table entry is removed if either the key or the value is unreachable.
+Under the
+.codn and -semantics,
+the entry is removed only if both the key and value are unreachable.
 
 If the keys of a weak-key hash table are reachable from the values, or if the
 values of a weak-key hash table are reachable from the keys, then the weak
 semantics is defeated for the affected entries: the hash table retains those
 entries as if it were an ordinary table.  A hash table with both weak keys and
-values does not have this issue.
+values does not have this issue, regardless of its semantics.
 
 An open traversal of a hash table is performed by the
 .code maphash
@@ -51123,7 +51126,7 @@ becomes unspecified.
 These functions construct a new hash table.
 
 .code make-hash
-takes three mandatory Boolean arguments. The
+takes three mandatory Boolean arguments. The Boolean
 .meta weak-keys
 argument specifies whether the hash table shall have weak keys. The
 .meta weak-vals
@@ -51131,6 +51134,39 @@ argument specifies whether it shall have weak values, and
 .meta equal-based
 specifies whether it is
 .codn equal -based.
+
+If the
+.meta weak-keys
+argument is one of the keywords
+.code :weak-and
+or
+.code :weak-or
+then the hash table shall have both weak keys and weak values, with the
+semantics implied by the keyword:
+.code :weak-and
+specifies
+.codn and -semantics
+and
+.code :weak-or
+specifies
+code or -semantics.
+The
+.meta weak-vals
+argument is then ignored.
+
+If both
+.meta weak-keys
+and
+.meta weak-values
+are true, and
+.meta weak-keys
+is not one of the keywords
+.code :weak-and
+or
+.codn :weak-or ,
+then the hash table has
+.codn or -semantics.
+
 The
 .code hash
 function defaults all three of these properties to false,
@@ -51159,6 +51195,8 @@ function provides an alternative interface. It accepts optional
 keyword arguments. The supported keyword symbols are:
 .codn :weak-keys ,
 .codn :weak-vals ,
+.codn :weak-and ,
+.codn :weak-or ,
 .codn :equal-based ,
 .code :eql-based
 .code :eq-based
@@ -51185,11 +51223,33 @@ function produces an
 hash table by default.
 
 If
-.code :weak-keys
+.codn :weak-keys ,
+.code :weak-and
+or
+.code :weak-or
 is specified, then
 .code :equal-based
 may not be specified.
 
+At most one of
+.code :weak-and
+or
+.code :weak-or
+may be specified. If either of these is specified, then the
+.code :weak-keys
+and
+.code :weak-values
+keywords are redundant and unnecessary.
+
+If
+.code :weak-keys
+and
+.code :weak-values
+are both specified, and
+.code :weak-and
+isn't specified, the situation is equivalent to
+.codn :weak-or .
+
 If
 .code :userdata
 is present, it must be followed by an argument value; that value
@@ -83088,13 +83148,6 @@ of these version values, the described behaviors are provided if
 is given an argument which is equal or lower. For instance
 .code "-C 103"
 selects the behaviors described below for version 105, but not those for 102.
-.IP 266
-Until \*(TX 266, hash tables with both weak values and keys are subject to
-a conjunctive rule for entry retention: entries are retained if both the
-key and value are reachable objects. If either the key or value is unreachable,
-the entry is eligible for removal. The behavior changed in favor of a disjunctive
-rule: the hash entry is retained if either the key or value is reachable.
-A compatibility option value of 266 or lower restores the old behavior.
 .IP 265
 Until \*(TX 265, the
 .code with-resources