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

* iface/gspn/eesrg.cc, iface/gspn/eesrg.hh, iface/gspn/gspn.cc,

Browse source 
iface/gspn/gspn.hh, src/tgba/bdddict.cc, src/tgba/bdddict.hh,
src/tgba/bddprint.hh, src/tgba/succiter.hh,
src/tgba/succiterconcrete.cc, src/tgba/succiterconcrete.hh,
src/tgba/tgba.hh, src/tgba/tgbabddconcrete.cc,
src/tgba/tgbabddconcrete.hh, src/tgba/tgbabddconcretefactory.cc,
src/tgba/tgbabddconcretefactory.hh, src/tgba/tgbabddcoredata.cc,
src/tgba/tgbabddcoredata.hh, src/tgba/tgbaexplicit.cc,
src/tgba/tgbaexplicit.hh, src/tgba/tgbaproduct.cc,
src/tgba/tgbaproduct.hh, src/tgba/tgbatba.cc, src/tgba/tgbatba.hh,
src/tgbaalgos/dotty.cc, src/tgbaalgos/dupexp.cc,
src/tgbaalgos/emptinesscheck.cc, src/tgbaalgos/emptinesscheck.hh,
src/tgbaalgos/lbtt.cc, src/tgbaalgos/lbtt.hh,
src/tgbaalgos/ltl2tgba_fm.cc, src/tgbaalgos/ltl2tgba_lacim.cc,
src/tgbaalgos/save.cc, src/tgbatest/explicit.cc,
src/tgbatest/ltl2tgba.cc, src/tgbaparse/tgbaparse.yy,
wrap/python/tests/ltl2tgba.py:
Rewrite `accepting condition' as `acceptance condition'.
The symbols which have been renamed are:
tgba::all_accepting_conditions
tgba::neg_accepting_conditions
succ_iterator::current_accepting_conditions
bdd_dict::register_accepting_variable
bdd_dict::register_accepting_variables
bdd_dict::is_registered_accepting_variable
tgba_bdd_concrete_factory::declare_accepting_condition
tgba_bdd_core_data::accepting_conditions
tgba_bdd_core_data::all_accepting_conditions
tgba_explicit::declare_accepting_condition
tgba_explicit::complement_all_accepting_conditions
tgba_explicit::has_accepting_condition
tgba_explicit::get_accepting_condition
tgba_explicit::add_accepting_condition
tgba_explicit::all_accepting_conditions
tgba_explicit::neg_accepting_conditions
state_tba_proxy::acceptance_cond
accepting_cond_splitter
This commit is contained in:
Alexandre Duret-Lutz 2003-11-28 16:34:42 +00:00
parent 334ae6e757
commit e341cc9ab6
37 changed files with 312 additions and 272 deletions
Download patch file Download diff file Expand all files Collapse all files

40
ChangeLog
View file

@ -1,3 +1,43 @@
2003-11-28 Alexandre Duret-Lutz <adl@src.lip6.fr>
* iface/gspn/eesrg.cc, iface/gspn/eesrg.hh, iface/gspn/gspn.cc,
iface/gspn/gspn.hh, src/tgba/bdddict.cc, src/tgba/bdddict.hh,
src/tgba/bddprint.hh, src/tgba/succiter.hh,
src/tgba/succiterconcrete.cc, src/tgba/succiterconcrete.hh,
src/tgba/tgba.hh, src/tgba/tgbabddconcrete.cc,
src/tgba/tgbabddconcrete.hh, src/tgba/tgbabddconcretefactory.cc,
src/tgba/tgbabddconcretefactory.hh, src/tgba/tgbabddcoredata.cc,
src/tgba/tgbabddcoredata.hh, src/tgba/tgbaexplicit.cc,
src/tgba/tgbaexplicit.hh, src/tgba/tgbaproduct.cc,
src/tgba/tgbaproduct.hh, src/tgba/tgbatba.cc, src/tgba/tgbatba.hh,
src/tgbaalgos/dotty.cc, src/tgbaalgos/dupexp.cc,
src/tgbaalgos/emptinesscheck.cc, src/tgbaalgos/emptinesscheck.hh,
src/tgbaalgos/lbtt.cc, src/tgbaalgos/lbtt.hh,
src/tgbaalgos/ltl2tgba_fm.cc, src/tgbaalgos/ltl2tgba_lacim.cc,
src/tgbaalgos/save.cc, src/tgbatest/explicit.cc,
src/tgbatest/ltl2tgba.cc, src/tgbaparse/tgbaparse.yy,
wrap/python/tests/ltl2tgba.py:
Rewrite `accepting condition' as `acceptance condition'.
The symbols which have been renamed are:
tgba::all_accepting_conditions
tgba::neg_accepting_conditions
succ_iterator::current_accepting_conditions
bdd_dict::register_accepting_variable
bdd_dict::register_accepting_variables
bdd_dict::is_registered_accepting_variable
tgba_bdd_concrete_factory::declare_accepting_condition
tgba_bdd_core_data::accepting_conditions
tgba_bdd_core_data::all_accepting_conditions
tgba_explicit::declare_accepting_condition
tgba_explicit::complement_all_accepting_conditions
tgba_explicit::has_accepting_condition
tgba_explicit::get_accepting_condition
tgba_explicit::add_accepting_condition
tgba_explicit::all_accepting_conditions
tgba_explicit::neg_accepting_conditions
state_tba_proxy::acceptance_cond
accepting_cond_splitter
2003-11-26 Alexandre Duret-Lutz <adl@src.lip6.fr>
* src/tgbaalgos/ltl2tgba_fm.cc (ltl_trad_visitor::visit) <G>:

12
iface/gspn/eesrg.cc
View file

@ -319,11 +319,11 @@ namespace spot
}
virtual bdd
current_accepting_conditions() const
current_acceptance_conditions() const
{
// There is no acceptance conditions in GSPN systems, so we just
// return those from OPERAND_.
return operand_->current_accepting_conditions();
return operand_->current_acceptance_conditions();
}
private:
State state_;
@ -457,16 +457,16 @@ namespace spot
}
bdd
tgba_gspn_eesrg::all_accepting_conditions() const
tgba_gspn_eesrg::all_acceptance_conditions() const
{
// There is no accepting conditions in GSPN systems.
// There is no acceptance conditions in GSPN systems.
return bddfalse;
}
bdd
tgba_gspn_eesrg::neg_accepting_conditions() const
tgba_gspn_eesrg::neg_acceptance_conditions() const
{
// There is no accepting conditions in GSPN systems.
// There is no acceptance conditions in GSPN systems.
return bddtrue;
}

4
iface/gspn/eesrg.hh
View file

@ -60,8 +60,8 @@ namespace spot
const tgba* global_automaton = 0) const;
virtual bdd_dict* get_dict() const;
virtual std::string format_state(const state* state) const;
virtual bdd all_accepting_conditions() const;
virtual bdd neg_accepting_conditions() const;
virtual bdd all_acceptance_conditions() const;
virtual bdd neg_acceptance_conditions() const;
protected:
virtual bdd compute_support_conditions(const spot::state* state) const;
virtual bdd compute_support_variables(const spot::state* state) const;

12
iface/gspn/gspn.cc
View file

@ -259,9 +259,9 @@ namespace spot
}
virtual bdd
current_accepting_conditions() const
current_acceptance_conditions() const
{
// There is no accepting conditions in GSPN systems.
// There is no acceptance conditions in GSPN systems.
return bddfalse;
}
private:
@ -393,16 +393,16 @@ namespace spot
}
bdd
tgba_gspn::all_accepting_conditions() const
tgba_gspn::all_acceptance_conditions() const
{
// There is no accepting conditions in GSPN systems.
// There is no acceptance conditions in GSPN systems.
return bddfalse;
}
bdd
tgba_gspn::neg_accepting_conditions() const
tgba_gspn::neg_acceptance_conditions() const
{
// There is no accepting conditions in GSPN systems.
// There is no acceptance conditions in GSPN systems.
return bddtrue;
}

