cab3be9795
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.
121 lines
3.1 KiB
C++
121 lines
3.1 KiB
C++
#ifndef SPOT_TGBA_TGBAEXPLICIT_HH
|
|
# define SPOT_TGBA_TGBAEXPLICIT_HH
|
|
|
|
#include <list>
|
|
#include <map>
|
|
#include "tgba.hh"
|
|
#include "ltlast/formula.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:
|
|
tgba_explicit(bdd_dict* dict);
|
|
tgba_explicit(const tgba_explicit& other);
|
|
tgba_explicit& tgba_explicit::operator=(const tgba_explicit& other);
|
|
|
|
struct transition;
|
|
typedef std::list<transition*> state;
|
|
|
|
/// Explicit transitions (used by spot::tgba_explicit).
|
|
struct transition
|
|
{
|
|
bdd condition;
|
|
bdd accepting_conditions;
|
|
state* dest;
|
|
};
|
|
|
|
transition*
|
|
create_transition(const std::string& source, const std::string& dest);
|
|
|
|
void add_condition(transition* t, ltl::formula* f);
|
|
void add_neg_condition(transition* t, ltl::formula* f);
|
|
void declare_accepting_condition(ltl::formula* f);
|
|
bool has_accepting_condition(ltl::formula* f) const;
|
|
void add_accepting_condition(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 bdd_dict* get_dict() const;
|
|
virtual std::string format_state(const spot::state* state) const;
|
|
|
|
virtual bdd all_accepting_conditions() const;
|
|
virtual bdd neg_accepting_conditions() const;
|
|
|
|
protected:
|
|
state* add_state(const std::string& name);
|
|
bdd get_condition(ltl::formula* f);
|
|
bdd get_accepting_condition(ltl::formula* f);
|
|
|
|
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_;
|
|
bdd_dict* dict_;
|
|
tgba_explicit::state* init_;
|
|
mutable bdd all_accepting_conditions_;
|
|
bdd neg_accepting_conditions_;
|
|
mutable bool all_accepting_conditions_computed_;
|
|
};
|
|
|
|
|
|
/// States used by spot::tgba_explicit.
|
|
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* clone() const;
|
|
|
|
virtual ~state_explicit()
|
|
{
|
|
}
|
|
|
|
const tgba_explicit::state* get_state() const;
|
|
private:
|
|
const tgba_explicit::state* state_;
|
|
};
|
|
|
|
|
|
/// Successor iterators used by spot::tgba_explicit.
|
|
class tgba_explicit_succ_iterator: public tgba_succ_iterator
|
|
{
|
|
public:
|
|
tgba_explicit_succ_iterator(const tgba_explicit::state* s, bdd all_acc);
|
|
|
|
virtual
|
|
~tgba_explicit_succ_iterator()
|
|
{
|
|
}
|
|
|
|
virtual void first();
|
|
virtual void next();
|
|
virtual bool done() const;
|
|
|
|
virtual state_explicit* current_state() const;
|
|
virtual bdd current_condition() const;
|
|
virtual bdd current_accepting_conditions() const;
|
|
|
|
private:
|
|
const tgba_explicit::state* s_;
|
|
tgba_explicit::state::const_iterator i_;
|
|
bdd all_accepting_conditions_;
|
|
};
|
|
|
|
}
|
|
|
|
#endif // SPOT_TGBA_TGBAEXPLICIT_HH
|