* configure.ac: Output src/tgbatest/Makefile and src/tgbatest/defs.

* src/Makefile.am (SUBDIRS): Add tgbatest.
* src/tgba/tgbaexplicit.hh, src/tgba/tgbaexplicit.cc: New file.
* src/tgba/Makefile.am (libtgba_la_SOURCES): Add tgbaexplicit.cc
and tgbaexplicit.hh.
* src/tgbatest/Makefile.am, src/tgbatest/defs.in,
src/tgbatest/explicit.cc, src/tgbatest/explicit.test: New files.

src/tgba/Makefile.am

@@ -35,4 +35,6 @@ libtgba_la_SOURCES = \
   tgbabddtranslatefactory.cc \
   tgbabddtranslatefactory.hh \
   tgbabddtranslateproxy.cc \
-  tgbabddtranslateproxy.hh
+  tgbabddtranslateproxy.hh \
+  tgbaexplicit.cc \
+  tgbaexplicit.hh

src/tgba/succiter.hh

@@ -27,7 +27,7 @@ namespace spot
     /// \brief Position the iterator on the first successor (if any).
     ///
     /// This method can be called several times to make multiple
-    /// passes over successors.  
+    /// passes over successors.
     ///
     /// \warning One should always call \c done() to
     /// ensure there is a successor, even after \c first().  A

src/tgba/tgbaexplicit.cc

@@ -0,0 +1,190 @@
+#include "ltlast/atomic_prop.hh"
+#include "tgbaexplicit.hh"
+#include <cassert>
+
+namespace spot
+{
+
+  ////////////////////////////////////////
+  // tgba_explicit_succ_iterator
+
+  tgba_explicit_succ_iterator::tgba_explicit_succ_iterator
+  (const tgba_explicit::state* s)
+    : s_(s)
+  {
+  }
+
+  void 
+  tgba_explicit_succ_iterator::first()
+  {
+    i_ = s_->begin();
+  }
+
+  void 
+  tgba_explicit_succ_iterator::next()
+  {
+    ++i_;
+  }
+
+  bool 
+  tgba_explicit_succ_iterator::done()
+  {
+    return i_ == s_->end();
+  }
+
+  state_explicit* 
+  tgba_explicit_succ_iterator::current_state()
+  {
+    return new state_explicit((*i_)->dest);
+  }
+
+  bdd 
+  tgba_explicit_succ_iterator::current_condition()
+  {
+    return (*i_)->condition;
+  }
+
+  bdd 
+  tgba_explicit_succ_iterator::current_promise()
+  {
+    return (*i_)->promise;
+  }
+
+
+  ////////////////////////////////////////
+  // state_explicit
+
+  const tgba_explicit::state* 
+  state_explicit::get_state() const
+  {
+    return state_;
+  }
+
+  int
+  state_explicit::compare(const spot::state* other) const
+  {
+    const state_explicit* o = dynamic_cast<const state_explicit*>(other);
+    assert(o);
+    return o->get_state() - get_state();
+  }
+
+  ////////////////////////////////////////
+  // tgba_explicit
+
+
+  tgba_explicit::tgba_explicit()
+    : init_(0)
+  {
+  }
+
+  tgba_explicit::~tgba_explicit()
+  {
+    ns_map::iterator i;
+    for (i = name_state_map_.begin(); i != name_state_map_.end(); ++i)
+      {
+	tgba_explicit::state::iterator i2;
+	for (i2 = i->second->begin(); i2 != i->second->end(); ++i2)
+	  delete *i2;
+	delete i->second;
+      }
+  }
+  
+  tgba_explicit::state*
+  tgba_explicit::add_state(const std::string& name)
+  {
+    ns_map::iterator i = name_state_map_.find(name);
+    if (i == name_state_map_.end())
+      {
+	tgba_explicit::state* s = new tgba_explicit::state;
+	name_state_map_[name] = s;
+	state_name_map_[s] = name;
+
+	// The first state we add is the inititial state.
+	if (! init_)
+	  init_ = s;
+
+	return s;
+      }
+    return i->second;
+  }
+
+  tgba_explicit::transition*
+  tgba_explicit::create_transition(const std::string& source, 
+				   const std::string& dest)
+  {
+    tgba_explicit::state* s = add_state(source);
+    tgba_explicit::state* d = add_state(dest);
+    transition* t = new transition;
+    t->dest = d;
+    t->condition = bddtrue;
+    t->promise = bddtrue;
+    s->push_back(t);
+    return t;
+  }
+
+  void tgba_explicit::add_condition(transition* t, ltl::formula* f)
+  {
+    assert(dynamic_cast<ltl::atomic_prop*>(f));
+    tgba_bdd_dict::fv_map::iterator i = dict_.var_map.find(f);
+    int v;
+    if (i == dict_.var_map.end())
+      {
+	v = create_node();
+	dict_.var_map[f] = v;
+	dict_.var_formula_map[v] = f;
+      }
+    else
+      {
+	v = i->second;
+      }
+    t->condition &= ithvar(v);
+  }
+
+  void tgba_explicit::add_promise(transition* t, ltl::formula* f)
+  {
+    tgba_bdd_dict::fv_map::iterator i = dict_.prom_map.find(f);
+    int v;
+    if (i == dict_.prom_map.end())
+      {
+	v = create_node();
+	dict_.prom_map[f] = v;
+	dict_.prom_formula_map[v] = f;
+      }
+    else
+      {
+	v = i->second;
+      }
+    t->promise &= ithvar(v);
+  }
+
+  state* 
+  tgba_explicit::get_init_state() const
+  {
+    return new state_explicit(init_);
+  }
+
+  tgba_succ_iterator* 
+  tgba_explicit::succ_iter(const spot::state* state) const
+  {
+    const state_explicit* s = dynamic_cast<const state_explicit*>(state);
+    assert(s);
+    return new tgba_explicit_succ_iterator(s->get_state());
+  }
+    
+  const tgba_bdd_dict& 
+  tgba_explicit::get_dict() const
+  {
+    return dict_;
+  }
+
+  std::string 
+  tgba_explicit::format_state(const spot::state* s) const
+  {
+    const state_explicit* se = dynamic_cast<const state_explicit*>(s);
+    assert(se);
+    sn_map::const_iterator i = state_name_map_.find(se->get_state());
+    assert(i != state_name_map_.end());
+    return i->second;
+  }
+
+}