4
iface/gspn/gspn.hh
View file

@ -59,8 +59,8 @@ namespace spot
const tgba* global_automaton = 0) const;
virtual bdd_dict* get_dict() const;
virtual std::string format_state(const state* state) const;
virtual bdd all_accepting_conditions() const;
virtual bdd neg_accepting_conditions() const;
virtual bdd all_acceptance_conditions() const;
virtual bdd neg_acceptance_conditions() const;
protected:
virtual bdd compute_support_conditions(const spot::state* state) const;
virtual bdd compute_support_variables(const spot::state* state) const;

12
src/tgba/bdddict.cc
View file

@ -102,11 +102,11 @@ namespace spot
}
int
bdd_dict::register_accepting_variable(const ltl::formula* f,
bdd_dict::register_acceptance_variable(const ltl::formula* f,
const void* for_me)
{
int num;
// Do not build an accepting variable that already exists.
// Do not build an acceptance variable that already exists.
fv_map::iterator sii = acc_map.find(f);
if (sii != acc_map.end())
{
@ -124,7 +124,7 @@ namespace spot
}
void
bdd_dict::register_accepting_variables(bdd f, const void* for_me)
bdd_dict::register_acceptance_variables(bdd f, const void* for_me)
{
if (f == bddtrue || f == bddfalse)
return;
@ -133,8 +133,8 @@ namespace spot
assert(i != acc_formula_map.end());
var_refs[i->first].insert(for_me);
register_accepting_variables(bdd_high(f), for_me);
register_accepting_variables(bdd_low(f), for_me);
register_acceptance_variables(bdd_high(f), for_me);
register_acceptance_variables(bdd_low(f), for_me);
}
@ -231,7 +231,7 @@ namespace spot
}
bool
bdd_dict::is_registered_accepting_variable(const ltl::formula* f,
bdd_dict::is_registered_acceptance_variable(const ltl::formula* f,
const void* by_me)
{
fv_map::iterator fi = acc_map.find(f);

20
src/tgba/bdddict.hh
View file

@ -51,8 +51,8 @@ namespace spot
vf_map now_formula_map; ///< Maps "Now" BDD variables to formulae
fv_map var_map; ///< Maps atomic propositions to BDD variables
vf_map var_formula_map; ///< Maps BDD variables to atomic propositions
fv_map acc_map; ///< Maps accepting conditions to BDD variables
vf_map acc_formula_map; ///< Maps BDD variables to accepting conditions
fv_map acc_map; ///< Maps acceptance conditions to BDD variables
vf_map acc_formula_map; ///< Maps BDD variables to acceptance conditions
/// \brief Map Next variables to Now variables.
///
@ -100,23 +100,23 @@ namespace spot
/// \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
/// acceptance 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);
int register_acceptance_variable(const ltl::formula* f, const void* for_me);
/// \brief Register BDD variables as accepting variables.
/// \brief Register BDD variables as acceptance variables.
///
/// Register all variables occurring in \a f as accepting variables
/// used by \a for_me. This assumes that these accepting variables
/// Register all variables occurring in \a f as acceptance variables
/// used by \a for_me. This assumes that these acceptance variables
/// are already known from the dictionary (i.e., they have already
/// been registered by register_accepting_variable() for another
/// been registered by register_acceptance_variable() for another
/// automaton).
void register_accepting_variables(bdd f, const void* for_me);
void register_acceptance_variables(bdd f, const void* for_me);
/// \brief Duplicate the variable usage of another object.
///
@ -135,7 +135,7 @@ namespace spot
/// Check whether formula \a f has already been registered by \a by_me.
bool is_registered_proposition(const ltl::formula* f, const void* by_me);
bool is_registered_state(const ltl::formula* f, const void* by_me);
bool is_registered_accepting_variable(const ltl::formula* f,
bool is_registered_acceptance_variable(const ltl::formula* f,
const void* by_me);
/// @}

4
src/tgba/bddprint.hh
View file

@ -47,7 +47,7 @@ namespace spot
/// \return The BDD formated as a string.
std::string bdd_format_sat(const bdd_dict* dict, bdd b);
/// \brief Print a BDD as a list of accepting conditions.
/// \brief Print a BDD as a list of acceptance conditions.
///
/// This is used when saving a TGBA.
/// \param os The output stream.
@ -57,7 +57,7 @@ namespace spot
std::ostream& bdd_print_acc(std::ostream& os,
const bdd_dict* dict, bdd b);
/// \brief Print a BDD as a set of accepting conditions.
/// \brief Print a BDD as a set of acceptance conditions.
///
/// This is used when saving a TGBA.
/// \param os The output stream.

6
src/tgba/succiter.hh
View file

@ -32,7 +32,7 @@ namespace spot
/// This class provides the basic functionalities required to
/// iterate over the successors of a state, as well as querying
/// transition labels. Because transitions are never explicitely
/// encoded, labels (conditions and accepting conditions) can only
/// encoded, labels (conditions and acceptance conditions) can only
/// be queried while iterating over the successors.
class tgba_succ_iterator
{
@ -90,9 +90,9 @@ namespace spot
///
/// This is a boolean function of atomic propositions.
virtual bdd current_condition() const = 0;
/// \brief Get the accepting conditions on the transition leading
/// \brief Get the acceptance conditions on the transition leading
/// to this successor.
virtual bdd current_accepting_conditions() const = 0;
virtual bdd current_acceptance_conditions() const = 0;
//@}
};

26
src/tgba/succiterconcrete.cc
View file

@ -70,10 +70,10 @@ namespace spot
// (a + b) & Next[a] & Next[b]
// a & b & Next[a] & !Next[b]
// Is this always correct? No! It depends on the
// accepting conditions associated to each transition.
// acceptance conditions associated to each transition.
// We cannot merge transitions which have different
// accepting conditions.
// Let's label transitions with hypothetic accepting sets:
// acceptance conditions.
// Let's label transitions with hypothetic acceptance sets:
// a & b & Next[a] & Next[b] ; Acc[1]
// !a & b & Next[a] & Next[b] ; Acc[2]
// a & !b & Next[a] & Next[b] ; Acc[2]
@ -103,17 +103,17 @@ namespace spot
// Gather all transitions going to this destination...
current_ = succ_set_left_ & dest;
// ... and compute their accepting sets.
bdd as = data_.accepting_conditions & current_;
// ... and compute their acceptance sets.
bdd as = data_.acceptance_conditions & current_;
// AS is false when no satisfaction of the current transition
// belongs to an accepting set: current_ can be used as-is.
// belongs to an acceptance set: current_ can be used as-is.
if (as != bddfalse)
{
// Otherwise, we have accepting sets, and we should
// Otherwise, we have acceptance sets, and we should
// restrict current_ to a subset sharing the same
// accepting conditions.
// same accepting set.
// acceptance conditions.
// same acceptance set.
as = bdd_exist(as, data_.nownext_set);
// as = (a | (!a)&b) & (Acc[a] | Acc[b]) + (!a & Acc[b])
@ -125,7 +125,7 @@ namespace spot
// current_acc_ = (Acc[a] | Acc[b])
assert(current_acc_ != bddfalse);
// Find other transitions included exactly in each of these
// accepting sets and are not included in other sets.
// acceptance sets and are not included in other sets.
// Consider
// !p.!Acc[g].Acc[f] + p.!Acc[g].Acc[f] + p.Acc[g].!Acc[f]
// if current_acc_ = !Acc[g].Acc[f] we
@ -133,11 +133,11 @@ namespace spot
// belongs to !Acc[g].Acc[f] + Acc[g].!Acc[f], not
// only !Acc[g].Acc[f].
// So, first, filter out all transitions like p, which
// are also in other accepting sets.
// are also in other acceptance sets.
bdd fout = bdd_relprod(as, !current_acc_, data_.acc_set);
bdd as_fout = as - fout;
// Then, pick the remaining term that are exactly in all
// required accepting sets.
// required acceptance sets.
bdd all = bddtrue;
bdd acc = current_acc_;
do
@ -188,7 +188,7 @@ namespace spot
}
bdd
tgba_succ_iterator_concrete::current_accepting_conditions() const
tgba_succ_iterator_concrete::current_acceptance_conditions() const
{
assert(!done());
return current_acc_;

8
src/tgba/succiterconcrete.hh
View file

@ -35,13 +35,13 @@ namespace spot
/// \brief Build a spot::tgba_succ_iterator_concrete.
///
/// \param successors The set of successors with ingoing
/// conditions and accepting conditions, represented as a BDD.
/// conditions and acceptance conditions, represented as a BDD.
/// The job of this iterator will be to enumerate the
/// satisfactions of that BDD and split them into destination
/// states and conditions, and compute accepting conditions.
/// states and conditions, and compute acceptance conditions.
/// \param d The core data of the automata.
/// These contains sets of variables useful to split a BDD, and
/// compute accepting conditions.
/// compute acceptance conditions.
tgba_succ_iterator_concrete(const tgba_bdd_core_data& d, bdd successors);
virtual ~tgba_succ_iterator_concrete();
@ -53,7 +53,7 @@ namespace spot
// inspection
state_bdd* current_state() const;
bdd current_condition() const;
bdd current_accepting_conditions() const;
bdd current_acceptance_conditions() const;
private:
const tgba_bdd_core_data& data_; ///< Core data of the automaton.

14
src/tgba/tgba.hh
View file

@ -37,7 +37,7 @@ namespace spot
///
/// TGBAs are transition-based, meanings their labels are put
/// on arcs, not on nodes. They use Generalized Büchi acceptance
/// conditions: there are several accepting sets (of
/// conditions: there are several acceptance sets (of
/// transitions), and a path can be accepted only if it traverse
/// at least one transition of each set infinitely often.
///
@ -153,7 +153,7 @@ namespace spot
/// deleted by the caller.
virtual state* project_state(const state* s, const tgba* t) const;
/// \brief Return the set of all accepting conditions used
/// \brief Return the set of all acceptance conditions used
/// by this automaton.
///
/// The goal of the emptiness check is to ensure that
@ -161,19 +161,19 @@ namespace spot
/// of these acceptiong conditions. I.e., the union
/// of the acceptiong conditions of all transition in
/// the SCC should be equal to the result of this function.
virtual bdd all_accepting_conditions() const = 0;
virtual bdd all_acceptance_conditions() const = 0;
/// \brief Return the conjuction of all negated accepting
/// \brief Return the conjuction of all negated acceptance
/// variables.
///
/// For instance if the automaton uses variables <tt>Acc[a]</tt>,
/// <tt>Acc[b]</tt> and <tt>Acc[c]</tt> to describe accepting sets,
/// <tt>Acc[b]</tt> and <tt>Acc[c]</tt> to describe acceptance sets,
/// this function should return <tt>!Acc[a]\&!Acc[b]\&!Acc[c]</tt>.
///
/// This is useful when making products: each operand's condition
/// set should be augmented with the neg_accepting_conditions() of
/// set should be augmented with the neg_acceptance_conditions() of
/// the other operand.
virtual bdd neg_accepting_conditions() const = 0;
virtual bdd neg_acceptance_conditions() const = 0;
protected:
/// Do the actual computation of tgba::support_conditions().

6
src/tgba/tgbabddconcrete.cc
View file

@ -147,13 +147,13 @@ namespace spot
}
bdd
tgba_bdd_concrete::all_accepting_conditions() const
tgba_bdd_concrete::all_acceptance_conditions() const
{
return data_.all_accepting_conditions;
return data_.all_acceptance_conditions;
}
bdd
tgba_bdd_concrete::neg_accepting_conditions() const
tgba_bdd_concrete::neg_acceptance_conditions() const
{
return data_.negacc_set;
}

4
src/tgba/tgbabddconcrete.hh
View file

@ -76,8 +76,8 @@ namespace spot
/// rules, etc.
const tgba_bdd_core_data& get_core_data() const;
virtual bdd all_accepting_conditions() const;
virtual bdd neg_accepting_conditions() const;
virtual bdd all_acceptance_conditions() const;
virtual bdd neg_acceptance_conditions() const;
protected:
virtual bdd compute_support_conditions(const state* state) const;

22
src/tgba/tgbabddconcretefactory.cc
View file

@ -58,7 +58,7 @@ namespace spot
}
void
tgba_bdd_concrete_factory::declare_accepting_condition(bdd b,
tgba_bdd_concrete_factory::declare_acceptance_condition(bdd b,
const ltl::formula* a)
{
// Maintain a conjunction of BDDs associated to A. We will latter
@ -82,27 +82,27 @@ namespace spot
acc_map_::iterator ai;
for (ai = acc_.begin(); ai != acc_.end(); ++ai)
{
// Register a BDD variable for this accepting condition.
int num = get_dict()->register_accepting_variable(ai->first, this);
// Keep track of all accepting conditions for easy
// Register a BDD variable for this acceptance condition.
int num = get_dict()->register_acceptance_variable(ai->first, this);
// Keep track of all acceptance conditions for easy
// existential quantification.
data_.declare_accepting_condition(bdd_ithvar(num));
data_.declare_acceptance_condition(bdd_ithvar(num));
}
for (ai = acc_.begin(); ai != acc_.end(); ++ai)
{
bdd acc = bdd_ithvar(get_dict()->acc_map[ai->first]);
// Complete acc with all the other accepting conditions negated.
// Complete acc with all the other acceptance conditions negated.
acc &= bdd_exist(data_.negacc_set, acc);
// Any state matching the BDD formulae registered is part
// of this accepting set.
data_.accepting_conditions |= ai->second & acc;
// of this acceptance set.
data_.acceptance_conditions |= ai->second & acc;
// Keep track of all accepting conditions, so that we can
// easily check whether a transition satisfies all accepting
// Keep track of all acceptance conditions, so that we can
// easily check whether a transition satisfies all acceptance
// conditions.
data_.all_accepting_conditions |= acc;
data_.all_acceptance_conditions |= acc;
}
// Any constraint between Now variables also exist between Next

14
src/tgba/tgbabddconcretefactory.hh
View file

@ -56,18 +56,18 @@ namespace spot
/// can be turned into BDD using ithvar().
int create_atomic_prop(const ltl::formula* f);
/// Declare an accepting condition.
/// Declare an acceptance condition.
///
/// Formula such as 'f U g' or 'F g' make the promise
/// that 'g' will be fulfilled eventually. So once
/// one of this formula has been translated into a BDD,
/// we use declare_accepting_condition() to associate
/// all other states to the accepting set of 'g'.
/// we use declare_acceptance_condition() to associate
/// all other states to the acceptance set of 'g'.
///
/// \param b a BDD indicating which variables are in the
/// accepting set
/// acceptance set
/// \param a the formula associated
void declare_accepting_condition(bdd b, const ltl::formula* a);
void declare_acceptance_condition(bdd b, const ltl::formula* a);
const tgba_bdd_core_data& get_core_data() const;
bdd_dict* get_dict() const;
@ -78,7 +78,7 @@ namespace spot
/// \brief Perfom final computations before the relation can be used.
///
/// This function should be called after all propositions, state,
/// accepting conditions, and constraints have been declared, and
/// acceptance conditions, and constraints have been declared, and
/// before calling get_code_data() or get_dict().
void finish();
@ -87,7 +87,7 @@ namespace spot
typedef Sgi::hash_map<const ltl::formula*, bdd,
ptr_hash<ltl::formula> > acc_map_;
acc_map_ acc_; ///< BDD associated to each accepting condition
acc_map_ acc_; ///< BDD associated to each acceptance condition
};
}

18
src/tgba/tgbabddcoredata.cc
View file

@ -26,8 +26,8 @@ namespace spot
{
tgba_bdd_core_data::tgba_bdd_core_data(bdd_dict* dict)
: relation(bddtrue),
accepting_conditions(bddfalse),
all_accepting_conditions(bddfalse),
acceptance_conditions(bddfalse),
all_acceptance_conditions(bddfalse),
now_set(bddtrue),
next_set(bddtrue),
nownext_set(bddtrue),
@ -45,8 +45,8 @@ namespace spot
tgba_bdd_core_data::tgba_bdd_core_data(const tgba_bdd_core_data& copy)
: relation(copy.relation),
accepting_conditions(copy.accepting_conditions),
all_accepting_conditions(copy.all_accepting_conditions),
acceptance_conditions(copy.acceptance_conditions),
all_acceptance_conditions(copy.all_acceptance_conditions),
now_set(copy.now_set),
next_set(copy.next_set),
nownext_set(copy.nownext_set),
@ -66,10 +66,10 @@ namespace spot
tgba_bdd_core_data::tgba_bdd_core_data(const tgba_bdd_core_data& left,
const tgba_bdd_core_data& right)
: relation(left.relation & right.relation),
accepting_conditions(left.accepting_conditions
| right.accepting_conditions),
all_accepting_conditions(left.all_accepting_conditions
| right.all_accepting_conditions),
acceptance_conditions(left.acceptance_conditions
| right.acceptance_conditions),
all_acceptance_conditions(left.all_acceptance_conditions
| right.all_acceptance_conditions),
now_set(left.now_set & right.now_set),
next_set(left.next_set & right.next_set),
nownext_set(left.nownext_set & right.nownext_set),
@ -122,7 +122,7 @@ namespace spot
}
void
tgba_bdd_core_data::declare_accepting_condition(bdd acc)
tgba_bdd_core_data::declare_acceptance_condition(bdd acc)
{
notnow_set &= acc;
notnext_set &= acc;

30
src/tgba/tgbabddcoredata.hh
View file

@ -39,21 +39,21 @@ namespace spot
/// to the next state
bdd relation;
/// \brief encodes the accepting conditions
/// \brief encodes the acceptance conditions
///
/// <tt>a U b</tt>, or <tt>F b</tt>, both imply that \c b should
/// be verified eventually. We encode this with generalized Büchi
/// acceptating conditions. An accepting set, called
/// acceptating conditions. An acceptance set, called
/// <tt>Acc[b]</tt>, hold all the state that do not promise to
/// verify \c b eventually. (I.e., all the states that contain \c
/// b, or do not contain <tt>a U b</tt>, or <tt>F b</tt>.)
///
/// The spot::succ_iter::current_accepting_conditions() method
/// will return the \c Acc[x] variables of the accepting sets
/// The spot::succ_iter::current_acceptance_conditions() method
/// will return the \c Acc[x] variables of the acceptance sets
/// in which a transition is. Actually we never return \c Acc[x]
/// alone, but \c Acc[x] and all other accepting variables negated.
/// alone, but \c Acc[x] and all other acceptance variables negated.
///
/// So if there is three accepting set \c a, \c b, and \c c, and a
/// So if there is three acceptance set \c a, \c b, and \c c, and a
/// transition is in set \c a, we'll return <tt>
/// Acc[a]&!Acc[b]&!Acc[c]</tt>. If the transition is in both \c
/// a and \c b, we'll return <tt>(Acc[a]\&!Acc[b]\&!Acc[c]) \c | \c
@ -66,22 +66,22 @@ namespace spot
/// check for `b' and have a destination of the form <tt>a U b</tt>,
/// or <tt>F b</tt>.
///
/// To summarize, \c accepting_conditions contains three kinds of
/// To summarize, \c acceptance_conditions contains three kinds of
/// variables:
/// \li "Next" variables, that encode the destination state,
/// \li atomic propositions, which are things to verify before going on
/// to the next state,
/// \li "Acc" variables.
bdd accepting_conditions;
bdd acceptance_conditions;
/// \brief The set of all accepting conditions used by the Automaton.
/// \brief The set of all acceptance conditions used by the Automaton.
///
/// The goal of the emptiness check is to ensure that
/// a strongly connected component walks through each
/// of these acceptiong conditions. I.e., the union
/// of the acceptiong conditions of all transition in
/// the SCC should be equal to the result of this function.
bdd all_accepting_conditions;
bdd all_acceptance_conditions;
/// The conjunction of all Now variables, in their positive form.
bdd now_set;
@ -105,12 +105,12 @@ namespace spot
/// and atomic propositions.
bdd varandnext_set;
/// \brief The (positive) conjunction of all variables which are
/// accepting conditions.
/// acceptance conditions.
bdd acc_set;
/// \brief The (positive) conjunction of all variables which are not
/// accepting conditions.
/// acceptance conditions.
bdd notacc_set;
/// \brief The negative conjunction of all variables which are accepting
/// \brief The negative conjunction of all variables which are acceptance
/// conditions.
bdd negacc_set;
@ -139,9 +139,9 @@ namespace spot
/// \brief Update the variable sets to take a new automic proposition into
/// account.
void declare_atomic_prop(bdd var);
/// \brief Update the variable sets to take a new accepting condition
/// \brief Update the variable sets to take a new acceptance condition
/// into account.
void declare_accepting_condition(bdd prom);
void declare_acceptance_condition(bdd prom);
};
}

76
src/tgba/tgbaexplicit.cc
View file

@ -34,7 +34,7 @@ namespace spot
tgba_explicit_succ_iterator::tgba_explicit_succ_iterator
(const tgba_explicit::state* s, bdd all_acc)
: s_(s), all_accepting_conditions_(all_acc)
: s_(s), all_acceptance_conditions_(all_acc)
{
}
@ -69,9 +69,9 @@ namespace spot
}
bdd
tgba_explicit_succ_iterator::current_accepting_conditions() const
tgba_explicit_succ_iterator::current_acceptance_conditions() const
{
return (*i_)->accepting_conditions & all_accepting_conditions_;
return (*i_)->acceptance_conditions & all_acceptance_conditions_;
}
@ -110,9 +110,9 @@ namespace spot
tgba_explicit::tgba_explicit(bdd_dict* dict)
: dict_(dict), init_(0), all_accepting_conditions_(bddfalse),
neg_accepting_conditions_(bddtrue),
all_accepting_conditions_computed_(false)
: dict_(dict), init_(0), all_acceptance_conditions_(bddfalse),
neg_acceptance_conditions_(bddtrue),
all_acceptance_conditions_computed_(false)
{
}
@ -166,7 +166,7 @@ namespace spot
transition* t = new transition;
t->dest = d;
t->condition = bddtrue;
t->accepting_conditions = bddfalse;
t->acceptance_conditions = bddfalse;
s->push_back(t);
return t;
}
@ -201,12 +201,12 @@ namespace spot
}
void
tgba_explicit::declare_accepting_condition(const ltl::formula* f)
tgba_explicit::declare_acceptance_condition(const ltl::formula* f)
{
int v = dict_->register_accepting_variable(f, this);
int v = dict_->register_acceptance_variable(f, this);
ltl::destroy(f);
bdd neg = bdd_nithvar(v);
neg_accepting_conditions_ &= neg;
neg_acceptance_conditions_ &= neg;
// Append neg to all acceptance conditions.
ns_map::iterator i;
@ -214,35 +214,35 @@ namespace spot
{
tgba_explicit::state::iterator i2;
for (i2 = i->second->begin(); i2 != i->second->end(); ++i2)
(*i2)->accepting_conditions &= neg;
(*i2)->acceptance_conditions &= neg;
}
all_accepting_conditions_computed_ = false;
all_acceptance_conditions_computed_ = false;
}
void
tgba_explicit::complement_all_accepting_conditions()
tgba_explicit::complement_all_acceptance_conditions()
{
bdd all = all_accepting_conditions();
bdd all = all_acceptance_conditions();
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)
{
(*i2)->accepting_conditions = all - (*i2)->accepting_conditions;
(*i2)->acceptance_conditions = all - (*i2)->acceptance_conditions;
}
}
}
bool
tgba_explicit::has_accepting_condition(const ltl::formula* f) const
tgba_explicit::has_acceptance_condition(const ltl::formula* f) const
{
return dict_->is_registered_accepting_variable(f, this);
return dict_->is_registered_acceptance_variable(f, this);
}
bdd
tgba_explicit::get_accepting_condition(const ltl::formula* f)
tgba_explicit::get_acceptance_condition(const ltl::formula* f)
{
const ltl::constant* c = dynamic_cast<const ltl::constant*>(f);
if (c)
@ -258,34 +258,34 @@ namespace spot
assert(0);
}
bdd_dict::fv_map::iterator i = dict_->acc_map.find(f);
assert(has_accepting_condition(f));
assert(has_acceptance_condition(f));
/* If this second assert fails and the first doesn't,
things are badly broken. This has already happened. */
assert(i != dict_->acc_map.end());
ltl::destroy(f);
bdd v = bdd_ithvar(i->second);
v &= bdd_exist(neg_accepting_conditions_, v);
v &= bdd_exist(neg_acceptance_conditions_, v);
return v;
}
void
tgba_explicit::add_accepting_condition(transition* t, const ltl::formula* f)
tgba_explicit::add_acceptance_condition(transition* t, const ltl::formula* f)
{
bdd c = get_accepting_condition(f);
t->accepting_conditions |= c;
bdd c = get_acceptance_condition(f);
t->acceptance_conditions |= c;
}
void
tgba_explicit::add_accepting_conditions(transition* t, bdd f)
tgba_explicit::add_acceptance_conditions(transition* t, bdd f)
{
bdd sup = bdd_support(f);
dict_->register_accepting_variables(sup, this);
dict_->register_acceptance_variables(sup, this);
while (sup != bddtrue)
{
neg_accepting_conditions_ &= bdd_nithvar(bdd_var(sup));
neg_acceptance_conditions_ &= bdd_nithvar(bdd_var(sup));
sup = bdd_high(sup);
}
t->accepting_conditions |= f;
t->acceptance_conditions |= f;
}
state*
@ -307,7 +307,7 @@ namespace spot
(void) global_state;
(void) global_automaton;
return new tgba_explicit_succ_iterator(s->get_state(),
all_accepting_conditions());
all_acceptance_conditions());
}
bdd
@ -355,38 +355,38 @@ namespace spot
}
bdd
tgba_explicit::all_accepting_conditions() const
tgba_explicit::all_acceptance_conditions() const
{
if (!all_accepting_conditions_computed_)
if (!all_acceptance_conditions_computed_)
{
bdd all = bddfalse;
// Build all_accepting_conditions_ from neg_accepting_conditions_
// Build all_acceptance_conditions_ from neg_acceptance_conditions_
// I.e., transform !A & !B & !C into
// A & !B & !C
// + !A & B & !C
// + !A & !B & C
bdd cur = neg_accepting_conditions_;
bdd cur = neg_acceptance_conditions_;
while (cur != bddtrue)
{
assert(cur != bddfalse);
bdd v = bdd_ithvar(bdd_var(cur));
all |= v & bdd_exist(neg_accepting_conditions_, v);
all |= v & bdd_exist(neg_acceptance_conditions_, v);
assert(bdd_high(cur) != bddtrue);
cur = bdd_low(cur);
}
all_accepting_conditions_ = all;
all_accepting_conditions_computed_ = true;
all_acceptance_conditions_ = all;
all_acceptance_conditions_computed_ = true;
}
return all_accepting_conditions_;
return all_acceptance_conditions_;
}
bdd
tgba_explicit::neg_accepting_conditions() const
tgba_explicit::neg_acceptance_conditions() const
{
return neg_accepting_conditions_;
return neg_acceptance_conditions_;
}
}

