Add a new length_boolone() function to fix an assert in randpsl.

* src/ltlvisit/length.hh (length_boolone): New function.
* src/ltlvisit/length.cc (length_boolone): Implement it using...
(length_boolone_visitor): ... this new visitor.
* src/ltltest/randltl.cc: Use length_boolone() to check the result
of the random generator, and ignore any formula larger (in
length()) than opt_f.  This fix a bug where the random formula
generator would sometime produce formula larger than requested,
because of the trivial rewriting of {f}[]->e as e|!f.
* src/ltltest/length.cc: Add option -b to call length_boolone().
* src/ltltest/length.test: Test length_boolone().

src/ltltest/length.cc

@@ -21,6 +21,7 @@
 #include <iostream>
 #include <cassert>
 #include <cstdlib>
+#include <cstring>
 #include "ltlparse/public.hh"
 #include "ltlvisit/length.hh"
 #include "ltlast/allnodes.hh"
@@ -35,16 +36,26 @@ syntax(char *prog)
 int
 main(int argc, char **argv)
 {
-  if (argc != 2)
+  if (argc < 2 || argc > 3)
     syntax(argv[0]);
 
+  bool boolone = false;
+  if (!strcmp(argv[1], "-b"))
+    {
+      boolone = true;
+      ++argv;
+    }
+
   spot::ltl::parse_error_list p1;
   spot::ltl::formula* f1 = spot::ltl::parse(argv[1], p1);
 
   if (spot::ltl::format_parse_errors(std::cerr, argv[1], p1))
     return 2;
 
-  std::cout << spot::ltl::length(f1) << std::endl;
+  if (boolone)
+    std::cout << spot::ltl::length_boolone(f1) << std::endl;
+  else
+    std::cout << spot::ltl::length(f1) << std::endl;
 
   f1->destroy();
   assert(spot::ltl::atomic_prop::instance_count() == 0);

src/ltltest/length.test

@@ -24,6 +24,15 @@
 
 set -e
 
-test `run 0 ../length 'a U Xc'` = 4
-test `run 0 ../length 'a&b&c'` = 5
-test `run 0 ../length 'a|b|c'` = 5
+len()
+{
+  test `run 0 ../length "$1"` = $2
+  test `run 0 ../length -b "$1"` = $3
+}
+
+len 'a U Xc'      4 4
+len 'a&b&c'       5 1
+len 'a|b|c'       5 1
+len '!a|b|!c'     7 1
+len '!(!a|b|!c)'  8 1
+len '!X(!a|b|!c)' 9 3

src/ltltest/randltl.cc

@@ -321,7 +321,16 @@ main(int argc, char** argv)
 		    }
 		  else
 		    {
-		      assert(spot::ltl::length(f) <= opt_f);
+		      assert(spot::ltl::length_boolone(f) <= opt_f);
+
+		      // We might have a formula bigger than opt_f
+		      // because {e}[]->f of length 3 gets trivially reduced
+		      // to f|!e of length 4.
+		      if (spot::ltl::length(f) > opt_f)
+			{
+			  f->destroy();
+			  continue;
+			}
 		    }
 		  break;
 		}