alarsyo/spot
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

rename tgba_ptr into twa_ptr

Browse source 
Automatic mass renaming.

* iface/ltsmin/modelcheck.cc, src/dstarparse/dra2ba.cc,
src/dstarparse/nra2nba.cc, src/ltlvisit/apcollect.cc,
src/ltlvisit/apcollect.hh, src/ta/taexplicit.cc, src/ta/taexplicit.hh,
src/ta/tgtaexplicit.cc, src/ta/tgtaexplicit.hh, src/ta/tgtaproduct.hh,
src/taalgos/tgba2ta.cc, src/taalgos/tgba2ta.hh, src/tgba/fwd.hh,
src/tgba/tgba.cc, src/tgba/tgba.hh, src/tgba/tgbagraph.hh,
src/tgba/tgbamask.cc, src/tgba/tgbamask.hh, src/tgba/tgbaproduct.cc,
src/tgba/tgbaproduct.hh, src/tgba/tgbaproxy.cc, src/tgba/tgbaproxy.hh,
src/tgbaalgos/bfssteps.cc, src/tgbaalgos/bfssteps.hh,
src/tgbaalgos/complete.cc, src/tgbaalgos/complete.hh,
src/tgbaalgos/compsusp.cc, src/tgbaalgos/dotty.cc,
src/tgbaalgos/dotty.hh, src/tgbaalgos/dtgbasat.cc,
src/tgbaalgos/dupexp.cc, src/tgbaalgos/dupexp.hh,
src/tgbaalgos/emptiness.cc, src/tgbaalgos/emptiness.hh,
src/tgbaalgos/gtec/gtec.cc, src/tgbaalgos/gtec/gtec.hh,
src/tgbaalgos/gtec/status.cc, src/tgbaalgos/gtec/status.hh,
src/tgbaalgos/gv04.cc, src/tgbaalgos/gv04.hh, src/tgbaalgos/hoa.cc,
src/tgbaalgos/hoa.hh, src/tgbaalgos/lbtt.cc, src/tgbaalgos/lbtt.hh,
src/tgbaalgos/magic.cc, src/tgbaalgos/magic.hh,
src/tgbaalgos/minimize.cc, src/tgbaalgos/ndfs_result.hxx,
src/tgbaalgos/neverclaim.cc, src/tgbaalgos/neverclaim.hh,
src/tgbaalgos/projrun.cc, src/tgbaalgos/projrun.hh,
src/tgbaalgos/reachiter.cc, src/tgbaalgos/reachiter.hh,
src/tgbaalgos/reducerun.cc, src/tgbaalgos/reducerun.hh,
src/tgbaalgos/replayrun.cc, src/tgbaalgos/replayrun.hh,
src/tgbaalgos/scc.cc, src/tgbaalgos/scc.hh, src/tgbaalgos/se05.cc,
src/tgbaalgos/se05.hh, src/tgbaalgos/stats.cc, src/tgbaalgos/stats.hh,
src/tgbaalgos/stutter.cc, src/tgbaalgos/tau03.cc,
src/tgbaalgos/tau03.hh, src/tgbaalgos/tau03opt.cc,
src/tgbaalgos/tau03opt.hh, src/tgbatest/checkta.cc,
src/tgbatest/complementation.cc, src/tgbatest/emptchk.cc,
src/tgbatest/ltl2tgba.cc, wrap/python/spot_impl.i: Rename tgba_ptr as
twa_ptr.
This commit is contained in:
Alexandre Duret-Lutz 2015-04-21 19:38:09 +02:00
parent 5d9778474f
commit 8520c4c330
74 changed files with 189 additions and 189 deletions
Download patch file Download diff file Expand all files Collapse all files

4
iface/ltsmin/modelcheck.cc
View file

@ -158,8 +158,8 @@ checked_main(int argc, char **argv)
spot::ltl::atomic_prop_set ap; spot::ltl::atomic_prop_set ap;
auto dict = spot::make_bdd_dict(); auto dict = spot::make_bdd_dict();
spot::const_kripke_ptr model = nullptr; spot::const_kripke_ptr model = nullptr;
spot::const_tgba_ptr prop = nullptr; spot::const_twa_ptr prop = nullptr;
spot::const_tgba_ptr product = nullptr; spot::const_twa_ptr product = nullptr;
spot::emptiness_check_instantiator_ptr echeck_inst = nullptr; spot::emptiness_check_instantiator_ptr echeck_inst = nullptr;
int exit_code = 0; int exit_code = 0;
spot::postprocessor post; spot::postprocessor post;

8
src/dstarparse/dra2ba.cc
View file

