Before this change, all automata would construct their own

dictionaries (map of BDD variables to LTL formulae).  This was
cumbersome, because to multiply two automata we had to build a
common dictionary (the union of the two LTL formula spaces), and
install wrappers to translate each automaton's BDD answers into
the common dictionary.  This translation, that had to be repeated
when several products were nested, was time consuming and was a
hindrance for some optimizations.
In the new scheme, all automata involved in a product must
share the same dictionary.  An empty dictionary should be
constructed by the user and passed to the automaton' constructors
as necessary.
This huge change removes most code than it adds.

* src/Makefile.am (libspot_la_LIBADD): Add misc/libmisc.la.
* src/misc/bddalloc.hh, src/misc/bddalloc.cc: New files.  These
partly replace src/tgba/bddfactory.hh and src/tgba/bddfactory.cc.
* src/misc/Makefile.am: Adjust to build bddalloc.hh and bddalloc.cc.
* src/tgba/bddfactory.hh, src/tgba/bddfactory.cc,
src/tgba/dictunion.hh, src/tgba/dictunion.cc,
src/tgba/tgbabdddict.hh, src/tgba/tgbabdddict.cc,
src/tgba/tgbabddtranslatefactory.hh,
src/tgba/tgbabddtranslatefactory.cc,
src/tgba/tgbatranslateproxy.hh, src/tgba/tgbatranslateproxy.cc:
Delete.
* src/tgba/bdddict.hh, src/tgba/bdddict.cc: New files.  These
replaces tgbabdddict.hh and tgbabdddict.cc, and also part of
bddfactory.hh and bddfactory.cc.
* src/tgba/bddprint.cc, src/tgba/bddprint.hh: Adjust to
use bdd_dict* instead of tgba_bdd_dict&.
* src/tgba/succiterconcrete.cc (succ_iter_concrete::next()):
Get next_to_now from the dictionary.
* src/tgba/tgba.hh (tgba::get_dict): Return a bdd_dict*,
not a const tgba_bdd_dict*.
* src/tgba/tgbabddconcrete.cc, src/tgba/tgbabddconcrete.hh:
Adjust to use the new dictionary, stored in data_.
* src/tgba/tgbabddconcretefactory.cc,
src/tgba/tgbabddconcretefactory.hh: Likewise.  Plus
now_to_next_ is now also stored in the dictionary.
* src/tgba/tgbabddconcreteproduct.cc: Likewise.  Now
that both operand share the same product, there is not
point in using tgba_bdd_translate_factory.
* src/tgba/tgbabddcoredata.cc, src/tgba/tgbabddcoredata.hh:
Store a bdd_dict (taken as constructor argument).
(tgba_bdd_core_data::~tgba_bdd_core_data): Remove.
(tgba_bdd_core_data::translate): Remove.
(tgba_bdd_core_data::next_to_now): Remove (now in dict).
(tgba_bdd_core_data::dict): New pointer.
* src/tgba/tgbabddfactory.hh: (tgba_bdd_factory::get_dict): Remove.
* src/tgba/tgbaexplicit.cc, src/tgba/tgbaexplicit.hh:
Adjust to use the new dictionary.
* src/tgba/tgbaproduct.cc, src/tgba/tgbaproduct.hh: Likewise.  Do
not use tgba_bdd_dict_union and tgba_bdd_translate_proxy anymore.
* src/tgbaalgos/lbtt.cc, src/tgbaalgos/save.cc: Adjust to
use bdd_dict* instead of tgba_bdd_dict&.
* src/tgbaalgos/ltl2tgba.cc, src/tgbaalgos/ltl2tgba.cc: Likewise.
(ltl_to_tgba): Take a dict argument.
* src/tgbaparse/public.hh (tgba_parse): Take a dict argument.
* src/tgbaparse/tgbaparse.yy (tgba_parse): Take a dict argument.
* src/tgbatest/explicit.cc, src/tgbatest/explprod.cc,
src/tgbatest/ltlprod.cc, src/tgbatest/mixprod.cc,
src/tgbatest/readsave.cc, src/tgbatest/spotlbtt.cc,
src/tgbatest/tgbaread.cc, src/tgbatest/tripprod.cc: Instantiate
a dictionary, and pass it to the automata' constructors.
* src/tgbatest/ltl2tgba.cc: Likewise, and remove the -o (defrag)
option.
* iface/gspn/gspn.hh (tgba_gspn::tgba_gspn): Take a bdd_dict argument.
(tgba_gspn::get_dict): Adjust return type.
* iface/gspn/gspn.cc: Do not use bdd_factory, adjust to
use the new dictionary instead.

src/tgbaalgos/lbtt.cc

@@ -64,7 +64,7 @@ namespace spot
   // Conjunctions are printed by bdd_format_sat, so we just have
   // to handle the other cases.
   static std::string