30
src/tgba/tgbaexplicit.hh
View file

@ -46,7 +46,7 @@ namespace spot
struct transition
{
bdd condition;
bdd accepting_conditions;
bdd acceptance_conditions;
state* dest;
};
@ -59,12 +59,12 @@ namespace spot
void add_neg_condition(transition* t, const ltl::formula* f);
/// This assumes that all variables in \a f are known from dict.
void add_conditions(transition* t, bdd f);
void declare_accepting_condition(const ltl::formula* f);
bool has_accepting_condition(const ltl::formula* f) const;
void add_accepting_condition(transition* t, const ltl::formula* f);
/// This assumes that all accepting conditions in \a f are known from dict.
void add_accepting_conditions(transition* t, bdd f);
void complement_all_accepting_conditions();
void declare_acceptance_condition(const ltl::formula* f);
bool has_acceptance_condition(const ltl::formula* f) const;
void add_acceptance_condition(transition* t, const ltl::formula* f);
/// This assumes that all acceptance conditions in \a f are known from dict.
void add_acceptance_conditions(transition* t, bdd f);
void complement_all_acceptance_conditions();
// tgba interface
virtual ~tgba_explicit();
@ -76,8 +76,8 @@ namespace spot
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;
virtual bdd all_acceptance_conditions() const;
virtual bdd neg_acceptance_conditions() const;
protected:
virtual bdd compute_support_conditions(const spot::state* state) const;
@ -85,7 +85,7 @@ namespace spot
state* add_state(const std::string& name);
bdd get_condition(const ltl::formula* f);
bdd get_accepting_condition(const ltl::formula* f);
bdd get_acceptance_condition(const ltl::formula* f);
typedef Sgi::hash_map<const std::string, tgba_explicit::state*,
string_hash> ns_map;
@ -95,9 +95,9 @@ namespace spot
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_;
mutable bdd all_acceptance_conditions_;
bdd neg_acceptance_conditions_;
mutable bool all_acceptance_conditions_computed_;
private:
// Disallow copy.
@ -146,12 +146,12 @@ namespace spot
virtual state_explicit* current_state() const;
virtual bdd current_condition() const;
virtual bdd current_accepting_conditions() const;
virtual bdd current_acceptance_conditions() const;
private:
const tgba_explicit::state* s_;
tgba_explicit::state::const_iterator i_;
bdd all_accepting_conditions_;
bdd all_acceptance_conditions_;
};
}