@ -50,7 +50,7 @@ namespace spot
// This function is defined in nra2nba.cc, and used only here. // This function is defined in nra2nba.cc, and used only here.
SPOT_LOCAL SPOT_LOCAL
twa_graph_ptr nra_to_nba(const const_dstar_aut_ptr& nra, twa_graph_ptr nra_to_nba(const const_dstar_aut_ptr& nra,
const const_tgba_ptr& aut); const const_twa_ptr& aut);
namespace namespace
{ {
@ -65,14 +65,14 @@ namespace spot
// retrive acceptances. // retrive acceptances.
static bool static bool
filter_states(const const_tgba_ptr& aut, filter_states(const const_twa_ptr& aut,
const const_dstar_aut_ptr& dra, const const_dstar_aut_ptr& dra,
const state_list& sl, const state_list& sl,
state_list& final, state_list& final,
state_list& nonfinal); state_list& nonfinal);
static bool static bool
filter_scc(const const_tgba_ptr& aut, filter_scc(const const_twa_ptr& aut,
const const_dstar_aut_ptr& dra, const const_dstar_aut_ptr& dra,
state_list& final, state_list& final,
state_list& nonfinal) state_list& nonfinal)
@ -99,7 +99,7 @@ namespace spot
} }
static bool static bool
filter_states(const const_tgba_ptr& aut, filter_states(const const_twa_ptr& aut,
const const_dstar_aut_ptr& dra, const const_dstar_aut_ptr& dra,
const state_list& sl, const state_list& sl,
state_list& final, state_list& final,

4
src/dstarparse/nra2nba.cc
View file

@ -38,7 +38,7 @@ namespace spot
// AUT is the automaton we iterate on, while A is the automaton // AUT is the automaton we iterate on, while A is the automaton
// we read the acceptance conditions from. Separating the two // we read the acceptance conditions from. Separating the two
// makes its possible to mask AUT, as needed in dra_to_ba(). // makes its possible to mask AUT, as needed in dra_to_ba().
nra_to_nba_worker(const const_dstar_aut_ptr& a, const_tgba_ptr aut): nra_to_nba_worker(const const_dstar_aut_ptr& a, const_twa_ptr aut):
tgba_reachable_iterator_depth_first(aut), tgba_reachable_iterator_depth_first(aut),
out_(make_twa_graph(aut->get_dict())), out_(make_twa_graph(aut->get_dict())),
d_(a), d_(a),
@ -116,7 +116,7 @@ namespace spot
// that is a masked version of nra->aut. // that is a masked version of nra->aut.
SPOT_LOCAL SPOT_LOCAL
twa_graph_ptr nra_to_nba(const const_dstar_aut_ptr& nra, twa_graph_ptr nra_to_nba(const const_dstar_aut_ptr& nra,
const const_tgba_ptr& aut) const const_twa_ptr& aut)
{ {
assert(nra->type == Rabin); assert(nra->type == Rabin);
nra_to_nba_worker w(nra, aut); nra_to_nba_worker w(nra, aut);

2
src/ltlvisit/apcollect.cc
View file

@ -85,7 +85,7 @@ namespace spot
} }
bdd bdd
atomic_prop_collect_as_bdd(const formula* f, const const_tgba_ptr& a) atomic_prop_collect_as_bdd(const formula* f, const const_twa_ptr& a)
{ {
spot::ltl::atomic_prop_set aps; spot::ltl::atomic_prop_set aps;
atomic_prop_collect(f, &aps); atomic_prop_collect(f, &aps);

2
src/ltlvisit/apcollect.hh
View file

@ -68,7 +68,7 @@ namespace spot
/// \return A conjunction the atomic propositions. /// \return A conjunction the atomic propositions.
SPOT_API bdd SPOT_API bdd
atomic_prop_collect_as_bdd(const formula* f, atomic_prop_collect_as_bdd(const formula* f,
const const_tgba_ptr& a); const const_twa_ptr& a);
/// @} /// @}
} }

4
src/ta/taexplicit.cc
View file

@ -350,7 +350,7 @@ namespace spot
// ta_explicit // ta_explicit
ta_explicit::ta_explicit(const const_tgba_ptr& tgba, ta_explicit::ta_explicit(const const_twa_ptr& tgba,
unsigned n_acc, unsigned n_acc,
state_ta_explicit* artificial_initial_state): state_ta_explicit* artificial_initial_state):
ta(tgba->get_dict()), ta(tgba->get_dict()),
@ -495,7 +495,7 @@ namespace spot
return tgba_->get_dict(); return tgba_->get_dict();
} }
const_tgba_ptr const_twa_ptr
ta_explicit::get_tgba() const ta_explicit::get_tgba() const
{ {
return tgba_; return tgba_;

8
src/ta/taexplicit.hh
View file

@ -40,11 +40,11 @@ namespace spot
class SPOT_API ta_explicit : public ta class SPOT_API ta_explicit : public ta
{ {
public: public:
ta_explicit(const const_tgba_ptr& tgba, ta_explicit(const const_twa_ptr& tgba,
unsigned n_acc, unsigned n_acc,
state_ta_explicit* artificial_initial_state = 0); state_ta_explicit* artificial_initial_state = 0);
const_tgba_ptr const_twa_ptr
get_tgba() const; get_tgba() const;
state_ta_explicit* state_ta_explicit*
@ -121,7 +121,7 @@ namespace spot
ta_explicit(const ta_explicit& other) SPOT_DELETED; ta_explicit(const ta_explicit& other) SPOT_DELETED;
ta_explicit& operator=(const ta_explicit& other) SPOT_DELETED; ta_explicit& operator=(const ta_explicit& other) SPOT_DELETED;
const_tgba_ptr tgba_; const_twa_ptr tgba_;
state_ta_explicit* artificial_initial_state_; state_ta_explicit* artificial_initial_state_;
ta::states_set_t states_set_; ta::states_set_t states_set_;
ta::states_set_t initial_states_set_; ta::states_set_t initial_states_set_;
@ -252,7 +252,7 @@ namespace spot
typedef std::shared_ptr<ta_explicit> ta_explicit_ptr; typedef std::shared_ptr<ta_explicit> ta_explicit_ptr;
typedef std::shared_ptr<const ta_explicit> const_ta_explicit_ptr; typedef std::shared_ptr<const ta_explicit> const_ta_explicit_ptr;
inline ta_explicit_ptr make_ta_explicit(const const_tgba_ptr& tgba, inline ta_explicit_ptr make_ta_explicit(const const_twa_ptr& tgba,
unsigned n_acc, unsigned n_acc,
state_ta_explicit* state_ta_explicit*
artificial_initial_state = 0) artificial_initial_state = 0)

2
src/ta/tgtaexplicit.cc
View file

@ -28,7 +28,7 @@
namespace spot namespace spot
{ {
tgta_explicit::tgta_explicit(const const_tgba_ptr& tgba, tgta_explicit::tgta_explicit(const const_twa_ptr& tgba,
unsigned n_acc, unsigned n_acc,
state_ta_explicit* artificial_initial_state) : state_ta_explicit* artificial_initial_state) :
tgta(tgba->get_dict()), tgta(tgba->get_dict()),

4
src/ta/tgtaexplicit.hh
View file

@ -37,7 +37,7 @@ namespace spot
class SPOT_API tgta_explicit : public tgta class SPOT_API tgta_explicit : public tgta
{ {
public: public:
tgta_explicit(const const_tgba_ptr& tgba, tgta_explicit(const const_twa_ptr& tgba,
unsigned n_acc, unsigned n_acc,
state_ta_explicit* artificial_initial_state); state_ta_explicit* artificial_initial_state);
@ -66,7 +66,7 @@ namespace spot
typedef std::shared_ptr<tgta_explicit> tgta_explicit_ptr; typedef std::shared_ptr<tgta_explicit> tgta_explicit_ptr;
typedef std::shared_ptr<const tgta_explicit> const_tgta_explicit_ptr; typedef std::shared_ptr<const tgta_explicit> const_tgta_explicit_ptr;
inline tgta_explicit_ptr make_tgta_explicit(const const_tgba_ptr& tgba, inline tgta_explicit_ptr make_tgta_explicit(const const_twa_ptr& tgba,
unsigned n_acc, unsigned n_acc,
state_ta_explicit* state_ta_explicit*
artificial_initial_state = 0) artificial_initial_state = 0)

2
src/ta/tgtaproduct.hh
View file

@ -42,7 +42,7 @@ namespace spot
succ_iter(const state* local_state) const; succ_iter(const state* local_state) const;
}; };
inline tgba_ptr product(const const_kripke_ptr& left, inline twa_ptr product(const const_kripke_ptr& left,
const const_tgta_ptr& right) const const_tgta_ptr& right)
{ {
return std::make_shared<tgta_product>(left, right); return std::make_shared<tgta_product>(left, right);

6
src/taalgos/tgba2ta.cc
View file

@ -415,7 +415,7 @@ namespace spot
{ {
std::stack<state_ta_explicit*> todo; std::stack<state_ta_explicit*> todo;
const_tgba_ptr tgba_ = ta->get_tgba(); const_twa_ptr tgba_ = ta->get_tgba();
// build Initial states set: // build Initial states set:
state* tgba_init_state = tgba_->get_init_state(); state* tgba_init_state = tgba_->get_init_state();
@ -544,7 +544,7 @@ namespace spot
} }
ta_explicit_ptr ta_explicit_ptr
tgba_to_ta(const const_tgba_ptr& tgba_, bdd atomic_propositions_set_, tgba_to_ta(const const_twa_ptr& tgba_, bdd atomic_propositions_set_,
bool degeneralized, bool artificial_initial_state_mode, bool degeneralized, bool artificial_initial_state_mode,
bool single_pass_emptiness_check, bool single_pass_emptiness_check,
bool artificial_livelock_state_mode, bool artificial_livelock_state_mode,
@ -601,7 +601,7 @@ namespace spot
} }
tgta_explicit_ptr tgta_explicit_ptr
tgba_to_tgta(const const_tgba_ptr& tgba_, bdd atomic_propositions_set_) tgba_to_tgta(const const_twa_ptr& tgba_, bdd atomic_propositions_set_)
{ {
state* tgba_init_state = tgba_->get_init_state(); state* tgba_init_state = tgba_->get_init_state();
auto artificial_init_state = new state_ta_explicit(tgba_init_state->clone(), auto artificial_init_state = new state_ta_explicit(tgba_init_state->clone(),

4
src/taalgos/tgba2ta.hh
View file

@ -82,7 +82,7 @@ namespace spot
/// \return A spot::ta_explicit that recognizes the same language as the /// \return A spot::ta_explicit that recognizes the same language as the
/// TGBA \a tgba_to_convert. /// TGBA \a tgba_to_convert.
SPOT_API ta_explicit_ptr SPOT_API ta_explicit_ptr
tgba_to_ta(const const_tgba_ptr& tgba_to_convert, bdd atomic_propositions_set, tgba_to_ta(const const_twa_ptr& tgba_to_convert, bdd atomic_propositions_set,
bool degeneralized = true, bool degeneralized = true,
bool artificial_initial_state_mode = true, bool artificial_initial_state_mode = true,
bool single_pass_emptiness_check = false, bool single_pass_emptiness_check = false,
@ -99,6 +99,6 @@ namespace spot
/// \return A spot::tgta_explicit (spot::tgta) that recognizes the same /// \return A spot::tgta_explicit (spot::tgta) that recognizes the same
/// language as the TGBA \a tgba_to_convert. /// language as the TGBA \a tgba_to_convert.
SPOT_API tgta_explicit_ptr SPOT_API tgta_explicit_ptr
tgba_to_tgta(const const_tgba_ptr& tgba_to_convert, tgba_to_tgta(const const_twa_ptr& tgba_to_convert,
bdd atomic_propositions_set); bdd atomic_propositions_set);
} }

4
src/tgba/fwd.hh
View file

@ -24,8 +24,8 @@
namespace spot namespace spot
{ {
class twa; class twa;
typedef std::shared_ptr<twa> tgba_ptr; typedef std::shared_ptr<twa> twa_ptr;
typedef std::shared_ptr<const twa> const_tgba_ptr; typedef std::shared_ptr<const twa> const_twa_ptr;
class twa_graph; class twa_graph;
typedef std::shared_ptr<const twa_graph> const_twa_graph_ptr; typedef std::shared_ptr<const twa_graph> const_twa_graph_ptr;

2
src/tgba/tgba.cc
View file

@ -60,7 +60,7 @@ namespace spot
state* state*
twa::project_state(const state* s, twa::project_state(const state* s,
const const_tgba_ptr& t) const const const_twa_ptr& t) const
{ {
if (t.get() == this) if (t.get() == this)
return s->clone(); return s->clone();

8
src/tgba/tgba.hh
View file

@ -629,7 +629,7 @@ namespace spot
/// or a new \c state* (the projected state) that must be /// or a new \c state* (the projected state) that must be
/// destroyed by the caller. /// destroyed by the caller.
virtual state* project_state(const state* s, virtual state* project_state(const state* s,
const const_tgba_ptr& t) const; const const_twa_ptr& t) const;
const acc_cond& acc() const const acc_cond& acc() const
@ -672,7 +672,7 @@ namespace spot
} }
/// \brief Copy the acceptance condition of another tgba. /// \brief Copy the acceptance condition of another tgba.
void copy_acceptance_of(const const_tgba_ptr& a) void copy_acceptance_of(const const_twa_ptr& a)
{ {
acc_ = a->acc(); acc_ = a->acc();
unsigned num = acc_.num_sets(); unsigned num = acc_.num_sets();
@ -680,7 +680,7 @@ namespace spot
prop_state_based_acc(); prop_state_based_acc();
} }
void copy_ap_of(const const_tgba_ptr& a) void copy_ap_of(const const_twa_ptr& a)
{ {
get_dict()->register_all_propositions_of(a, this); get_dict()->register_all_propositions_of(a, this);
} }
@ -821,7 +821,7 @@ namespace spot
// There is no default value here on purpose. This way any time we // There is no default value here on purpose. This way any time we
// add a new property we have to update every call to prop_copy(). // add a new property we have to update every call to prop_copy().
void prop_copy(const const_tgba_ptr& other, prop_set p) void prop_copy(const const_twa_ptr& other, prop_set p)
{ {
if (p.state_based) if (p.state_based)
prop_state_based_acc(other->has_state_based_acc()); prop_state_based_acc(other->has_state_based_acc());

2
src/tgba/tgbagraph.hh
View file

@ -470,7 +470,7 @@ namespace spot
return std::make_shared<twa_graph>(aut, p); return std::make_shared<twa_graph>(aut, p);
} }
inline twa_graph_ptr make_twa_graph(const const_tgba_ptr& aut, inline twa_graph_ptr make_twa_graph(const const_twa_ptr& aut,
twa::prop_set p) twa::prop_set p)
{ {
auto a = std::dynamic_pointer_cast<const twa_graph>(aut); auto a = std::dynamic_pointer_cast<const twa_graph>(aut);

20
src/tgba/tgbamask.cc
View file

@ -91,7 +91,7 @@ namespace spot
/// \param masked The automaton to mask /// \param masked The automaton to mask
/// \param init Any state to use as initial state. This state will be /// \param init Any state to use as initial state. This state will be
/// destroyed by the destructor. /// destroyed by the destructor.
tgba_mask(const const_tgba_ptr& masked, const state* init = 0): tgba_mask(const const_twa_ptr& masked, const state* init = 0):
tgba_proxy(masked), tgba_proxy(masked),
init_(init) init_(init)
{ {
@ -150,7 +150,7 @@ namespace spot
{ {
const state_set& mask_; const state_set& mask_;
public: public:
tgba_mask_keep(const const_tgba_ptr& masked, tgba_mask_keep(const const_twa_ptr& masked,
const state_set& mask, const state_set& mask,
const state* init) const state* init)
: tgba_mask(masked, init), : tgba_mask(masked, init),
@ -169,7 +169,7 @@ namespace spot
{ {
const state_set& mask_; const state_set& mask_;
public: public:
tgba_mask_ignore(const const_tgba_ptr& masked, tgba_mask_ignore(const const_twa_ptr& masked,
const state_set& mask, const state_set& mask,
const state* init) const state* init)
: tgba_mask(masked, init), : tgba_mask(masked, init),
@ -188,7 +188,7 @@ namespace spot
{ {
unsigned mask_; unsigned mask_;
public: public:
tgba_mask_acc_ignore(const const_tgba_ptr& masked, tgba_mask_acc_ignore(const const_twa_ptr& masked,
unsigned mask, unsigned mask,
const state* init) const state* init)
: tgba_mask(masked, init), : tgba_mask(masked, init),
@ -204,24 +204,24 @@ namespace spot
} }
const_tgba_ptr const_twa_ptr
build_tgba_mask_keep(const const_tgba_ptr& to_mask, build_tgba_mask_keep(const const_twa_ptr& to_mask,
const state_set& to_keep, const state_set& to_keep,
const state* init) const state* init)
{ {
return std::make_shared<tgba_mask_keep>(to_mask, to_keep, init); return std::make_shared<tgba_mask_keep>(to_mask, to_keep, init);
} }
const_tgba_ptr const_twa_ptr
build_tgba_mask_ignore(const const_tgba_ptr& to_mask, build_tgba_mask_ignore(const const_twa_ptr& to_mask,
const state_set& to_ignore, const state_set& to_ignore,
const state* init) const state* init)
{ {
return std::make_shared<tgba_mask_ignore>(to_mask, to_ignore, init); return std::make_shared<tgba_mask_ignore>(to_mask, to_ignore, init);
} }
const_tgba_ptr const_twa_ptr
build_tgba_mask_acc_ignore(const const_tgba_ptr& to_mask, build_tgba_mask_acc_ignore(const const_twa_ptr& to_mask,
unsigned to_ignore, unsigned to_ignore,
const state* init) const state* init)
{ {

12
src/tgba/tgbamask.hh
View file

@ -31,8 +31,8 @@ namespace spot
/// Mask the TGBA \a to_mask, keeping only the /// Mask the TGBA \a to_mask, keeping only the
/// states from \a to_keep. The initial state /// states from \a to_keep. The initial state
/// can optionally be reset to \a init. /// can optionally be reset to \a init.
SPOT_API const_tgba_ptr SPOT_API const_twa_ptr
build_tgba_mask_keep(const const_tgba_ptr& to_mask, build_tgba_mask_keep(const const_twa_ptr& to_mask,
const state_set& to_keep, const state_set& to_keep,
const state* init = 0); const state* init = 0);
@ -42,8 +42,8 @@ namespace spot
/// Mask the TGBA \a to_mask, keeping only the states that are not /// Mask the TGBA \a to_mask, keeping only the states that are not
/// in \a to_ignore. The initial state can optionally be reset to /// in \a to_ignore. The initial state can optionally be reset to
/// \a init. /// \a init.
SPOT_API const_tgba_ptr SPOT_API const_twa_ptr
build_tgba_mask_ignore(const const_tgba_ptr& to_mask, build_tgba_mask_ignore(const const_twa_ptr& to_mask,
const state_set& to_ignore, const state_set& to_ignore,
const state* init = 0); const state* init = 0);
@ -59,8 +59,8 @@ namespace spot
/// set of all acceptance set) is not changed, because so far this /// set of all acceptance set) is not changed, because so far this
/// function is only needed in graph algorithms that do not call /// function is only needed in graph algorithms that do not call
/// all_acceptance_conditions(). /// all_acceptance_conditions().
SPOT_API const_tgba_ptr SPOT_API const_twa_ptr
build_tgba_mask_acc_ignore(const const_tgba_ptr& to_mask, build_tgba_mask_acc_ignore(const const_twa_ptr& to_mask,
unsigned to_ignore, unsigned to_ignore,
const state* init = 0); const state* init = 0);
} }

14
src/tgba/tgbaproduct.cc
View file

@ -90,8 +90,8 @@ namespace spot
{ {
} }
void recycle(const const_tgba_ptr& l, twa_succ_iterator* left, void recycle(const const_twa_ptr& l, twa_succ_iterator* left,
const_tgba_ptr r, twa_succ_iterator* right) const_twa_ptr r, twa_succ_iterator* right)
{ {
l->release_iter(left_); l->release_iter(left_);
left_ = left; left_ = left;
@ -282,8 +282,8 @@ namespace spot
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
// twa_product // twa_product
twa_product::twa_product(const const_tgba_ptr& left, twa_product::twa_product(const const_twa_ptr& left,
const const_tgba_ptr& right) const const_twa_ptr& right)
: twa(left->get_dict()), left_(left), right_(right), : twa(left->get_dict()), left_(left), right_(right),
pool_(sizeof(state_product)) pool_(sizeof(state_product))
{ {
@ -393,7 +393,7 @@ namespace spot
} }
state* state*
twa_product::project_state(const state* s, const const_tgba_ptr& t) const twa_product::project_state(const state* s, const const_twa_ptr& t) const
{ {
const state_product* s2 = down_cast<const state_product*>(s); const state_product* s2 = down_cast<const state_product*>(s);
assert(s2); assert(s2);
@ -423,8 +423,8 @@ namespace spot
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
// twa_product_init // twa_product_init
twa_product_init::twa_product_init(const const_tgba_ptr& left, twa_product_init::twa_product_init(const const_twa_ptr& left,
const const_tgba_ptr& right, const const_twa_ptr& right,
const state* left_init, const state* left_init,
const state* right_init) const state* right_init)
: twa_product(left, right), : twa_product(left, right),

18
src/tgba/tgbaproduct.hh
View file

@ -84,7 +84,7 @@ namespace spot
/// \param left The left automata in the product. /// \param left The left automata in the product.
/// \param right The right automata in the product. /// \param right The right automata in the product.
/// Do not be fooled by these arguments: a product is commutative. /// Do not be fooled by these arguments: a product is commutative.
twa_product(const const_tgba_ptr& left, const const_tgba_ptr& right); twa_product(const const_twa_ptr& left, const const_twa_ptr& right);
virtual ~twa_product(); virtual ~twa_product();
@ -98,7 +98,7 @@ namespace spot
virtual std::string virtual std::string
transition_annotation(const twa_succ_iterator* t) const; transition_annotation(const twa_succ_iterator* t) const;
virtual state* project_state(const state* s, const const_tgba_ptr& t) const; virtual state* project_state(const state* s, const const_twa_ptr& t) const;
const acc_cond& left_acc() const; const acc_cond& left_acc() const;
const acc_cond& right_acc() const; const acc_cond& right_acc() const;
@ -107,8 +107,8 @@ namespace spot
virtual bdd compute_support_conditions(const state* state) const; virtual bdd compute_support_conditions(const state* state) const;
protected: protected:
const_tgba_ptr left_; const_twa_ptr left_;
const_tgba_ptr right_; const_twa_ptr right_;
bool left_kripke_; bool left_kripke_;
fixed_size_pool pool_; fixed_size_pool pool_;
@ -122,7 +122,7 @@ namespace spot
class SPOT_API twa_product_init final: public twa_product class SPOT_API twa_product_init final: public twa_product
{ {
public: public:
twa_product_init(const const_tgba_ptr& left, const const_tgba_ptr& right, twa_product_init(const const_twa_ptr& left, const const_twa_ptr& right,
const state* left_init, const state* right_init); const state* left_init, const state* right_init);
virtual state* get_init_state() const; virtual state* get_init_state() const;
protected: protected:
@ -131,15 +131,15 @@ namespace spot
}; };
/// \brief on-the-fly TGBA product /// \brief on-the-fly TGBA product
inline twa_product_ptr otf_product(const const_tgba_ptr& left, inline twa_product_ptr otf_product(const const_twa_ptr& left,
const const_tgba_ptr& right) const const_twa_ptr& right)
{ {
return std::make_shared<twa_product>(left, right); return std::make_shared<twa_product>(left, right);
} }
/// \brief on-the-fly TGBA product with forced initial states /// \brief on-the-fly TGBA product with forced initial states
inline twa_product_ptr otf_product_at(const const_tgba_ptr& left, inline twa_product_ptr otf_product_at(const const_twa_ptr& left,
const const_tgba_ptr& right, const const_twa_ptr& right,
const state* left_init, const state* left_init,
const state* right_init) const state* right_init)
{ {

4
src/tgba/tgbaproxy.cc
View file

@ -21,7 +21,7 @@
namespace spot namespace spot
{ {
tgba_proxy::tgba_proxy(const const_tgba_ptr& original) tgba_proxy::tgba_proxy(const const_twa_ptr& original)
: twa(original->get_dict()), original_(original) : twa(original->get_dict()), original_(original)
{ {
get_dict()->register_all_variables_of(original, this); get_dict()->register_all_variables_of(original, this);
@ -62,7 +62,7 @@ namespace spot
} }
state* state*
tgba_proxy::project_state(const state* s, const const_tgba_ptr& t) const tgba_proxy::project_state(const state* s, const const_twa_ptr& t) const
{ {
return original_->project_state(s, t); return original_->project_state(s, t);
} }

6
src/tgba/tgbaproxy.hh
View file

@ -35,7 +35,7 @@ namespace spot
class SPOT_API tgba_proxy: public twa class SPOT_API tgba_proxy: public twa
{ {
protected: protected:
tgba_proxy(const const_tgba_ptr& original); tgba_proxy(const const_twa_ptr& original);
public: public:
virtual ~tgba_proxy(); virtual ~tgba_proxy();
@ -50,10 +50,10 @@ namespace spot
virtual std::string virtual std::string
transition_annotation(const twa_succ_iterator* t) const; transition_annotation(const twa_succ_iterator* t) const;
virtual state* project_state(const state* s, const const_tgba_ptr& t) const; virtual state* project_state(const state* s, const const_twa_ptr& t) const;
protected: protected:
virtual bdd compute_support_conditions(const state* state) const; virtual bdd compute_support_conditions(const state* state) const;
const_tgba_ptr original_; const_twa_ptr original_;
}; };
} }

2
src/tgbaalgos/bfssteps.cc
View file

@ -28,7 +28,7 @@
namespace spot namespace spot
{ {
bfs_steps::bfs_steps(const const_tgba_ptr& a) bfs_steps::bfs_steps(const const_twa_ptr& a)
: a_(a) : a_(a)
{ {
} }

4
src/tgbaalgos/bfssteps.hh
View file

@ -40,7 +40,7 @@ namespace spot
class SPOT_API bfs_steps class SPOT_API bfs_steps
{ {
public: public:
bfs_steps(const const_tgba_ptr& a); bfs_steps(const const_twa_ptr& a);
virtual ~bfs_steps(); virtual ~bfs_steps();
/// \brief Start the search from \a start, and append the /// \brief Start the search from \a start, and append the
@ -97,6 +97,6 @@ namespace spot
tgba_run::steps& l); tgba_run::steps& l);
protected: protected:
const_tgba_ptr a_; ///< The spot::tgba we are searching into. const_twa_ptr a_; ///< The spot::tgba we are searching into.
}; };
} }

2
src/tgbaalgos/complete.cc
View file

@ -117,7 +117,7 @@ namespace spot
return sink; return sink;
} }
twa_graph_ptr tgba_complete(const const_tgba_ptr& aut) twa_graph_ptr tgba_complete(const const_twa_ptr& aut)
{ {
auto res = make_twa_graph(aut, { auto res = make_twa_graph(aut, {
true, // state based true, // state based

2
src/tgbaalgos/complete.hh
View file

@ -35,5 +35,5 @@ namespace spot
/// \brief Clone a tgba and complete it. /// \brief Clone a tgba and complete it.
/// ///
/// If the tgba has no acceptance set, one will be added. /// If the tgba has no acceptance set, one will be added.
SPOT_API twa_graph_ptr tgba_complete(const const_tgba_ptr& aut); SPOT_API twa_graph_ptr tgba_complete(const const_twa_ptr& aut);
} }

2
src/tgbaalgos/compsusp.cc
View file

@ -212,7 +212,7 @@ namespace spot
static static
twa_graph_ptr twa_graph_ptr
susp_prod(const const_tgba_ptr& left, const ltl::formula* f, bdd v) susp_prod(const const_twa_ptr& left, const ltl::formula* f, bdd v)
{ {
bdd_dict_ptr dict = left->get_dict(); bdd_dict_ptr dict = left->get_dict();
auto right = auto right =

2
src/tgbaalgos/dotty.cc
View file

@ -488,7 +488,7 @@ namespace spot
} // anonymous namespace } // anonymous namespace
std::ostream& std::ostream&
dotty_reachable(std::ostream& os, const const_tgba_ptr& g, dotty_reachable(std::ostream& os, const const_twa_ptr& g,
const char* options) const char* options)
{ {
dotty_output d(os, options); dotty_output d(os, options);

2
src/tgbaalgos/dotty.hh
View file

@ -42,6 +42,6 @@ namespace spot
/// 'a' shows the acceptance. /// 'a' shows the acceptance.
SPOT_API std::ostream& SPOT_API std::ostream&
dotty_reachable(std::ostream& os, dotty_reachable(std::ostream& os,
const const_tgba_ptr& g, const const_twa_ptr& g,
const char* options = nullptr); const char* options = nullptr);
} }

4
src/tgbaalgos/dtgbasat.cc
View file

@ -245,12 +245,12 @@ namespace spot
struct dict struct dict
{ {
dict(const const_tgba_ptr& a) dict(const const_twa_ptr& a)
: aut(a) : aut(a)
{ {
} }
const_tgba_ptr aut; const_twa_ptr aut;
typedef std::map<transition, int> trans_map; typedef std::map<transition, int> trans_map;
typedef std::map<transition_acc, int> trans_acc_map; typedef std::map<transition_acc, int> trans_acc_map;
trans_map transid; trans_map transid;

6
src/tgbaalgos/dupexp.cc
View file

@ -36,7 +36,7 @@ namespace spot
class dupexp_iter: public T class dupexp_iter: public T
{ {
public: public:
dupexp_iter(const const_tgba_ptr& a, twa::prop_set p) dupexp_iter(const const_twa_ptr& a, twa::prop_set p)
: T(a), out_(make_twa_graph(a->get_dict())) : T(a), out_(make_twa_graph(a->get_dict()))
{ {
out_->copy_acceptance_of(a); out_->copy_acceptance_of(a);
@ -76,7 +76,7 @@ namespace spot
} // anonymous } // anonymous
twa_graph_ptr twa_graph_ptr
tgba_dupexp_bfs(const const_tgba_ptr& aut, twa::prop_set p) tgba_dupexp_bfs(const const_twa_ptr& aut, twa::prop_set p)
{ {
dupexp_iter<tgba_reachable_iterator_breadth_first> di(aut, p); dupexp_iter<tgba_reachable_iterator_breadth_first> di(aut, p);
di.run(); di.run();
@ -84,7 +84,7 @@ namespace spot
} }
twa_graph_ptr twa_graph_ptr
tgba_dupexp_dfs(const const_tgba_ptr& aut, twa::prop_set p) tgba_dupexp_dfs(const const_twa_ptr& aut, twa::prop_set p)
{ {
dupexp_iter<tgba_reachable_iterator_depth_first> di(aut, p); dupexp_iter<tgba_reachable_iterator_depth_first> di(aut, p);
di.run(); di.run();

4
src/tgbaalgos/dupexp.hh
View file

@ -33,10 +33,10 @@ namespace spot
/// \brief Build an explicit automaton from all states of \a aut, /// \brief Build an explicit automaton from all states of \a aut,
/// numbering states in bread first order as they are processed. /// numbering states in bread first order as they are processed.
SPOT_API twa_graph_ptr SPOT_API twa_graph_ptr
tgba_dupexp_bfs(const const_tgba_ptr& aut, twa::prop_set p); tgba_dupexp_bfs(const const_twa_ptr& aut, twa::prop_set p);
/// \ingroup tgba_misc /// \ingroup tgba_misc
/// \brief Build an explicit automaton from all states of \a aut, /// \brief Build an explicit automaton from all states of \a aut,
/// numbering states in depth first order as they are processed. /// numbering states in depth first order as they are processed.
SPOT_API twa_graph_ptr SPOT_API twa_graph_ptr
tgba_dupexp_dfs(const const_tgba_ptr& aut, twa::prop_set p); tgba_dupexp_dfs(const const_twa_ptr& aut, twa::prop_set p);
} }

8
src/tgbaalgos/emptiness.cc
View file

@ -77,7 +77,7 @@ namespace spot
std::ostream& std::ostream&
print_tgba_run(std::ostream& os, print_tgba_run(std::ostream& os,
const const_tgba_ptr& a, const const_twa_ptr& a,
const const_tgba_run_ptr& run) const const_tgba_run_ptr& run)
{ {
bdd_dict_ptr d = a->get_dict(); bdd_dict_ptr d = a->get_dict();
@ -189,7 +189,7 @@ namespace spot
struct ec_algo struct ec_algo
{ {
const char* name; const char* name;
emptiness_check_ptr(*construct)(const const_tgba_ptr&, emptiness_check_ptr(*construct)(const const_twa_ptr&,
spot::option_map); spot::option_map);
unsigned int min_acc; unsigned int min_acc;
unsigned int max_acc; unsigned int max_acc;
@ -225,7 +225,7 @@ namespace spot
} }
emptiness_check_ptr emptiness_check_ptr
emptiness_check_instantiator::instantiate(const const_tgba_ptr& a) const emptiness_check_instantiator::instantiate(const const_twa_ptr& a) const
{ {
return static_cast<ec_algo*>(info_)->construct(a, o_); return static_cast<ec_algo*>(info_)->construct(a, o_);
} }
@ -291,7 +291,7 @@ namespace spot
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
twa_graph_ptr twa_graph_ptr
tgba_run_to_tgba(const const_tgba_ptr& a, const const_tgba_run_ptr& run) tgba_run_to_tgba(const const_twa_ptr& a, const const_tgba_run_ptr& run)
{ {
auto d = a->get_dict(); auto d = a->get_dict();
auto res = make_twa_graph(d); auto res = make_twa_graph(d);

18
src/tgbaalgos/emptiness.hh
View file

@ -77,7 +77,7 @@ namespace spot
class SPOT_API emptiness_check_result class SPOT_API emptiness_check_result
{ {
public: public:
emptiness_check_result(const const_tgba_ptr& a, emptiness_check_result(const const_twa_ptr& a,
option_map o = option_map()) option_map o = option_map())
: a_(a), o_(o) : a_(a), o_(o)
{ {
@ -103,7 +103,7 @@ namespace spot
virtual tgba_run_ptr accepting_run(); virtual tgba_run_ptr accepting_run();
/// The automaton on which an accepting_run() was found. /// The automaton on which an accepting_run() was found.
const const_tgba_ptr& const const_twa_ptr&
automaton() const automaton() const
{ {
return a_; return a_;
@ -126,7 +126,7 @@ namespace spot
/// Notify option updates. /// Notify option updates.
virtual void options_updated(const option_map& old); virtual void options_updated(const option_map& old);
const_tgba_ptr a_; ///< The automaton. const_twa_ptr a_; ///< The automaton.
option_map o_; ///< The options. option_map o_; ///< The options.
}; };
@ -137,14 +137,14 @@ namespace spot
public std::enable_shared_from_this<emptiness_check> public std::enable_shared_from_this<emptiness_check>
{ {
public: public:
emptiness_check(const const_tgba_ptr& a, option_map o = option_map()) emptiness_check(const const_twa_ptr& a, option_map o = option_map())
: a_(a), o_(o) : a_(a), o_(o)
{ {
} }
virtual ~emptiness_check(); virtual ~emptiness_check();
/// The automaton that this emptiness-check inspects. /// The automaton that this emptiness-check inspects.
const const_tgba_ptr& const const_twa_ptr&
automaton() const automaton() const
{ {
return a_; return a_;
@ -192,7 +192,7 @@ namespace spot
virtual void options_updated(const option_map& old); virtual void options_updated(const option_map& old);
protected: protected:
const_tgba_ptr a_; ///< The automaton. const_twa_ptr a_; ///< The automaton.
option_map o_; ///< The options option_map o_; ///< The options
}; };
@ -207,7 +207,7 @@ namespace spot
{ {
public: public:
/// Actually instantiate the emptiness check, for \a a. /// Actually instantiate the emptiness check, for \a a.
emptiness_check_ptr instantiate(const const_tgba_ptr& a) const; emptiness_check_ptr instantiate(const const_twa_ptr& a) const;
/// Accessor to the options. /// Accessor to the options.
/// @{ /// @{
@ -308,7 +308,7 @@ namespace spot
/// transition annotation). /// transition annotation).
SPOT_API std::ostream& SPOT_API std::ostream&
print_tgba_run(std::ostream& os, print_tgba_run(std::ostream& os,
const const_tgba_ptr& a, const const_twa_ptr& a,
const const_tgba_run_ptr& run); const const_tgba_run_ptr& run);
/// \brief Return an explicit_tgba corresponding to \a run (i.e. comparable /// \brief Return an explicit_tgba corresponding to \a run (i.e. comparable
@ -316,7 +316,7 @@ namespace spot
/// ///
/// \pre \a run must correspond to an actual run of the automaton \a a. /// \pre \a run must correspond to an actual run of the automaton \a a.
SPOT_API twa_graph_ptr SPOT_API twa_graph_ptr
tgba_run_to_tgba(const const_tgba_ptr& a, const const_tgba_run_ptr& run); tgba_run_to_tgba(const const_twa_ptr& a, const const_tgba_run_ptr& run);
/// @} /// @}

6
src/tgbaalgos/gtec/gtec.cc
View file

@ -40,7 +40,7 @@ namespace spot
typedef std::pair<const spot::state*, twa_succ_iterator*> pair_state_iter; typedef std::pair<const spot::state*, twa_succ_iterator*> pair_state_iter;
} }
couvreur99_check::couvreur99_check(const const_tgba_ptr& a, option_map o) couvreur99_check::couvreur99_check(const const_twa_ptr& a, option_map o)
: emptiness_check(a, o), : emptiness_check(a, o),
removed_components(0) removed_components(0)
{ {
@ -326,7 +326,7 @@ namespace spot
} }
} }
couvreur99_check_shy::couvreur99_check_shy(const const_tgba_ptr& a, couvreur99_check_shy::couvreur99_check_shy(const const_twa_ptr& a,
option_map o) option_map o)
: couvreur99_check(a, o), num(1) : couvreur99_check(a, o), num(1)
{ {
@ -607,7 +607,7 @@ namespace spot
} }
emptiness_check_ptr emptiness_check_ptr
couvreur99(const const_tgba_ptr& a, option_map o) couvreur99(const const_twa_ptr& a, option_map o)
{ {
if (o.get("shy")) if (o.get("shy"))
return std::make_shared<couvreur99_check_shy>(a, o); return std::make_shared<couvreur99_check_shy>(a, o);

6
src/tgbaalgos/gtec/gtec.hh
View file

@ -136,7 +136,7 @@ namespace spot
/// choosing a successor. Otherwise, only the successor of the /// choosing a successor. Otherwise, only the successor of the
/// topmost state on the DFS stack are considered. /// topmost state on the DFS stack are considered.
SPOT_API emptiness_check_ptr SPOT_API emptiness_check_ptr
couvreur99(const const_tgba_ptr& a, option_map options = option_map()); couvreur99(const const_twa_ptr& a, option_map options = option_map());
#ifndef SWIG #ifndef SWIG
/// \brief An implementation of the Couvreur99 emptiness-check algorithm. /// \brief An implementation of the Couvreur99 emptiness-check algorithm.
@ -145,7 +145,7 @@ namespace spot
class SPOT_API couvreur99_check: public emptiness_check, public ec_statistics class SPOT_API couvreur99_check: public emptiness_check, public ec_statistics
{ {
public: public:
couvreur99_check(const const_tgba_ptr& a, option_map o = option_map()); couvreur99_check(const const_twa_ptr& a, option_map o = option_map());
virtual ~couvreur99_check(); virtual ~couvreur99_check();
/// Check whether the automaton's language is empty. /// Check whether the automaton's language is empty.
@ -187,7 +187,7 @@ namespace spot
class SPOT_API couvreur99_check_shy final: public couvreur99_check class SPOT_API couvreur99_check_shy final: public couvreur99_check
{ {
public: public:
couvreur99_check_shy(const const_tgba_ptr& a, option_map o = option_map()); couvreur99_check_shy(const const_twa_ptr& a, option_map o = option_map());
virtual ~couvreur99_check_shy(); virtual ~couvreur99_check_shy();
virtual emptiness_check_result_ptr check(); virtual emptiness_check_result_ptr check();

2
src/tgbaalgos/gtec/status.cc
View file

@ -25,7 +25,7 @@
namespace spot namespace spot
{ {
couvreur99_check_status::couvreur99_check_status(const const_tgba_ptr& aut) couvreur99_check_status::couvreur99_check_status(const const_twa_ptr& aut)
: aut(aut) : aut(aut)
{ {
} }

4
src/tgbaalgos/gtec/status.hh
View file

@ -36,11 +36,11 @@ namespace spot
class SPOT_API couvreur99_check_status class SPOT_API couvreur99_check_status
{ {
public: public:
couvreur99_check_status(const const_tgba_ptr& aut); couvreur99_check_status(const const_twa_ptr& aut);
~couvreur99_check_status(); ~couvreur99_check_status();
const_tgba_ptr aut; const_twa_ptr aut;
scc_stack root; scc_stack root;
typedef std::unordered_map<const state*, int, typedef std::unordered_map<const state*, int,

4
src/tgbaalgos/gv04.cc
View file

@ -67,7 +67,7 @@ namespace spot
int dftop; // Top of DFS stack. int dftop; // Top of DFS stack.
bool violation; // Whether an accepting run was found. bool violation; // Whether an accepting run was found.
gv04(const const_tgba_ptr& a, option_map o) gv04(const const_twa_ptr& a, option_map o)
: emptiness_check(a, o) : emptiness_check(a, o)
{ {
assert(a->acc().num_sets() <= 1); assert(a->acc().num_sets() <= 1);
@ -407,7 +407,7 @@ namespace spot
} // anonymous } // anonymous
emptiness_check_ptr emptiness_check_ptr
explicit_gv04_check(const const_tgba_ptr& a, option_map o) explicit_gv04_check(const const_twa_ptr& a, option_map o)
{ {
return std::make_shared<gv04>(a, o); return std::make_shared<gv04>(a, o);
} }

2
src/tgbaalgos/gv04.hh
View file

@ -53,5 +53,5 @@ namespace spot
} }
\endverbatim */ \endverbatim */
SPOT_API emptiness_check_ptr SPOT_API emptiness_check_ptr
explicit_gv04_check(const const_tgba_ptr& a, option_map o = option_map()); explicit_gv04_check(const const_twa_ptr& a, option_map o = option_map());
} }

2
src/tgbaalgos/hoa.cc
View file

@ -432,7 +432,7 @@ namespace spot
std::ostream& std::ostream&
hoa_reachable(std::ostream& os, hoa_reachable(std::ostream& os,
const const_tgba_ptr& aut, const const_twa_ptr& aut,
const char* opt) const char* opt)
{ {

2
src/tgbaalgos/hoa.hh
View file

@ -37,6 +37,6 @@ namespace spot
/// single-line output. /// single-line output.
SPOT_API std::ostream& SPOT_API std::ostream&
hoa_reachable(std::ostream& os, hoa_reachable(std::ostream& os,
const const_tgba_ptr& g, const const_twa_ptr& g,
const char* opt); const char* opt);
} }

4
src/tgbaalgos/lbtt.cc
View file

@ -38,7 +38,7 @@ namespace spot
class lbtt_bfs : public tgba_reachable_iterator_breadth_first class lbtt_bfs : public tgba_reachable_iterator_breadth_first
{ {
public: public:
lbtt_bfs(const const_tgba_ptr& a, std::ostream& os, bool sba_format) lbtt_bfs(const const_twa_ptr& a, std::ostream& os, bool sba_format)
: tgba_reachable_iterator_breadth_first(a), : tgba_reachable_iterator_breadth_first(a),
os_(os), os_(os),
sba_format_(sba_format), sba_format_(sba_format),
@ -133,7 +133,7 @@ namespace spot
} }
std::ostream& std::ostream&
lbtt_reachable(std::ostream& os, const const_tgba_ptr& g, bool sba) lbtt_reachable(std::ostream& os, const const_twa_ptr& g, bool sba)
{ {
if (!g->acc().is_generalized_buchi()) if (!g->acc().is_generalized_buchi())
throw std::runtime_error throw std::runtime_error

2
src/tgbaalgos/lbtt.hh
View file

@ -35,5 +35,5 @@ namespace spot
/// \param sba Assume \a g is an SBA and use LBTT's state-based /// \param sba Assume \a g is an SBA and use LBTT's state-based
/// acceptance format (similar to LBT's format). /// acceptance format (similar to LBT's format).
SPOT_API std::ostream& SPOT_API std::ostream&
lbtt_reachable(std::ostream& os, const const_tgba_ptr& g, bool sba = false); lbtt_reachable(std::ostream& os, const const_twa_ptr& g, bool sba = false);
} }

8
src/tgbaalgos/magic.cc
View file

@ -54,7 +54,7 @@ namespace spot
/// ///
/// \pre The automaton \a a must have at most one acceptance /// \pre The automaton \a a must have at most one acceptance
/// condition (i.e. it is a TBA). /// condition (i.e. it is a TBA).
magic_search_(const const_tgba_ptr& a, size_t size, magic_search_(const const_twa_ptr& a, size_t size,
option_map o = option_map()) option_map o = option_map())
: emptiness_check(a, o), : emptiness_check(a, o),
h(size) h(size)
@ -584,20 +584,20 @@ namespace spot
} // anonymous } // anonymous
emptiness_check_ptr emptiness_check_ptr
explicit_magic_search(const const_tgba_ptr& a, option_map o) explicit_magic_search(const const_twa_ptr& a, option_map o)
{ {
return std::make_shared<magic_search_<explicit_magic_search_heap>>(a, 0, o); return std::make_shared<magic_search_<explicit_magic_search_heap>>(a, 0, o);
} }
emptiness_check_ptr emptiness_check_ptr
bit_state_hashing_magic_search(const const_tgba_ptr& a, bit_state_hashing_magic_search(const const_twa_ptr& a,
size_t size, option_map o) size_t size, option_map o)
{ {
return std::make_shared<magic_search_<bsh_magic_search_heap>>(a, size, o); return std::make_shared<magic_search_<bsh_magic_search_heap>>(a, size, o);
} }
emptiness_check_ptr emptiness_check_ptr
magic_search(const const_tgba_ptr& a, option_map o) magic_search(const const_twa_ptr& a, option_map o)
{ {
size_t size = o.get("bsh"); size_t size = o.get("bsh");
if (size) if (size)

6
src/tgbaalgos/magic.hh
View file

@ -96,7 +96,7 @@ namespace spot
/// \bug The name is misleading. Magic-search is the algorithm /// \bug The name is misleading. Magic-search is the algorithm
/// from \c godefroid.93.pstv, not \c courcoubetis.92.fmsd. /// from \c godefroid.93.pstv, not \c courcoubetis.92.fmsd.
SPOT_API emptiness_check_ptr SPOT_API emptiness_check_ptr
explicit_magic_search(const const_tgba_ptr& a, explicit_magic_search(const const_twa_ptr& a,
option_map o = option_map()); option_map o = option_map());
/// \brief Returns an emptiness checker on the spot::tgba automaton \a a. /// \brief Returns an emptiness checker on the spot::tgba automaton \a a.
@ -127,7 +127,7 @@ namespace spot
/// \sa spot::explicit_magic_search /// \sa spot::explicit_magic_search
/// ///
SPOT_API emptiness_check_ptr SPOT_API emptiness_check_ptr
bit_state_hashing_magic_search(const const_tgba_ptr& a, size_t size, bit_state_hashing_magic_search(const const_twa_ptr& a, size_t size,
option_map o = option_map()); option_map o = option_map());
/// \brief Wrapper for the two magic_search implementations. /// \brief Wrapper for the two magic_search implementations.
@ -137,7 +137,7 @@ namespace spot
/// in the \c option_map. If \c "bsh" is set and non null, its value /// in the \c option_map. If \c "bsh" is set and non null, its value
/// is used as the size of the hash map. /// is used as the size of the hash map.
SPOT_API emptiness_check_ptr SPOT_API emptiness_check_ptr
magic_search(const const_tgba_ptr& a, option_map o = option_map()); magic_search(const const_twa_ptr& a, option_map o = option_map());
/// @} /// @}
} }

10
src/tgbaalgos/minimize.cc
View file

@ -60,7 +60,7 @@ namespace spot
{ {
static std::ostream& static std::ostream&
dump_hash_set(const hash_set* hs, dump_hash_set(const hash_set* hs,
const const_tgba_ptr& aut, const const_twa_ptr& aut,
std::ostream& out) std::ostream& out)
{ {
out << '{'; out << '{';
@ -75,7 +75,7 @@ namespace spot
} }
static std::string static std::string
format_hash_set(const hash_set* hs, const_tgba_ptr aut) format_hash_set(const hash_set* hs, const_twa_ptr aut)
{ {
std::ostringstream s; std::ostringstream s;
dump_hash_set(hs, aut, s); dump_hash_set(hs, aut, s);
@ -84,7 +84,7 @@ namespace spot
} }
// Find all states of an automaton. // Find all states of an automaton.
void build_state_set(const const_tgba_ptr& a, hash_set* seen) void build_state_set(const const_twa_ptr& a, hash_set* seen)
{ {
std::queue<const state*> tovisit; std::queue<const state*> tovisit;
// Perform breadth-first traversal. // Perform breadth-first traversal.
@ -114,7 +114,7 @@ namespace spot
// From the base automaton and the list of sets, build the minimal // From the base automaton and the list of sets, build the minimal
// resulting automaton // resulting automaton
twa_graph_ptr build_result(const const_tgba_ptr& a, twa_graph_ptr build_result(const const_twa_ptr& a,
std::list<hash_set*>& sets, std::list<hash_set*>& sets,
hash_set* final) hash_set* final)
{ {
@ -182,7 +182,7 @@ namespace spot
struct wdba_search_acc_loop : public bfs_steps struct wdba_search_acc_loop : public bfs_steps
{ {
wdba_search_acc_loop(const const_tgba_ptr& det_a, wdba_search_acc_loop(const const_twa_ptr& det_a,
unsigned scc_n, scc_info& sm, unsigned scc_n, scc_info& sm,
power_map& pm, const state* dest) power_map& pm, const state* dest)
: bfs_steps(det_a), scc_n(scc_n), sm(sm), pm(pm), dest(dest) : bfs_steps(det_a), scc_n(scc_n), sm(sm), pm(pm), dest(dest)

6
src/tgbaalgos/ndfs_result.hxx
View file

@ -229,7 +229,7 @@ namespace spot
typedef std::unordered_set<const state*, typedef std::unordered_set<const state*,
state_ptr_hash, state_ptr_equal> state_set; state_ptr_hash, state_ptr_equal> state_set;
void clean(const const_tgba_ptr& a, stack_type& st1, void clean(const const_twa_ptr& a, stack_type& st1,
state_set& seen, state_set& dead) state_set& seen, state_set& dead)
{ {
while (!st1.empty()) while (!st1.empty())
@ -372,7 +372,7 @@ namespace spot
{ {
public: public:
test_path(ars_statistics* ars, test_path(ars_statistics* ars,
const const_tgba_ptr& a, const state* t, const const_twa_ptr& a, const state* t,
const state_set& d, const heap& h) const state_set& d, const heap& h)
: bfs_steps(a), ars(ars), target(t), dead(d), h(h) : bfs_steps(a), ars(ars), target(t), dead(d), h(h)
{ {
@ -467,7 +467,7 @@ namespace spot
{ {
public: public:
min_path(ars_statistics* ars, min_path(ars_statistics* ars,
const const_tgba_ptr& a, const const_twa_ptr& a,
const m_source_trans& target, const heap& h) const m_source_trans& target, const heap& h)
: bfs_steps(a), ars(ars), target(target), h(h) : bfs_steps(a), ars(ars), target(target), h(h)
{ {

2
src/tgbaalgos/neverclaim.cc
View file

@ -201,7 +201,7 @@ namespace spot
} // anonymous namespace } // anonymous namespace
std::ostream& std::ostream&
never_claim_reachable(std::ostream& os, const const_tgba_ptr& g, never_claim_reachable(std::ostream& os, const const_twa_ptr& g,
const char* options) const char* options)
{ {
if (!(g->acc().is_buchi() || g->acc().is_true())) if (!(g->acc().is_buchi() || g->acc().is_true()))

2
src/tgbaalgos/neverclaim.hh
View file

@ -40,6 +40,6 @@ namespace spot
/// \param opt a string of option: 'c' to comment each state /// \param opt a string of option: 'c' to comment each state
SPOT_API std::ostream& SPOT_API std::ostream&
never_claim_reachable(std::ostream& os, never_claim_reachable(std::ostream& os,
const const_tgba_ptr& g, const const_twa_ptr& g,
const char* opt = nullptr); const char* opt = nullptr);
} }

4
src/tgbaalgos/projrun.cc
View file

@ -28,8 +28,8 @@ namespace spot
{ {
tgba_run_ptr tgba_run_ptr
project_tgba_run(const const_tgba_ptr& a_run, project_tgba_run(const const_twa_ptr& a_run,
const const_tgba_ptr& a_proj, const const_twa_ptr& a_proj,
const const_tgba_run_ptr& run) const const_tgba_run_ptr& run)
{ {
auto res = std::make_shared<tgba_run>(); auto res = std::make_shared<tgba_run>();

4
src/tgbaalgos/projrun.hh
View file

@ -42,7 +42,7 @@ namespace spot
/// \param a_proj the automata on which to project the run /// \param a_proj the automata on which to project the run
/// \return true iff the run could be completed /// \return true iff the run could be completed
SPOT_API tgba_run_ptr SPOT_API tgba_run_ptr
project_tgba_run(const const_tgba_ptr& a_run, project_tgba_run(const const_twa_ptr& a_run,
const const_tgba_ptr& a_proj, const const_twa_ptr& a_proj,
const const_tgba_run_ptr& run); const const_tgba_run_ptr& run);
} }

8
src/tgbaalgos/reachiter.cc
View file

@ -28,7 +28,7 @@ namespace spot
// tgba_reachable_iterator // tgba_reachable_iterator
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
tgba_reachable_iterator::tgba_reachable_iterator(const const_tgba_ptr& a) tgba_reachable_iterator::tgba_reachable_iterator(const const_twa_ptr& a)
: aut_(a) : aut_(a)
{ {
} }
@ -122,7 +122,7 @@ namespace spot
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
tgba_reachable_iterator_breadth_first:: tgba_reachable_iterator_breadth_first::
tgba_reachable_iterator_breadth_first(const const_tgba_ptr& a) tgba_reachable_iterator_breadth_first(const const_twa_ptr& a)
: tgba_reachable_iterator(a) : tgba_reachable_iterator(a)
{ {
} }
@ -147,7 +147,7 @@ namespace spot
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
tgba_reachable_iterator_depth_first:: tgba_reachable_iterator_depth_first::
tgba_reachable_iterator_depth_first(const const_tgba_ptr& a) tgba_reachable_iterator_depth_first(const const_twa_ptr& a)
: aut_(a) : aut_(a)
{ {
} }
@ -273,7 +273,7 @@ namespace spot
tgba_reachable_iterator_depth_first_stack:: tgba_reachable_iterator_depth_first_stack::
tgba_reachable_iterator_depth_first_stack(const const_tgba_ptr& a) tgba_reachable_iterator_depth_first_stack(const const_twa_ptr& a)
: tgba_reachable_iterator_depth_first(a) : tgba_reachable_iterator_depth_first(a)
{ {
} }

12
src/tgbaalgos/reachiter.hh
View file

@ -34,7 +34,7 @@ namespace spot
class SPOT_API tgba_reachable_iterator class SPOT_API tgba_reachable_iterator
{ {
public: public:
tgba_reachable_iterator(const const_tgba_ptr& a); tgba_reachable_iterator(const const_twa_ptr& a);
virtual ~tgba_reachable_iterator(); virtual ~tgba_reachable_iterator();
/// \brief Iterate over all reachable states of a spot::tgba. /// \brief Iterate over all reachable states of a spot::tgba.
@ -88,7 +88,7 @@ namespace spot
const twa_succ_iterator* si); const twa_succ_iterator* si);
protected: protected:
const_tgba_ptr aut_; ///< The spot::tgba to explore. const_twa_ptr aut_; ///< The spot::tgba to explore.
typedef std::unordered_map<const state*, int, typedef std::unordered_map<const state*, int,
state_ptr_hash, state_ptr_equal> seen_map; state_ptr_hash, state_ptr_equal> seen_map;
@ -102,7 +102,7 @@ namespace spot
public tgba_reachable_iterator public tgba_reachable_iterator
{ {
public: public:
tgba_reachable_iterator_breadth_first(const const_tgba_ptr& a); tgba_reachable_iterator_breadth_first(const const_twa_ptr& a);
virtual void add_state(const state* s); virtual void add_state(const state* s);
virtual const state* next_state(); virtual const state* next_state();
@ -116,7 +116,7 @@ namespace spot
class SPOT_API tgba_reachable_iterator_depth_first class SPOT_API tgba_reachable_iterator_depth_first
{ {
public: public:
tgba_reachable_iterator_depth_first(const const_tgba_ptr& a); tgba_reachable_iterator_depth_first(const const_twa_ptr& a);
virtual ~tgba_reachable_iterator_depth_first(); virtual ~tgba_reachable_iterator_depth_first();
/// \brief Iterate over all reachable states of a spot::tgba. /// \brief Iterate over all reachable states of a spot::tgba.
@ -158,7 +158,7 @@ namespace spot
const twa_succ_iterator* si); const twa_succ_iterator* si);
protected: protected:
const_tgba_ptr aut_; ///< The spot::tgba to explore. const_twa_ptr aut_; ///< The spot::tgba to explore.
typedef std::unordered_map<const state*, int, typedef std::unordered_map<const state*, int,
state_ptr_hash, state_ptr_equal> seen_map; state_ptr_hash, state_ptr_equal> seen_map;
@ -186,7 +186,7 @@ namespace spot
: public tgba_reachable_iterator_depth_first : public tgba_reachable_iterator_depth_first
{ {
public: public:
tgba_reachable_iterator_depth_first_stack(const const_tgba_ptr& a); tgba_reachable_iterator_depth_first_stack(const const_twa_ptr& a);
/// \brief Whether state sn is on the DFS stack. /// \brief Whether state sn is on the DFS stack.
/// ///
/// Note the destination state of a transition is only pushed to /// Note the destination state of a transition is only pushed to

4
src/tgbaalgos/reducerun.cc
View file

@ -33,7 +33,7 @@ namespace spot
class shortest_path: public bfs_steps class shortest_path: public bfs_steps
{ {
public: public:
shortest_path(const const_tgba_ptr& a) shortest_path(const const_twa_ptr& a)
: bfs_steps(a), target(0) : bfs_steps(a), target(0)
{ {
} }
@ -88,7 +88,7 @@ namespace spot
} }
tgba_run_ptr tgba_run_ptr
reduce_run(const const_tgba_ptr& a, const const_tgba_run_ptr& org) reduce_run(const const_twa_ptr& a, const const_tgba_run_ptr& org)
{ {
auto res = std::make_shared<tgba_run>(); auto res = std::make_shared<tgba_run>();
state_set ss; state_set ss;

2
src/tgbaalgos/reducerun.hh
View file

@ -34,5 +34,5 @@ namespace spot
/// Return a run which is accepting for \a a and that is no longer /// Return a run which is accepting for \a a and that is no longer
/// than \a org. /// than \a org.
SPOT_API tgba_run_ptr SPOT_API tgba_run_ptr
reduce_run(const const_tgba_ptr& a, const const_tgba_run_ptr& org); reduce_run(const const_twa_ptr& a, const const_tgba_run_ptr& org);
} }

4
src/tgbaalgos/replayrun.cc
View file

@ -33,7 +33,7 @@ namespace spot
{ {
void void
print_annotation(std::ostream& os, print_annotation(std::ostream& os,
const const_tgba_ptr& a, const const_twa_ptr& a,
const twa_succ_iterator* i) const twa_succ_iterator* i)
{ {
std::string s = a->transition_annotation(i); std::string s = a->transition_annotation(i);
@ -44,7 +44,7 @@ namespace spot
} }
bool bool
replay_tgba_run(std::ostream& os, const const_tgba_ptr& a, replay_tgba_run(std::ostream& os, const const_twa_ptr& a,
const const_tgba_run_ptr& run, bool debug) const const_tgba_run_ptr& run, bool debug)
{ {
const state* s = a->get_init_state(); const state* s = a->get_init_state();

2
src/tgbaalgos/replayrun.hh
View file

@ -48,7 +48,7 @@ namespace spot
/// \return true iff the run could be completed /// \return true iff the run could be completed
SPOT_API bool SPOT_API bool
replay_tgba_run(std::ostream& os, replay_tgba_run(std::ostream& os,
const const_tgba_ptr& a, const const_twa_ptr& a,
const const_tgba_run_ptr& run, const const_tgba_run_ptr& run,
bool debug = false); bool debug = false);
} }

6
src/tgbaalgos/scc.cc
View file

@ -27,7 +27,7 @@
namespace spot namespace spot
{ {
scc_map::scc_map(const const_tgba_ptr& aut) scc_map::scc_map(const const_twa_ptr& aut)
: aut_(aut) : aut_(aut)
{ {
} }
@ -76,7 +76,7 @@ namespace spot
return aut_->acc().accepting(acc_set_of(n)); return aut_->acc().accepting(acc_set_of(n));
} }
const_tgba_ptr const_twa_ptr
scc_map::get_aut() const scc_map::get_aut() const
{ {
return aut_; return aut_;
@ -443,7 +443,7 @@ namespace spot
} }
std::ostream& std::ostream&
dump_scc_dot(const const_tgba_ptr& a, std::ostream& out, bool verbose) dump_scc_dot(const const_twa_ptr& a, std::ostream& out, bool verbose)
{ {
scc_map m(a); scc_map m(a);
m.build_map(); m.build_map();

8
src/tgbaalgos/scc.hh
View file

@ -41,7 +41,7 @@ namespace spot
/// ///
/// This will note compute the map initially. You should call /// This will note compute the map initially. You should call
/// build_map() to do so. /// build_map() to do so.
scc_map(const const_tgba_ptr& aut); scc_map(const const_twa_ptr& aut);
~scc_map(); ~scc_map();
@ -49,7 +49,7 @@ namespace spot
void build_map(); void build_map();
/// Get the automaton for which the map has been constructed. /// Get the automaton for which the map has been constructed.
const_tgba_ptr get_aut() const; const_twa_ptr get_aut() const;
/// \brief Get the number of SCC in the automaton. /// \brief Get the number of SCC in the automaton.
/// ///
@ -171,7 +171,7 @@ namespace spot
std::set<acc_cond::mark_t> useful_acc; std::set<acc_cond::mark_t> useful_acc;
}; };
const_tgba_ptr aut_; // Automata to decompose. const_twa_ptr aut_; // Automata to decompose.
typedef std::list<scc> stack_type; typedef std::list<scc> stack_type;
stack_type root_; // Stack of SCC roots. stack_type root_; // Stack of SCC roots.
std::stack<acc_cond::mark_t> arc_acc_; // A stack of acceptance conditions std::stack<acc_cond::mark_t> arc_acc_; // A stack of acceptance conditions
@ -203,7 +203,7 @@ namespace spot
}; };
SPOT_API std::ostream& SPOT_API std::ostream&
dump_scc_dot(const const_tgba_ptr& a, dump_scc_dot(const const_twa_ptr& a,
std::ostream& out, bool verbose = false); std::ostream& out, bool verbose = false);
SPOT_API std::ostream& SPOT_API std::ostream&
dump_scc_dot(const scc_map& m, std::ostream& out, bool verbose = false); dump_scc_dot(const scc_map& m, std::ostream& out, bool verbose = false);

8
src/tgbaalgos/se05.cc
View file

@ -54,7 +54,7 @@ namespace spot
/// ///
/// \pre The automaton \a a must have at most one acceptance /// \pre The automaton \a a must have at most one acceptance
/// condition (i.e. it is a TBA). /// condition (i.e. it is a TBA).
se05_search(const const_tgba_ptr a, size_t size, se05_search(const const_twa_ptr a, size_t size,
option_map o = option_map()) option_map o = option_map())
: emptiness_check(a, o), : emptiness_check(a, o),
h(size) h(size)
@ -676,20 +676,20 @@ namespace spot
} // anonymous } // anonymous
emptiness_check_ptr emptiness_check_ptr
explicit_se05_search(const const_tgba_ptr& a, option_map o) explicit_se05_search(const const_twa_ptr& a, option_map o)
{ {
return std::make_shared<se05_search<explicit_se05_search_heap>>(a, 0, o); return std::make_shared<se05_search<explicit_se05_search_heap>>(a, 0, o);
} }
emptiness_check_ptr emptiness_check_ptr
bit_state_hashing_se05_search(const const_tgba_ptr& a, bit_state_hashing_se05_search(const const_twa_ptr& a,
size_t size, option_map o) size_t size, option_map o)
{ {
return std::make_shared<se05_search<bsh_se05_search_heap>>(a, size, o); return std::make_shared<se05_search<bsh_se05_search_heap>>(a, size, o);
} }
emptiness_check_ptr emptiness_check_ptr
se05(const const_tgba_ptr& a, option_map o) se05(const const_twa_ptr& a, option_map o)
{ {
size_t size = o.get("bsh"); size_t size = o.get("bsh");
if (size) if (size)

6
src/tgbaalgos/se05.hh
View file

@ -101,7 +101,7 @@ namespace spot
/// \sa spot::explicit_magic_search /// \sa spot::explicit_magic_search
/// ///
SPOT_API emptiness_check_ptr SPOT_API emptiness_check_ptr
explicit_se05_search(const const_tgba_ptr& a, option_map o = option_map()); explicit_se05_search(const const_twa_ptr& a, option_map o = option_map());
/// \brief Returns an emptiness checker on the spot::tgba automaton \a a. /// \brief Returns an emptiness checker on the spot::tgba automaton \a a.
/// ///
@ -131,7 +131,7 @@ namespace spot
/// \sa spot::explicit_se05_search /// \sa spot::explicit_se05_search
/// ///
SPOT_API emptiness_check_ptr SPOT_API emptiness_check_ptr
bit_state_hashing_se05_search(const const_tgba_ptr& a, size_t size, bit_state_hashing_se05_search(const const_twa_ptr& a, size_t size,
option_map o = option_map()); option_map o = option_map());
@ -142,7 +142,7 @@ namespace spot
/// in the \c option_map. If \c "bsh" is set and non null, its value /// in the \c option_map. If \c "bsh" is set and non null, its value
/// is used as the size of the hash map. /// is used as the size of the hash map.
SPOT_API emptiness_check_ptr SPOT_API emptiness_check_ptr
se05(const const_tgba_ptr& a, option_map o); se05(const const_twa_ptr& a, option_map o);
/// @} /// @}
} }

8
src/tgbaalgos/stats.cc
View file

@ -36,7 +36,7 @@ namespace spot
class stats_bfs: public tgba_reachable_iterator_breadth_first class stats_bfs: public tgba_reachable_iterator_breadth_first
{ {
public: public:
stats_bfs(const const_tgba_ptr& a, tgba_statistics& s) stats_bfs(const const_twa_ptr& a, tgba_statistics& s)
: tgba_reachable_iterator_breadth_first(a), s_(s) : tgba_reachable_iterator_breadth_first(a), s_(s)
{ {
} }
@ -61,7 +61,7 @@ namespace spot
class sub_stats_bfs: public stats_bfs class sub_stats_bfs: public stats_bfs
{ {
public: public:
sub_stats_bfs(const const_tgba_ptr& a, tgba_sub_statistics& s) sub_stats_bfs(const const_twa_ptr& a, tgba_sub_statistics& s)
: stats_bfs(a, s), s_(s), seen_(bddtrue) : stats_bfs(a, s), s_(s), seen_(bddtrue)
{ {
} }
@ -118,7 +118,7 @@ namespace spot
} }
tgba_statistics tgba_statistics
stats_reachable(const const_tgba_ptr& g) stats_reachable(const const_twa_ptr& g)
{ {
tgba_statistics s; tgba_statistics s;
stats_bfs d(g, s); stats_bfs d(g, s);
@ -127,7 +127,7 @@ namespace spot
} }
tgba_sub_statistics tgba_sub_statistics
sub_stats_reachable(const const_tgba_ptr& g) sub_stats_reachable(const const_twa_ptr& g)
{ {
tgba_sub_statistics s; tgba_sub_statistics s;
sub_stats_bfs d(g, s); sub_stats_bfs d(g, s);

4
src/tgbaalgos/stats.hh
View file

@ -50,9 +50,9 @@ namespace spot
}; };
/// \brief Compute statistics for an automaton. /// \brief Compute statistics for an automaton.
SPOT_API tgba_statistics stats_reachable(const const_tgba_ptr& g); SPOT_API tgba_statistics stats_reachable(const const_twa_ptr& g);
/// \brief Compute subended statistics for an automaton. /// \brief Compute subended statistics for an automaton.
SPOT_API tgba_sub_statistics sub_stats_reachable(const const_tgba_ptr& g); SPOT_API tgba_sub_statistics sub_stats_reachable(const const_twa_ptr& g);
class SPOT_API printable_formula: public printable_value<const ltl::formula*> class SPOT_API printable_formula: public printable_value<const ltl::formula*>

6
src/tgbaalgos/stutter.cc
View file

@ -206,7 +206,7 @@ namespace spot
class tgbasl final : public twa class tgbasl final : public twa
{ {
public: public:
tgbasl(const const_tgba_ptr& a, bdd atomic_propositions) tgbasl(const const_twa_ptr& a, bdd atomic_propositions)
: twa(a->get_dict()), a_(a), aps_(atomic_propositions) : twa(a->get_dict()), a_(a), aps_(atomic_propositions)
{ {
get_dict()->register_all_propositions_of(&a_, this); get_dict()->register_all_propositions_of(&a_, this);
@ -249,13 +249,13 @@ namespace spot
} }
private: private:
const_tgba_ptr a_; const_twa_ptr a_;
bdd aps_; bdd aps_;
}; };
typedef std::shared_ptr<tgbasl> tgbasl_ptr; typedef std::shared_ptr<tgbasl> tgbasl_ptr;
inline tgbasl_ptr make_tgbasl(const const_tgba_ptr& aut, bdd ap) inline tgbasl_ptr make_tgbasl(const const_twa_ptr& aut, bdd ap)
{ {
return std::make_shared<tgbasl>(aut, ap); return std::make_shared<tgbasl>(aut, ap);
} }

4
src/tgbaalgos/tau03.cc
View file

@ -54,7 +54,7 @@ namespace spot
{ {
public: public:
/// \brief Initialize the search algorithm on the automaton \a a /// \brief Initialize the search algorithm on the automaton \a a
tau03_search(const const_tgba_ptr a, size_t size, option_map o) tau03_search(const const_twa_ptr a, size_t size, option_map o)
: emptiness_check(a, o), : emptiness_check(a, o),
h(size) h(size)
{ {
@ -376,7 +376,7 @@ namespace spot
} // anonymous } // anonymous
emptiness_check_ptr emptiness_check_ptr
explicit_tau03_search(const const_tgba_ptr& a, option_map o) explicit_tau03_search(const const_twa_ptr& a, option_map o)
{ {
return std::make_shared<tau03_search<explicit_tau03_search_heap>>(a, 0, o); return std::make_shared<tau03_search<explicit_tau03_search_heap>>(a, 0, o);
} }

2
src/tgbaalgos/tau03.hh
View file

@ -95,7 +95,7 @@ namespace spot
\endverbatim */ \endverbatim */
/// ///
SPOT_API emptiness_check_ptr SPOT_API emptiness_check_ptr
explicit_tau03_search(const const_tgba_ptr& a, option_map o = option_map()); explicit_tau03_search(const const_twa_ptr& a, option_map o = option_map());
/// @} /// @}
} }

4
src/tgbaalgos/tau03opt.cc
View file

@ -65,7 +65,7 @@ namespace spot
{ {
public: public:
/// \brief Initialize the search algorithm on the automaton \a a /// \brief Initialize the search algorithm on the automaton \a a
tau03_opt_search(const const_tgba_ptr& a, size_t size, option_map o) tau03_opt_search(const const_twa_ptr& a, size_t size, option_map o)
: emptiness_check(a, o), : emptiness_check(a, o),
current_weight(a->acc()), current_weight(a->acc()),
h(size), h(size),
@ -562,7 +562,7 @@ namespace spot
} // anonymous } // anonymous
emptiness_check_ptr emptiness_check_ptr
explicit_tau03_opt_search(const const_tgba_ptr& a, option_map o) explicit_tau03_opt_search(const const_twa_ptr& a, option_map o)
{ {
return return
std::make_shared<tau03_opt_search<explicit_tau03_opt_search_heap>>(a, std::make_shared<tau03_opt_search<explicit_tau03_opt_search_heap>>(a,

2
src/tgbaalgos/tau03opt.hh
View file

@ -97,7 +97,7 @@ namespace spot
/// state of this stack. /// state of this stack.
/// ///
SPOT_API emptiness_check_ptr SPOT_API emptiness_check_ptr
explicit_tau03_opt_search(const const_tgba_ptr& a, explicit_tau03_opt_search(const const_twa_ptr& a,
option_map o = option_map()); option_map o = option_map());
/// @} /// @}

2
src/tgbatest/checkta.cc
View file

@ -51,7 +51,7 @@ void stats(std::string title, const spot::ta_ptr& ta)
<< std::setw(6) << s.acceptance_states << '\n'; << std::setw(6) << s.acceptance_states << '\n';
} }
void stats(std::string title, const spot::tgba_ptr& tg) void stats(std::string title, const spot::twa_ptr& tg)
{ {
auto s = stats_reachable(tg); auto s = stats_reachable(tg);

4
src/tgbatest/complementation.cc
View file

@ -127,7 +127,7 @@ int main(int argc, char* argv[])
return 2; return 2;
spot::twa_graph_ptr a = h->aut; spot::twa_graph_ptr a = h->aut;
spot::tgba_ptr complement = 0; spot::twa_ptr complement = 0;
complement = spot::make_safra_complement(a); complement = spot::make_safra_complement(a);
@ -155,7 +155,7 @@ int main(int argc, char* argv[])
return 2; return 2;
auto a = spot::ltl_to_tgba_fm(f1, dict); auto a = spot::ltl_to_tgba_fm(f1, dict);
spot::tgba_ptr complement = 0; spot::twa_ptr complement = 0;
complement = spot::make_safra_complement(a); complement = spot::make_safra_complement(a);
spot::dotty_reachable(std::cout, complement); spot::dotty_reachable(std::cout, complement);

2
src/tgbatest/emptchk.cc
View file

@ -98,7 +98,7 @@ main(int argc, char** argv)
auto d = spot::make_bdd_dict(); auto d = spot::make_bdd_dict();
// Build many different automata from this formula. // Build many different automata from this formula.
spot::const_tgba_ptr aut[4]; spot::const_twa_ptr aut[4];
{ {
auto a = spot::ltl_to_taa(f, d); auto a = spot::ltl_to_taa(f, d);
aut[0] = a; aut[0] = a;

6
src/tgbatest/ltl2tgba.cc
View file

@ -309,7 +309,7 @@ to_int(const char* s)
return res; return res;
} }
spot::twa_graph_ptr ensure_digraph(const spot::tgba_ptr& a) spot::twa_graph_ptr ensure_digraph(const spot::twa_ptr& a)
{ {
auto aa = std::dynamic_pointer_cast<spot::twa_graph>(a); auto aa = std::dynamic_pointer_cast<spot::twa_graph>(a);
if (aa) if (aa)
@ -371,7 +371,7 @@ checked_main(int argc, char** argv)
const char* hoa_opt = nullptr; const char* hoa_opt = nullptr;
auto& env = spot::ltl::default_environment::instance(); auto& env = spot::ltl::default_environment::instance();
spot::ltl::atomic_prop_set* unobservables = 0; spot::ltl::atomic_prop_set* unobservables = 0;
spot::tgba_ptr system_aut = 0; spot::twa_ptr system_aut = 0;
auto dict = spot::make_bdd_dict(); auto dict = spot::make_bdd_dict();
spot::timer_map tm; spot::timer_map tm;
bool use_timer = false; bool use_timer = false;
@ -960,7 +960,7 @@ checked_main(int argc, char** argv)
if (f || from_file) if (f || from_file)
{ {
spot::tgba_ptr a = 0; spot::twa_ptr a = 0;
bool assume_sba = false; bool assume_sba = false;
if (from_file) if (from_file)

2
wrap/python/spot_impl.i
View file

@ -376,7 +376,7 @@ empty_hoa_parse_error_list()
} }
spot::twa_graph_ptr spot::twa_graph_ptr
ensure_digraph(const spot::tgba_ptr& a) ensure_digraph(const spot::twa_ptr& a)
{ {
auto aa = std::dynamic_pointer_cast<spot::twa_graph>(a); auto aa = std::dynamic_pointer_cast<spot::twa_graph>(a);
if (aa) if (aa)