-  bdd_to_lbtt(bdd b, const tgba_bdd_dict& d)
+  bdd_to_lbtt(bdd b, const bdd_dict* d)
   {
     if (b == bddfalse)
       return "f";
@@ -178,7 +178,7 @@ namespace spot
   std::ostream&
   lbtt_reachable(std::ostream& os, const tgba& g)
   {
-    const tgba_bdd_dict& d = g.get_dict();
+    const bdd_dict* d = g.get_dict();
     std::ostringstream body;
 
     seen_map seen;

src/tgbaalgos/ltl2tgba.cc

@@ -38,7 +38,7 @@ namespace spot
     void
     visit(const atomic_prop* node)
     {
-      res_ = fact_.ithvar(fact_.create_atomic_prop(node));
+      res_ = bdd_ithvar(fact_.create_atomic_prop(node));
     }
 
     void
@@ -70,8 +70,8 @@ namespace spot
 		   now <=> x | next
 	    */
 	    int v = fact_.create_state(node);
-	    bdd now = fact_.ithvar(v);
-	    bdd next = fact_.ithvar(v + 1);
+	    bdd now = bdd_ithvar(v);
+	    bdd next = bdd_ithvar(v + 1);
 	    bdd x = recurse(node->child());
 	    fact_.constrain_relation(bdd_apply(now, x | next, bddop_biimp));
 	    /*
@@ -101,8 +101,8 @@ namespace spot
 	      }
 	    // Gx  <=>  x && XGx
 	    int v = fact_.create_state(node);
-	    bdd now = fact_.ithvar(v);
-	    bdd next = fact_.ithvar(v + 1);
+	    bdd now = bdd_ithvar(v);
+	    bdd next = bdd_ithvar(v + 1);
 	    fact_.constrain_relation(bdd_apply(now, child & next,
 					       bddop_biimp));
 	    res_ = now;
@@ -116,8 +116,8 @@ namespace spot
 	case unop::X:
 	  {
 	    int v = fact_.create_state(node->child());
-	    bdd now = fact_.ithvar(v);
-	    bdd next = fact_.ithvar(v + 1);
+	    bdd now = bdd_ithvar(v);
+	    bdd next = bdd_ithvar(v + 1);
 	    fact_.constrain_relation(bdd_apply(now, recurse(node->child()),
 					       bddop_biimp));
 	    res_ = next;
@@ -153,8 +153,8 @@ namespace spot
 		   now <=> f2 | (f1 & next)
 	    */
 	    int v = fact_.create_state(node);
-	    bdd now = fact_.ithvar(v);
-	    bdd next = fact_.ithvar(v + 1);
+	    bdd now = bdd_ithvar(v);
+	    bdd next = bdd_ithvar(v + 1);
 	    fact_.constrain_relation(bdd_apply(now, f2 | (f1 & next),
 					       bddop_biimp));
 	    /*
@@ -175,8 +175,8 @@ namespace spot
 		   now <=> f2 & (f1 | next)
 	    */
 	    int v = fact_.create_state(node);
-	    bdd now = fact_.ithvar(v);
-	    bdd next = fact_.ithvar(v + 1);
+	    bdd now = bdd_ithvar(v);
+	    bdd next = bdd_ithvar(v + 1);
 	    fact_.constrain_relation(bdd_apply(now, f2 & (f1 | next),
 					       bddop_biimp));
 	    res_ = now;
@@ -231,18 +231,18 @@ namespace spot
   };
 
   tgba_bdd_concrete
-  ltl_to_tgba(const ltl::formula* f)
+  ltl_to_tgba(const ltl::formula* f, bdd_dict* dict)
   {
-    // Normalize the formula.  We want all the negation on
-    // the atomic proposition.  We also suppress logic
-    // abbreviation such as <=>, =>, or XOR, since they
+    // Normalize the formula.  We want all the negations on
+    // the atomic propositions.  We also suppress logic
+    // abbreviations such as <=>, =>, or XOR, since they
     // would involve negations at the BDD level.
     const ltl::formula* f1 = ltl::unabbreviate_logic(f);
     const ltl::formula* f2 = ltl::negative_normal_form(f1);
     ltl::destroy(f1);
 
     // Traverse the formula and draft the automaton in a factory.
-    tgba_bdd_concrete_factory fact;
+    tgba_bdd_concrete_factory fact(dict);
     ltl_trad_visitor v(fact, true);
     f2->accept(v);
     ltl::destroy(f2);

src/tgbaalgos/ltl2tgba.hh

@@ -7,7 +7,7 @@
 namespace spot
 {
   /// Build a spot::tgba_bdd_concrete from an LTL formula.
-  tgba_bdd_concrete ltl_to_tgba(const ltl::formula* f);
+  tgba_bdd_concrete ltl_to_tgba(const ltl::formula* f, bdd_dict* dict);
 }
 
 #endif // SPOT_TGBA_LTL2TGBA_HH

src/tgbaalgos/save.cc

@@ -42,10 +42,10 @@ namespace spot
   std::ostream&
   tgba_save_reachable(std::ostream& os, const tgba& g)
   {
-    const tgba_bdd_dict& d = g.get_dict();
+    const bdd_dict* d = g.get_dict();
     os << "acc =";
-    for (tgba_bdd_dict::fv_map::const_iterator ai = d.acc_map.begin();
-	 ai != d.acc_map.end(); ++ai)
+    for (bdd_dict::fv_map::const_iterator ai = d->acc_map.begin();
+	 ai != d->acc_map.end(); ++ai)
       {
 	os << " \"";
 	ltl::to_string(ai->first, os) << "\"";