Replacing uses of the eq function which are used only as C booleans,

with just using the == operator.

Removing cobj_equal_op since it's indistinguishable from eq.

Streamlining missingp and null_or_missing_p.

* eval.c (transform_op): eq to ==.
(c_var_ops): cobj_equal_op to eq.

* filter.c (trie_compress, trie_lookup_feed_char, filter_string_tree,
html_hex_continue, html_dec_continue): eq to ==.

* hash.c (hash_iter_ops): cobj_equal to eq.

* lib.c (countq, getplist, getplist_f, search_str_tree,
posq): eq to ==.
(cobj_equal_op): Function removed.

* lib.h (cobj_equal_op): Declaration removed.
(missingp): Becomes a simple macro that yields a C boolean instead
of t/nil val, because it's only used that way.
(null_or_missing_p): Becomes inline function returning int.

* match.c (v_output): eq to ==.

* rand.c (random_state_ops): cobj_equal_op to eq.

* regex.c (char_set_obj_ops, regex_obj_ops): cobj_equal_op to eq.
(reg_derivative): Silly if3 expression replaced by null.
(regexp): Redundant if2 expression wrapped around eq removed.

* stream.c (null_ops, stdio_ops, tail_ops, pipe_ops, string_in_ops,
byte_in_ops, string_out_ops, strlist_out_ops, dir_ops,
cat_stream_ops): cobj_equal_op to eq.

* syslog.c (syslog_strm_ops): cobj_equal_op to eq.

1 files changed, 4 insertions, 4 deletions

diff --git a/regex.c b/regex.c
index f0dcb85b..2e24338d 100644
--- a/regex.c
+++ b/regex.c
@@ -761,7 +761,7 @@ static void char_set_cobj_destroy(val chset)
 }
 
 static struct cobj_ops char_set_obj_ops = {
-  cobj_equal_op,
+  eq,
   cobj_print_op,
   char_set_cobj_destroy,
   cobj_mark_op,
@@ -1264,7 +1264,7 @@ static void regex_destroy(val regex)
 }
 
 static struct cobj_ops regex_obj_ops = {
-  cobj_equal_op,
+  eq,
   cobj_print_op,
   regex_destroy,
   cobj_mark_op,
@@ -1501,7 +1501,7 @@ static val reg_derivative(val exp, val ch)
   if (exp == nil || exp == t) {
     return t;
   } else if (chrp(exp)) {
-    return if3(eq(exp, ch), nil, t);
+    return null(eq(exp, ch));
   } else if (typeof(exp) == chset_s) {
     char_set_t *set = (char_set_t *) exp->co.handle;
     return if3(char_set_contains(set, c_chr(ch)), nil, t);
@@ -1635,7 +1635,7 @@ val regex_compile(val regex_sexp, val error_stream)
 val regexp(val obj)
 {
   if (consp(obj))
-    return if2(eq(car(obj), compiled_regex_s), t);
+    return eq(car(obj), compiled_regex_s);
 
   return typeof(obj) == regex_s ? t : nil;
 }