src/tgba/tgbaexplicit.hh

@@ -0,0 +1,101 @@
+#ifndef SPOT_TGBA_TGBAEXPLICIT_HH
+# define SPOT_TGBA_TGBAEXPLICIT_HH
+
+#include <list>
+#include <map>
+#include "tgba.hh"
+#include "ltlast/formula.hh"
+#include "bddfactory.hh"
+
+namespace spot
+{
+  // Forward declarations.  See below.
+  class state_explicit;
+  class tgba_explicit_succ_iterator;
+
+  /// Explicit representation of a spot::tgba.
+  class tgba_explicit : public tgba, public bdd_factory
+  {
+  public:
+    tgba_explicit();
+
+    struct transition;
+    typedef std::list<transition*> state;
+    struct transition
+    {
+      bdd condition;
+      bdd promise;
+      state* dest;
+    };
+
+    transition*
+    create_transition(const std::string& source, const std::string& dest);
+
+    void add_condition(transition* t, ltl::formula* f);
+    void add_promise(transition* t, ltl::formula* f);
+
+    // tgba interface
+    virtual ~tgba_explicit();
+    virtual spot::state* get_init_state() const;
+    virtual tgba_succ_iterator*
+    succ_iter(const spot::state* state) const;
+    virtual const tgba_bdd_dict& get_dict() const;
+    virtual std::string format_state(const spot::state* state) const;
+
+  protected:
+    state* add_state(const std::string& name);
+    typedef std::map<const std::string, tgba_explicit::state*> ns_map;
+    typedef std::map<const tgba_explicit::state*, std::string> sn_map;
+    ns_map name_state_map_;
+    sn_map state_name_map_;
+    tgba_bdd_dict dict_;
+    tgba_explicit::state* init_;
+  };
+
+
+  class state_explicit : public spot::state
+  {
+  public:
+    state_explicit(const tgba_explicit::state* s)
+      : state_(s)
+    {
+    }
+
+    virtual int compare(const spot::state* other) const;
+
+    virtual ~state_explicit()
+    {
+    }
+
+    const tgba_explicit::state* get_state() const;
+  private:
+    const tgba_explicit::state* state_;
+  };
+
+
+  class tgba_explicit_succ_iterator : public tgba_succ_iterator
+  {
+  public:
+    tgba_explicit_succ_iterator(const tgba_explicit::state* s);
+
+    virtual
+    ~tgba_explicit_succ_iterator()
+    {
+    }
+
+    virtual void first();
+    virtual void next();
+    virtual bool done();
+
+    virtual state_explicit* current_state();
+    virtual bdd current_condition();
+    virtual bdd current_promise();
+
+  private:
+    const tgba_explicit::state* s_;
+    tgba_explicit::state::const_iterator i_;
+  };
+
+}
+
+#endif // SPOT_TGBA_TGBAEXPLICIT_HH