24
src/tgba/tgbaproduct.cc
View file

@ -162,10 +162,10 @@ namespace spot
return current_cond_;
}
bdd tgba_succ_iterator_product::current_accepting_conditions() const
bdd tgba_succ_iterator_product::current_acceptance_conditions() const
{
return ((left_->current_accepting_conditions() & right_neg_)
| (right_->current_accepting_conditions() & left_neg_));
return ((left_->current_acceptance_conditions() & right_neg_)
| (right_->current_acceptance_conditions() & left_neg_));
}
////////////////////////////////////////////////////////////
@ -176,16 +176,16 @@ namespace spot
{
assert(dict_ == right->get_dict());
bdd lna = left_->neg_accepting_conditions();
bdd rna = right_->neg_accepting_conditions();
bdd lna = left_->neg_acceptance_conditions();
bdd rna = right_->neg_acceptance_conditions();
left_acc_complement_ = bdd_exist(lna, bdd_support(rna));
right_acc_complement_ = bdd_exist(rna, bdd_support(lna));
all_accepting_conditions_ = ((left_->all_accepting_conditions()
all_acceptance_conditions_ = ((left_->all_acceptance_conditions()
& right_acc_complement_)
| (right_->all_accepting_conditions()
| (right_->all_acceptance_conditions()
& left_acc_complement_));
neg_accepting_conditions_ = lna & rna;
neg_acceptance_conditions_ = lna & rna;
dict_->register_all_variables_of(&left_, this);
dict_->register_all_variables_of(&right_, this);
@ -279,15 +279,15 @@ namespace spot
}
bdd
tgba_product::all_accepting_conditions() const
tgba_product::all_acceptance_conditions() const
{
return all_accepting_conditions_;
return all_acceptance_conditions_;
}
bdd
tgba_product::neg_accepting_conditions() const
tgba_product::neg_acceptance_conditions() const
{
return neg_accepting_conditions_;
return neg_acceptance_conditions_;
}
}

10
src/tgba/tgbaproduct.hh
View file

@ -91,7 +91,7 @@ namespace spot
// inspection
state_product* current_state() const;
bdd current_condition() const;
bdd current_accepting_conditions() const;
bdd current_acceptance_conditions() const;
private:
//@{
@ -133,8 +133,8 @@ namespace spot
virtual state* project_state(const state* s, const tgba* t) const;
virtual bdd all_accepting_conditions() const;
virtual bdd neg_accepting_conditions() const;
virtual bdd all_acceptance_conditions() const;
virtual bdd neg_acceptance_conditions() const;
protected:
virtual bdd compute_support_conditions(const state* state) const;
@ -146,8 +146,8 @@ namespace spot
const tgba* right_;
bdd left_acc_complement_;
bdd right_acc_complement_;
bdd all_accepting_conditions_;
bdd neg_accepting_conditions_;
bdd all_acceptance_conditions_;
bdd neg_acceptance_conditions_;
// Disallow copy.
tgba_product(const tgba_product&);
tgba_product& tgba_product::operator=(const tgba_product&);

54
src/tgba/tgbatba.cc
View file

@ -30,7 +30,7 @@ namespace spot
/// \brief A state for spot::tgba_tba_proxy.
///
/// This state is in fact a pair of state: the state from the tgba
/// automaton, and the "counter" (we use the accepting set
/// automaton, and the "counter" (we use the acceptance set
/// BDD variable instead of an integer counter).
class state_tba_proxy : public state
{
@ -44,7 +44,7 @@ namespace spot
state_tba_proxy(const state_tba_proxy& o)
: state(),
s_(o.real_state()->clone()),
acc_(o.accepting_cond())
acc_(o.acceptance_cond())
{
}
@ -61,7 +61,7 @@ namespace spot
}
bdd
accepting_cond() const
acceptance_cond() const
{
return acc_;
}
@ -74,14 +74,14 @@ namespace spot
int res = s_->compare(o->real_state());
if (res != 0)
return res;
return acc_.id() - o->accepting_cond().id();
return acc_.id() - o->acceptance_cond().id();
}
virtual size_t
hash() const
{
// We expect to have many more state than accepting conditions.
// Hence we keep only 8 bits for accepting conditions.
// We expect to have many more state than acceptance conditions.
// Hence we keep only 8 bits for acceptance conditions.
return (s_->hash() << 8) + (acc_.id() & 0xFF);
}
@ -103,9 +103,9 @@ namespace spot
public:
tgba_tba_proxy_succ_iterator(tgba_succ_iterator* it,
bdd acc, bdd next_acc,
bdd the_accepting_cond)
bdd the_acceptance_cond)
: it_(it), acc_(acc), next_acc_(next_acc),
the_accepting_cond_(the_accepting_cond)
the_acceptance_cond_(the_acceptance_cond)
{
}
@ -142,10 +142,10 @@ namespace spot
{
state* s = it_->current_state();
bdd acc;
// Transition in the ACC_ accepting set should be directed
// to the NEXT_ACC_ accepting set.
// Transition in the ACC_ acceptance set should be directed
// to the NEXT_ACC_ acceptance set.
if (acc_ == bddtrue
|| (acc_ & it_->current_accepting_conditions()) == acc_)
|| (acc_ & it_->current_acceptance_conditions()) == acc_)
acc = next_acc_;
else
acc = acc_;
@ -159,31 +159,31 @@ namespace spot
}
bdd
current_accepting_conditions() const
current_acceptance_conditions() const
{
return the_accepting_cond_;
return the_acceptance_cond_;
}
protected:
tgba_succ_iterator* it_;
bdd acc_;
bdd next_acc_;
bdd the_accepting_cond_;
bdd the_acceptance_cond_;
};
tgba_tba_proxy::tgba_tba_proxy(const tgba* a)
: a_(a)
{
bdd all = a_->all_accepting_conditions();
bdd all = a_->all_acceptance_conditions();
// We will use one accepting condition for this automata.
// We will use one acceptance condition for this automata.
// Let's call it Acc[True].
int v = get_dict()
->register_accepting_variable(ltl::constant::true_instance(), this);
the_accepting_cond_ = bdd_ithvar(v);
->register_acceptance_variable(ltl::constant::true_instance(), this);
the_acceptance_cond_ = bdd_ithvar(v);
// Now build the "cycle" of accepting conditions.
// Now build the "cycle" of acceptance conditions.
bdd last = bdd_satone(all);
all -= last;
@ -225,13 +225,13 @@ namespace spot
tgba_succ_iterator* it = a_->succ_iter(s->real_state(),
global_state, global_automaton);
bdd acc = s->accepting_cond();
bdd acc = s->acceptance_cond();
cycle_map::const_iterator i = acc_cycle_.find(acc);
assert(i != acc_cycle_.end());
return
new tgba_tba_proxy_succ_iterator(it, acc, i->second,
(acc == bddtrue)
? the_accepting_cond_ : bddfalse);
? the_acceptance_cond_ : bddfalse);
}
bdd_dict*
@ -246,7 +246,7 @@ namespace spot
const state_tba_proxy* s = dynamic_cast<const state_tba_proxy*>(state);
assert(s);
return a_->format_state(s->real_state()) + "("
+ bdd_format_set(get_dict(), s->accepting_cond()) + ")";
+ bdd_format_set(get_dict(), s->acceptance_cond()) + ")";
}
state*
@ -261,15 +261,15 @@ namespace spot
bdd
tgba_tba_proxy::all_accepting_conditions() const
tgba_tba_proxy::all_acceptance_conditions() const
{
return the_accepting_cond_;
return the_acceptance_cond_;
}
bdd
tgba_tba_proxy::neg_accepting_conditions() const
tgba_tba_proxy::neg_acceptance_conditions() const
{
return !the_accepting_cond_;
return !the_acceptance_cond_;
}
bool
@ -278,7 +278,7 @@ namespace spot
const state_tba_proxy* s =
dynamic_cast<const state_tba_proxy*>(state);
assert(s);
return bddtrue == s->accepting_cond();
return bddtrue == s->acceptance_cond();
}
bdd

