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/tgba/bdddict.hh

@@ -0,0 +1,122 @@
+#ifndef SPOT_TGBA_BDDDICT_HH
+# define SPOT_TGBA_BDDDICT_HH
+
+#include <map>
+#include <list>
+#include <set>
+#include <iostream>
+#include <bdd.h>
+#include "ltlast/formula.hh"
+#include "misc/bddalloc.hh"
+
+namespace spot
+{
+
+  /// Map BDD variables to formulae.
+  class bdd_dict: public bdd_allocator
+  {
+  public:
+
+    bdd_dict();
+    ~bdd_dict();
+
+    /// Formula-to-BDD-variable maps.
+    typedef std::map<const ltl::formula*, int> fv_map;
+    /// BDD-variable-to-formula maps.
+    typedef std::map<int, const ltl::formula*> vf_map;
+
+    fv_map now_map;		///< Maps formulae to "Now" BDD variables
+    vf_map now_formula_map;	///< Maps "Now" BDD variables to formulae
+    fv_map var_map;		///< Maps atomic propisitions to BDD variables
+    vf_map var_formula_map;     ///< Maps BDD variables to atomic propisitions
+    fv_map acc_map;		///< Maps accepting conditions to BDD variables
+    vf_map acc_formula_map;	///< Maps BDD variables to accepting conditions
+
+    /// \brief Map Next variables to Now variables.
+    ///
+    /// Use with BuDDy's bdd_replace() function.
+    bddPair* next_to_now;
+    /// \brief Map Now variables to Next variables.
+    ///
+    /// Use with BuDDy's bdd_replace() function.
+    bddPair* now_to_next;
+
+    /// \brief Register an atomic proposition.
+    ///
+    /// Return (and maybe allocate) a BDD variable designating formula
+    /// \a f.  The \a for_me argument should point to the object using
+    /// this BDD variable, this is used for reference counting.  It is
+    /// perfectly safe to call this function several time with the same
+    /// arguments.
+    ///
+    /// \return The variable number.  Use bdd_ithvar() or bdd_nithvar()
+    ///   to convert this to a BDD.
+    int register_proposition(const ltl::formula* f, const void* for_me);
+
+    /// \brief Register a couple of Now/Next variables
+    ///
+    /// Return (and maybe allocate) two BDD variables for a state
+    /// associated to formula \a f.  The \a for_me argument should point
+    /// to the object using this BDD variable, this is used for
+    /// reference counting.  It is perfectly safe to call this
+    /// function several time with the same arguments.
+    ///
+    /// \return The first variable number.  Add one to get the second
+    /// variable.  Use bdd_ithvar() or bdd_nithvar() to convert this
+    /// to a BDD.
+    int register_state(const ltl::formula* f, const void* for_me);
+
+    /// \brief Register an atomic proposition.
+    ///
+    /// Return (and maybe allocate) a BDD variable designating an
+    /// accepting set associated to formula \a f.  The \a for_me
+    /// argument should point to the object using this BDD variable,
+    /// this is used for reference counting.  It is perfectly safe to
+    /// call this function several time with the same arguments.
+    ///
+    /// \return The variable number.  Use bdd_ithvar() or bdd_nithvar()
+    ///   to convert this to a BDD.
+    int register_accepting_variable(const ltl::formula* f, const void* for_me);
+
+    /// \brief Duplicate the variable usage of another object.
+    ///
+    /// This tells this dictionary that the \a for_me object
+    /// will be using the same BDD variables as the \a from_other objects.
+    /// This ensure that the variables won't be freed when \a from_other
+    /// is deleted if \a from_other is still alive.
+    void register_all_variables_of(const void* from_other, const void* for_me);
+
+    /// \brief Release the variables used by object.
+    ///
+    /// Usually called in the destructor if \a me.
+    void unregister_all_my_variables(const void* me);
+
+    /// Check whether formula \a f has already been registered by \a by_me.
+    bool is_registered(const ltl::formula* f, const void* by_me);
+
+    /// \brief Dump all variables for debugging.
+    /// \param os The output stream.
+    std::ostream& dump(std::ostream& os) const;
+
+    /// \brief Make sure the dictionary is empty.
+    ///
+    /// This will print diagnostics and abort if the dictionary
+    /// is not empty.  Use for debugging.
+    void assert_emptiness() const;
+
+  protected:
+    /// BDD-variable reference counts.
+    typedef std::set<const void*> ref_set;
+    typedef std::map<int, ref_set> vr_map;
+    vr_map var_refs;
+
+  private:
+    // Disallow copy.
+    bdd_dict(const bdd_dict& other);
+    bdd_dict& operator=(const bdd_dict& other);
+  };
+
+
+}
+
+#endif // SPOT_TGBA_BDDDICT_HH