10
src/tgba/tgbatba.hh
View file

@ -35,14 +35,14 @@ namespace spot
/// be degeneralized on the fly.
///
/// This automaton is a spot::tgba, but it will always have exactly
/// one accepting condition.
/// one acceptance condition.
///
/// The degeneralization is done by synchronizing the input
/// automaton with a "counter" automaton such as the one shown in
/// "On-the-fly Verification of Linear Temporal Logic" (Jean-Michel
/// Couveur, FME99).
///
/// If the input automaton uses N accepting conditions, the output
/// If the input automaton uses N acceptance conditions, the output
/// automaton can have at most max(N,1)+1 times more states and
/// transitions.
class tgba_tba_proxy : public tgba
@ -65,8 +65,8 @@ namespace spot
virtual state* project_state(const state* s, const tgba* t) const;
virtual bdd all_accepting_conditions() const;
virtual bdd neg_accepting_conditions() const;
virtual bdd all_acceptance_conditions() const;
virtual bdd neg_acceptance_conditions() const;
bool state_is_accepting(const state* state) const;
@ -78,7 +78,7 @@ namespace spot
const tgba* a_;
typedef std::map<bdd, bdd, bdd_less_than> cycle_map;
cycle_map acc_cycle_;
bdd the_accepting_cond_;
bdd the_acceptance_cond_;
// Disallow copy.
tgba_tba_proxy(const tgba_tba_proxy&);
tgba_tba_proxy& tgba_tba_proxy::operator=(const tgba_tba_proxy&);

2
src/tgbaalgos/dotty.cc
View file

@ -63,7 +63,7 @@ namespace spot
bdd_print_formula(os_, automata_->get_dict(),
si->current_condition()) << "\\n";
bdd_print_accset(os_, automata_->get_dict(),
si->current_accepting_conditions()) << "\"]"
si->current_acceptance_conditions()) << "\"]"
<< std::endl;
}

2
src/tgbaalgos/dupexp.cc
View file

@ -84,7 +84,7 @@ namespace spot {
tgba_explicit::transition* t =
out_->create_transition(name_[in], name_[out]);
out_->add_conditions(t, si->current_condition());
out_->add_accepting_conditions(t, si->current_accepting_conditions());
out_->add_acceptance_conditions(t, si->current_acceptance_conditions());
}
private:

8
src/tgbaalgos/emptinesscheck.cc
View file

@ -181,7 +181,7 @@ namespace spot
// (destination state, acceptance conditions of the arc)
// we are interested in...
const state* dest = succ->current_state();
bdd acc = succ->current_accepting_conditions();
bdd acc = succ->current_acceptance_conditions();
// ... and point the iterator to the next successor, for
// the next iteration.
succ->next();
@ -242,7 +242,7 @@ namespace spot
// Accumulate all acceptance conditions into the merged SCC.
root.top().condition |= acc;
if (root.top().condition == aut_->all_accepting_conditions())
if (root.top().condition == aut_->all_acceptance_conditions())
{
// We have found an accepting SCC.
// Release all iterators in TODO.
@ -559,7 +559,7 @@ namespace spot
}
dest = h_filt(dest);
bdd acc = iter->current_accepting_conditions() | todo.top().acc;
bdd acc = iter->current_acceptance_conditions() | todo.top().acc;
path.push_back(state_proposition(dest, iter->current_condition()));
// Advance iterator for next step.
@ -604,7 +604,7 @@ namespace spot
// acceptance conditions of acc_restrict.
//
// FIXME: It would be better to count the number
// of accepting conditions.
// of acceptance conditions.
if (bddtrue != (best_acc_restrict >> acc_restrict))
continue;
}

4
src/tgbaalgos/emptinesscheck.hh
View file

@ -80,7 +80,7 @@ namespace spot
connected_component(int index = -1);
int index;
/// The bdd condition is the union of all accepting condition of
/// The bdd condition is the union of all acceptance conditions of
/// transitions which connect the states of the connected component.
bdd condition;
};
@ -121,7 +121,7 @@ namespace spot
void remove_component(const state* start_delete);
/// Called by counter_example to find a path which traverses all
/// accepting conditions in the accepted SCC.
/// acceptance conditions in the accepted SCC.
void accepting_path (const connected_component_set& scc,
const state* start, bdd acc_to_traverse);

36
src/tgbaalgos/lbtt.cc
View file

@ -34,14 +34,14 @@
namespace spot
{
// At some point we'll need to print an accepting set into LBTT's
// format. LBTT expects numbered accepting sets, so first we'll
// number each accepting condition, and latter when we have to print
// At some point we'll need to print an acceptance set into LBTT's
// format. LBTT expects numbered acceptance sets, so first we'll
// number each acceptance condition, and latter when we have to print
// them we'll just have to look up each of them.
class accepting_cond_splitter
class acceptance_cond_splitter
{
public:
accepting_cond_splitter(bdd all_acc)
acceptance_cond_splitter(bdd all_acc)
{
unsigned count = 0;
while (all_acc != bddfalse)
@ -105,7 +105,7 @@ namespace spot
}
// Each state in the produced automata corresponds to
// a (state, accepting set) pair for the source automata.
// a (state, acceptance set) pair for the source automata.
typedef std::pair<state*, bdd> state_acc_pair;
@ -128,7 +128,7 @@ namespace spot
bool
operator()(const state_acc_pair& that) const
{
// We assume there will be far more states than accepting conditions.
// We assume there will be far more states than acceptance conditions.
// Hence we keep only 8 bits for the latter.
return (that.first->hash() << 8) + (that.second.id() & 0xFF);
}
@ -173,18 +173,18 @@ namespace spot
return;
}
// Browse the successors of STATE to gather accepting
// Browse the successors of STATE to gather acceptance
// conditions of outgoing transitions.
bdd_set acc_seen;
tgba_succ_iterator* si = g->succ_iter(state);
for (si->first(); !si->done(); si->next())
{
acc_seen.insert(si->current_accepting_conditions());
acc_seen.insert(si->current_acceptance_conditions());
}
// Order the creation of the supplementary initial state if needed.
// Use bddtrue as accepting condition because it cannot conflict
// with other (state, accepting cond) pairs in the maps.
// Use bddtrue as acceptance condition because it cannot conflict
// with other (state, acceptance cond) pairs in the maps.
if (init && acc_seen.size() > 1)
{
state_acc_pair p(state, bddtrue);
@ -219,7 +219,7 @@ namespace spot
fill_todo(todo, seen, acp_seen,
g->get_init_state(), g, mmp, state_number, true);
accepting_cond_splitter acs(g->all_accepting_conditions());
acceptance_cond_splitter acs(g->all_acceptance_conditions());
while(! todo.empty())
{
@ -227,12 +227,12 @@ namespace spot
todo.erase(todo.begin());
unsigned number = acp_seen[sap];
// number == 0 is the initial state. bddtrue as an accepting
// number == 0 is the initial state. bddtrue as an acceptance
// conditions indicates a "fake" initial state introduced
// because the original initial state was split into many
// states (with different accepting conditions).
// states (with different acceptance conditions).
// As this "fake" state has no input transitions, there is
// no point in computing any accepting conditions.
// no point in computing any acceptance conditions.
body << number << (number ? " 0 " : " 1 ");
if (sap.second != bddtrue)
acs.split(body, sap.second);
@ -241,12 +241,12 @@ namespace spot
tgba_succ_iterator* si = g->succ_iter(sap.first);
for (si->first(); !si->done(); si->next())
{
// We have put the accepting conditions on the state,
// so draw only outgoing transition with these accepting
// We have put the acceptance conditions on the state,
// so draw only outgoing transition with these acceptance
// conditions.
if (sap.second != bddtrue
&& si->current_accepting_conditions() != sap.second)
&& si->current_acceptance_conditions() != sap.second)
continue;
minmax_pair destrange;

8
src/tgbaalgos/lbtt.hh
View file

@ -31,17 +31,17 @@ namespace spot
///
/// Note that LBTT expects an automaton with transition
/// labeled by propositional formulae, and generalized
/// Büchi accepting conditions on \b states. This
/// Büchi acceptance conditions on \b states. This
/// is unlike our spot::tgba automata which put
/// both generalized accepting conditions and propositional
/// both generalized acceptance conditions and propositional
/// formulae) on \b transitions.
///
/// This algorithm will therefore produce an automata where
/// accepting conditions have been moved from each transition to
/// acceptance conditions have been moved from each transition to
/// previous state. In the worst case, doing so will multiply the
/// number of states and transitions of the automata by
/// <code>2^|Acc|</code>. where <code>|Acc|</code> is the number of
/// accepting conditions used by the automata. (It can be a bit
/// acceptance conditions used by the automata. (It can be a bit
/// more because LBTT allows only for one initial state:
/// lbtt_reachable() may also have to create an additional state in
/// case the source initial state had to be split.) You have been

14
src/tgbaalgos/ltl2tgba_fm.cc
View file

@ -112,7 +112,7 @@ namespace spot
register_a_variable(const formula* f)
{
int num;
// Do not build an accepting variable that already exists.
// Do not build an acceptance variable that already exists.
fv_map::iterator sii = a_map.find(f);
if (sii != a_map.end())
{
@ -243,16 +243,16 @@ namespace spot
bdd high = bdd_high(b);
if (high == bddfalse)
{
// Simply ignore negated accepting variables.
// Simply ignore negated acceptance variables.
b = bdd_low(b);
}
else
{
formula* ac = var_to_formula(var);
if (! a->has_accepting_condition(ac))
a->declare_accepting_condition(clone(ac));
a->add_accepting_condition(t, ac);
if (! a->has_acceptance_condition(ac))
a->declare_acceptance_condition(clone(ac));
a->add_acceptance_condition(t, ac);
atomic_prop::instance_count();
b = high;
@ -501,8 +501,8 @@ namespace spot
i != formulae_seen.end(); ++i)
destroy(*i);
// Turn all promises into real accepting conditions.
a->complement_all_accepting_conditions();
// Turn all promises into real acceptance conditions.
a->complement_all_acceptance_conditions();
return a;
}

10
src/tgbaalgos/ltl2tgba_lacim.cc
View file

@ -98,12 +98,12 @@ namespace spot
/*
`x | next', doesn't actually encode the fact that x
should be fulfilled eventually. We ensure this by
creating a new generalized Büchi accepting set, Acc[x],
creating a new generalized Büchi acceptance set, Acc[x],
and leave out of this set any transition going off NOW
without checking X. Such accepting conditions are
without checking X. Such acceptance conditions are
checked for during the emptiness check.
*/
fact_.declare_accepting_condition(x | !now, node->child());
fact_.declare_acceptance_condition(x | !now, node->child());
res_ = now;
return;
}
@ -181,10 +181,10 @@ namespace spot
/*
The rightmost conjunction, f1 & next, doesn't actually
encode the fact that f2 should be fulfilled eventually.
We declare an accepting condition for this purpose (see
We declare an acceptance condition for this purpose (see
the comment in the unop::F case).
*/
fact_.declare_accepting_condition(f2 | !now, node->second());
fact_.declare_acceptance_condition(f2 | !now, node->second());
res_ = now;
return;
}

4
src/tgbaalgos/save.cc
View file

@ -42,7 +42,7 @@ namespace spot
const bdd_dict* d = automata_->get_dict();
os_ << "acc =";
bdd acc = automata_->all_accepting_conditions();
bdd acc = automata_->all_acceptance_conditions();
while (acc != bddfalse)
{
bdd cube = bdd_satone(acc);
@ -79,7 +79,7 @@ namespace spot
os_ << "\"" << cur << "\", \""
<< automata_->format_state(dest) << "\", \"";
bdd_print_formula(os_, d, si->current_condition()) << "\",";
bdd_print_acc(os_, d, si->current_accepting_conditions());
bdd_print_acc(os_, d, si->current_acceptance_conditions());
os_ << ";" << std::endl;
}
}

12
src/tgbaparse/tgbaparse.yy
View file

@ -64,9 +64,9 @@ typedef std::pair<bool, spot::ltl::formula*> pair;
%token ACC_DEF
%%
tgba: accepting_decl lines | lines;
tgba: acceptance_decl lines | lines;
accepting_decl: ACC_DEF acc_decl ';'
acceptance_decl: ACC_DEF acc_decl ';'
/* At least one line. */
lines: line
@ -85,7 +85,7 @@ line: strident ',' strident ',' cond_list ',' acc_list ';'
result->add_condition(t, i->second);
std::list<formula*>::iterator i2;
for (i2 = $7->begin(); i2 != $7->end(); ++i2)
result->add_accepting_condition(t, *i2);
result->add_acceptance_condition(t, *i2);
delete $1;
delete $3;
delete $5;
@ -152,10 +152,10 @@ acc_list:
else if (*$2 != "" && *$2 != "false")
{
formula* f = parse_environment.require(*$2);
if (! result->has_accepting_condition(f))
if (! result->has_acceptance_condition(f))
{
error_list.push_back(spot::tgba_parse_error(@2,
"undeclared accepting condition"));
"undeclared acceptance condition"));
destroy(f);
delete $2;
YYERROR;
@ -172,7 +172,7 @@ acc_decl:
| acc_decl strident
{
formula* f = parse_environment.require(*$2);
result->declare_accepting_condition(f);
result->declare_acceptance_condition(f);
delete $2;
}
;

12
src/tgbatest/explicit.cc
View file

@ -22,12 +22,12 @@ main()
a->add_condition(t2, e.require("a"));
a->add_condition(t3, e.require("b"));
a->add_condition(t3, e.require("c"));
a->declare_accepting_condition(e.require("p"));
a->declare_accepting_condition(e.require("q"));
a->declare_accepting_condition(e.require("r"));
a->add_accepting_condition(t1, e.require("p"));
a->add_accepting_condition(t1, e.require("q"));
a->add_accepting_condition(t2, e.require("r"));
a->declare_acceptance_condition(e.require("p"));
a->declare_acceptance_condition(e.require("q"));
a->declare_acceptance_condition(e.require("r"));
a->add_acceptance_condition(t1, e.require("p"));
a->add_acceptance_condition(t1, e.require("q"));
a->add_acceptance_condition(t2, e.require("r"));
spot::dotty_reachable(std::cout, a);

6
src/tgbatest/ltl2tgba.cc
View file

@ -24,7 +24,7 @@ syntax(char* prog)
<< " "<< prog << " -X [OPTIONS...] file" << std::endl
<< std::endl
<< "Options:" << std::endl
<< " -a display the accepting_conditions BDD, not the "
<< " -a display the acceptance_conditions BDD, not the "
<< "reachability graph"
<< std::endl
<< " -A same as -a, but as a set" << std::endl
@ -262,7 +262,7 @@ main(int argc, char** argv)
if (concrete)
spot::bdd_print_dot(std::cout, concrete->get_dict(),
concrete->
get_core_data().accepting_conditions);
get_core_data().acceptance_conditions);
break;
case 3:
if (concrete)
@ -273,7 +273,7 @@ main(int argc, char** argv)
if (concrete)
spot::bdd_print_set(std::cout, concrete->get_dict(),
concrete->
get_core_data().accepting_conditions);
get_core_data().acceptance_conditions);
break;
case 5:
a->get_dict()->dump(std::cout);

6
wrap/python/tests/ltl2tgba.py
View file

@ -31,7 +31,7 @@ def usage(prog):
print "Usage: ", prog, """ [OPTIONS...] formula
Options:
-a display the accepting_conditions BDD, not the reachability graph
-a display the acceptance_conditions BDD, not the reachability graph
-A same as -a, but as a set
-d turn on traces during parsing
-D degeneralize the automaton
@ -115,7 +115,7 @@ if f:
elif output == 2:
if concrete:
spot.bdd_print_dot(cout, concrete.get_dict(),
concrete.get_core_data().accepting_conditions)
concrete.get_core_data().acceptance_conditions)
elif output == 3:
if concrete:
spot.bdd_print_set(cout, concrete.get_dict(),
@ -124,7 +124,7 @@ if f:
elif output == 4:
if concrete:
spot.bdd_print_set(cout, concrete.get_dict(),
concrete.get_core_data().accepting_conditions)
concrete.get_core_data().acceptance_conditions)
print
elif output == 5:
a.get_dict().dump(cout)