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

Homogenize passing of automata as pointers, not references.

Browse source 
Disallow copy for security.

* src/tgba/tgbabddconcrete.hh (tgba_bdd_concrete): Disallow copy.
* src/tgba/tgbaexplicit.hh (tgba_explicit): Likewise.
* src/tgba/tgbaexplicit.cc (tgba_explicit::operator=,
tgba_explicit::tgba_explicit(tgba_explicit)): Remove.
* src/tgba/tgbabddconcreteproduct.cc
(tgba_bdd_concrete_product_factory::tgba_bdd_concrete_product_factory,
product): Take operand automata as pointers.
* src/tgba/tgbabddconcreteproduct.hh (product): Likewise.
* src/tgba/tgbaproduct.cc, src/tgba/tgbaproduct.hh:
(tgba_product): Disallow copy.
(tgba_product::tgba_product): Take operand automata as pointers.
* src/tgbaalgos/dotty.cc (dotty_state, dotty_rec, dotty_reachable):
Take tgba arguments as pointer.
* src/tgbaalgos/dotty.hh (dotty_reachable): Likewise.
* src/tgbaalgos/lbtt.cc (fill_todo, lbtt_reachable): Likewise.
* src/tgbaalgos/lbtt.hh (lbtt_reachable): Likewise.
* src/tgbaalgos/ltl2tgba.cc, src/tgbaalgos/ltl2tgba.hh (ltl_to_tgba):
Likewise.
* src/tgbaalgos/save.cc (save_rec, tgba_save_reachable): Likewise.
* src/tgbaalgos/save.hh (save): Likewise.
* src/tgbatest/explicit.cc, src/tgbatest/explprod.cc,
src/tgbatest/ltl2tgba.cc, src/tgbatest/ltlprod.cc,
src/tgbatest/mixprod.cc, src/tgbatest/readsave.cc,
src/tgbatest/spotlbtt.cc, src/tgbatest/tgbaread.cc,
src/tgbatest/tripprod.cc: Likewise.
This commit is contained in:
Alexandre Duret-Lutz 2003-07-14 22:20:35 +00:00
parent cab3be9795
commit 66b1630c31
25 changed files with 123 additions and 104 deletions
Download patch file Download diff file Expand all files Collapse all files

31
ChangeLog
View file

@ -1,3 +1,34 @@
2003-07-15 Alexandre Duret-Lutz <aduret@src.lip6.fr>
Homogenize passing of automata as pointers, not references.
Disallow copy for security.
* src/tgba/tgbabddconcrete.hh (tgba_bdd_concrete): Disallow copy.
* src/tgba/tgbaexplicit.hh (tgba_explicit): Likewise.
* src/tgba/tgbaexplicit.cc (tgba_explicit::operator=,
tgba_explicit::tgba_explicit(tgba_explicit)): Remove.
* src/tgba/tgbabddconcreteproduct.cc
(tgba_bdd_concrete_product_factory::tgba_bdd_concrete_product_factory,
product): Take operand automata as pointers.
* src/tgba/tgbabddconcreteproduct.hh (product): Likewise.
* src/tgba/tgbaproduct.cc, src/tgba/tgbaproduct.hh:
(tgba_product): Disallow copy.
(tgba_product::tgba_product): Take operand automata as pointers.
* src/tgbaalgos/dotty.cc (dotty_state, dotty_rec, dotty_reachable):
Take tgba arguments as pointer.
* src/tgbaalgos/dotty.hh (dotty_reachable): Likewise.
* src/tgbaalgos/lbtt.cc (fill_todo, lbtt_reachable): Likewise.
* src/tgbaalgos/lbtt.hh (lbtt_reachable): Likewise.
* src/tgbaalgos/ltl2tgba.cc, src/tgbaalgos/ltl2tgba.hh (ltl_to_tgba):
Likewise.
* src/tgbaalgos/save.cc (save_rec, tgba_save_reachable): Likewise.
* src/tgbaalgos/save.hh (save): Likewise.
* src/tgbatest/explicit.cc, src/tgbatest/explprod.cc,
src/tgbatest/ltl2tgba.cc, src/tgbatest/ltlprod.cc,
src/tgbatest/mixprod.cc, src/tgbatest/readsave.cc,
src/tgbatest/spotlbtt.cc, src/tgbatest/tgbaread.cc,
src/tgbatest/tripprod.cc: Likewise.
2003-07-14 Alexandre Duret-Lutz <aduret@src.lip6.fr> 2003-07-14 Alexandre Duret-Lutz <aduret@src.lip6.fr>
Before this change, all automata would construct their own Before this change, all automata would construct their own

4
src/tgba/tgbabddconcrete.hh
View file

@ -58,6 +58,10 @@ namespace spot
protected: protected:
tgba_bdd_core_data data_; ///< Core data associated to the automaton. tgba_bdd_core_data data_; ///< Core data associated to the automaton.
bdd init_; ///< Initial state. bdd init_; ///< Initial state.
private:
// Disallow copy.
tgba_bdd_concrete(const tgba_bdd_concrete&);
tgba_bdd_concrete& tgba_bdd_concrete::operator=(const tgba_bdd_concrete&);
}; };
} }

22
src/tgba/tgbabddconcreteproduct.cc
View file

@ -11,15 +11,15 @@ namespace spot
class tgba_bdd_product_factory: public tgba_bdd_factory class tgba_bdd_product_factory: public tgba_bdd_factory
{ {
public: public:
tgba_bdd_product_factory(const tgba_bdd_concrete& left, tgba_bdd_product_factory(const tgba_bdd_concrete* left,
const tgba_bdd_concrete& right) const tgba_bdd_concrete* right)
: dict_(left.get_dict()), : dict_(left->get_dict()),
left_(left), left_(left),
right_(right), right_(right),
data_(left_.get_core_data(), right_.get_core_data()), data_(left_->get_core_data(), right_->get_core_data()),
init_(left_.get_init_bdd() & right_.get_init_bdd()) init_(left_->get_init_bdd() & right_->get_init_bdd())
{ {
assert(dict_ == right.get_dict()); assert(dict_ == right->get_dict());
} }
virtual virtual
@ -47,16 +47,16 @@ namespace spot
private: private:
bdd_dict* dict_; bdd_dict* dict_;
const tgba_bdd_concrete& left_; const tgba_bdd_concrete* left_;
const tgba_bdd_concrete& right_; const tgba_bdd_concrete* right_;
tgba_bdd_core_data data_; tgba_bdd_core_data data_;
bdd init_; bdd init_;
}; };
tgba_bdd_concrete tgba_bdd_concrete*
product(const tgba_bdd_concrete& left, const tgba_bdd_concrete& right) product(const tgba_bdd_concrete* left, const tgba_bdd_concrete* right)
{ {
tgba_bdd_product_factory p(left, right); tgba_bdd_product_factory p(left, right);
return tgba_bdd_concrete(p, p.get_init_state()); return new tgba_bdd_concrete(p, p.get_init_state());
} }
} }

4
src/tgba/tgbabddconcreteproduct.hh
View file

@ -9,8 +9,8 @@ namespace spot
/// ///
/// This function build the resulting product, as another /// This function build the resulting product, as another
/// tgba::tgba_bdd_concrete automaton. /// tgba::tgba_bdd_concrete automaton.
tgba_bdd_concrete tgba_bdd_concrete*
product(const tgba_bdd_concrete& left, const tgba_bdd_concrete& right); product(const tgba_bdd_concrete* left, const tgba_bdd_concrete* right);
} }
#endif // SPOT_TGBA_TGBABDDCONCRETEPRODUCT_HH #endif // SPOT_TGBA_TGBABDDCONCRETEPRODUCT_HH

25
src/tgba/tgbaexplicit.cc
View file

@ -87,31 +87,6 @@ namespace spot
{ {
} }
tgba_explicit::tgba_explicit(const tgba_explicit& other)
: tgba(),
name_state_map_(other.name_state_map_),
state_name_map_(other.state_name_map_),
dict_(other.dict_),
init_(other.init_),
all_accepting_conditions_(other.all_accepting_conditions_),
neg_accepting_conditions_(other.neg_accepting_conditions_),
all_accepting_conditions_computed_(other.
all_accepting_conditions_computed_)
{
dict_->register_all_variables_of(&other, this);
}
tgba_explicit&
tgba_explicit::operator=(const tgba_explicit& other)
{
if (&other != this)
{
this->~tgba_explicit();
new (this) tgba_explicit(other);
}
return *this;
}
tgba_explicit::~tgba_explicit() tgba_explicit::~tgba_explicit()
{ {
ns_map::iterator i; ns_map::iterator i;

7
src/tgba/tgbaexplicit.hh
View file

@ -17,8 +17,6 @@ namespace spot
{ {
public: public:
tgba_explicit(bdd_dict* dict); tgba_explicit(bdd_dict* dict);
tgba_explicit(const tgba_explicit& other);
tgba_explicit& tgba_explicit::operator=(const tgba_explicit& other);
struct transition; struct transition;
typedef std::list<transition*> state; typedef std::list<transition*> state;
@ -65,6 +63,11 @@ namespace spot
mutable bdd all_accepting_conditions_; mutable bdd all_accepting_conditions_;
bdd neg_accepting_conditions_; bdd neg_accepting_conditions_;
mutable bool all_accepting_conditions_computed_; mutable bool all_accepting_conditions_computed_;
private:
// Disallow copy.
tgba_explicit(const tgba_explicit& other);
tgba_explicit& tgba_explicit::operator=(const tgba_explicit& other);
}; };

6
src/tgba/tgbaproduct.cc
View file

@ -143,10 +143,10 @@ namespace spot
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
// tgba_product // tgba_product
tgba_product::tgba_product(const tgba& left, const tgba& right) tgba_product::tgba_product(const tgba* left, const tgba* right)
: dict_(left.get_dict()), left_(&left), right_(&right) : dict_(left->get_dict()), left_(left), right_(right)
{ {
assert(dict_ == right.get_dict()); assert(dict_ == right->get_dict());
all_accepting_conditions_ = ((left_->all_accepting_conditions() all_accepting_conditions_ = ((left_->all_accepting_conditions()
& right_->neg_accepting_conditions()) & right_->neg_accepting_conditions())

5
src/tgba/tgbaproduct.hh
View file

@ -94,7 +94,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.
tgba_product(const tgba& left, const tgba& right); tgba_product(const tgba* left, const tgba* right);
virtual ~tgba_product(); virtual ~tgba_product();
@ -116,6 +116,9 @@ namespace spot
const tgba* right_; const tgba* right_;
bdd all_accepting_conditions_; bdd all_accepting_conditions_;
bdd neg_accepting_conditions_; bdd neg_accepting_conditions_;
// Disallow copy.
tgba_product(const tgba_product&);
tgba_product& tgba_product::operator=(const tgba_product&);
}; };
} }

16
src/tgbaalgos/dotty.cc
View file

@ -10,7 +10,7 @@ namespace spot
/// Output and record a state. /// Output and record a state.
static bool static bool
dotty_state(std::ostream& os, dotty_state(std::ostream& os,
const tgba& g, state* st, seen_map& m, int& node) const tgba* g, state* st, seen_map& m, int& node)
{ {
seen_map::iterator i = m.find(st); seen_map::iterator i = m.find(st);
@ -25,24 +25,24 @@ namespace spot
m[st] = node; m[st] = node;
os << " " << node << " [label=\"" os << " " << node << " [label=\""
<< g.format_state(st) << "\"]" << std::endl; << g->format_state(st) << "\"]" << std::endl;
return true; return true;
} }
/// Process successors. /// Process successors.
static void static void
dotty_rec(std::ostream& os, dotty_rec(std::ostream& os,
const tgba& g, state* st, seen_map& m, int father) const tgba* g, state* st, seen_map& m, int father)
{ {
tgba_succ_iterator* si = g.succ_iter(st); tgba_succ_iterator* si = g->succ_iter(st);
for (si->first(); !si->done(); si->next()) for (si->first(); !si->done(); si->next())
{ {
int node; int node;
state* s = si->current_state(); state* s = si->current_state();
bool recurse = dotty_state(os, g, s, m, node); bool recurse = dotty_state(os, g, s, m, node);
os << " " << father << " -> " << node << " [label=\""; os << " " << father << " -> " << node << " [label=\"";
bdd_print_set(os, g.get_dict(), si->current_condition()) << "\\n"; bdd_print_set(os, g->get_dict(), si->current_condition()) << "\\n";
bdd_print_set(os, g.get_dict(), si->current_accepting_conditions()) bdd_print_set(os, g->get_dict(), si->current_accepting_conditions())
<< "\"]" << std::endl; << "\"]" << std::endl;
if (recurse) if (recurse)
{ {
@ -58,10 +58,10 @@ namespace spot
} }
std::ostream& std::ostream&
dotty_reachable(std::ostream& os, const tgba& g) dotty_reachable(std::ostream& os, const tgba* g)
{ {
seen_map m; seen_map m;
state* state = g.get_init_state(); state* state = g->get_init_state();
os << "digraph G {" << std::endl; os << "digraph G {" << std::endl;
os << " size=\"7.26,10.69\"" << std::endl; os << " size=\"7.26,10.69\"" << std::endl;
os << " 0 [label=\"\", style=invis]" << std::endl; os << " 0 [label=\"\", style=invis]" << std::endl;

2
src/tgbaalgos/dotty.hh
View file

@ -7,7 +7,7 @@
namespace spot namespace spot
{ {
/// \brief Print reachable states in dot format. /// \brief Print reachable states in dot format.
std::ostream& dotty_reachable(std::ostream& os, const tgba& g); std::ostream& dotty_reachable(std::ostream& os, const tgba* g);
} }
#endif // SPOT_TGBAALGOS_DOTTY_HH #endif // SPOT_TGBAALGOS_DOTTY_HH

14
src/tgbaalgos/lbtt.cc
View file

@ -130,7 +130,7 @@ namespace spot
// a supplementary state, to act as initial state for LBTT.) // a supplementary state, to act as initial state for LBTT.)
void void
fill_todo(todo_set& todo, seen_map& seen, acp_seen_map& acp_seen, fill_todo(todo_set& todo, seen_map& seen, acp_seen_map& acp_seen,
state* state, const tgba& g, state* state, const tgba* g,
minmax_pair& mmp, unsigned& state_number, minmax_pair& mmp, unsigned& state_number,
bool init) bool init)
{ {
@ -147,7 +147,7 @@ namespace spot
// Browse the successors of STATE to gather accepting // Browse the successors of STATE to gather accepting
// conditions of outgoing transitions. // conditions of outgoing transitions.
bdd_set acc_seen; bdd_set acc_seen;
tgba_succ_iterator* si = g.succ_iter(state); tgba_succ_iterator* si = g->succ_iter(state);
for (si->first(); !si->done(); si->next()) for (si->first(); !si->done(); si->next())
{ {
acc_seen.insert(si->current_accepting_conditions()); acc_seen.insert(si->current_accepting_conditions());
@ -176,9 +176,9 @@ namespace spot
} }
std::ostream& std::ostream&
lbtt_reachable(std::ostream& os, const tgba& g) lbtt_reachable(std::ostream& os, const tgba* g)
{ {
const bdd_dict* d = g.get_dict(); const bdd_dict* d = g->get_dict();
std::ostringstream body; std::ostringstream body;
seen_map seen; seen_map seen;
@ -189,8 +189,8 @@ namespace spot
minmax_pair mmp; minmax_pair mmp;
fill_todo(todo, seen, acp_seen, fill_todo(todo, seen, acp_seen,
g.get_init_state(), g, mmp, state_number, true); g->get_init_state(), g, mmp, state_number, true);
accepting_cond_splitter acs(g.all_accepting_conditions()); accepting_cond_splitter acs(g->all_accepting_conditions());
while(! todo.empty()) while(! todo.empty())
{ {
@ -209,7 +209,7 @@ namespace spot
acs.split(body, sap.second); acs.split(body, sap.second);
body << "-1" << std::endl; body << "-1" << std::endl;
tgba_succ_iterator* si = g.succ_iter(sap.first); tgba_succ_iterator* si = g->succ_iter(sap.first);
for (si->first(); !si->done(); si->next()) for (si->first(); !si->done(); si->next())
{ {
// We have put the accepting conditions on the state, // We have put the accepting conditions on the state,

2
src/tgbaalgos/lbtt.hh
View file

@ -28,7 +28,7 @@ namespace spot
/// ///
/// \param g The automata to print. /// \param g The automata to print.
/// \param os Where to print. /// \param os Where to print.
std::ostream& lbtt_reachable(std::ostream& os, const tgba& g); std::ostream& lbtt_reachable(std::ostream& os, const tgba* g);
} }
#endif // SPOT_TGBAALGOS_LBTT_HH #endif // SPOT_TGBAALGOS_LBTT_HH

5
src/tgbaalgos/ltl2tgba.cc
View file

@ -230,7 +230,7 @@ namespace spot
bool root_; bool root_;
}; };
tgba_bdd_concrete tgba_bdd_concrete*
ltl_to_tgba(const ltl::formula* f, bdd_dict* dict) ltl_to_tgba(const ltl::formula* f, bdd_dict* dict)
{ {
// Normalize the formula. We want all the negations on // Normalize the formula. We want all the negations on
@ -249,7 +249,6 @@ namespace spot
fact.finish(); fact.finish();
// Finally setup the resulting automaton. // Finally setup the resulting automaton.
tgba_bdd_concrete g(fact, v.result()); return new tgba_bdd_concrete(fact, v.result());
return g;
} }
} }

2
src/tgbaalgos/ltl2tgba.hh
View file

@ -7,7 +7,7 @@
namespace spot namespace spot
{ {
/// Build a spot::tgba_bdd_concrete from an LTL formula. /// Build a spot::tgba_bdd_concrete from an LTL formula.
tgba_bdd_concrete ltl_to_tgba(const ltl::formula* f, bdd_dict* dict); tgba_bdd_concrete* ltl_to_tgba(const ltl::formula* f, bdd_dict* dict);
} }
#endif // SPOT_TGBA_LTL2TGBA_HH #endif // SPOT_TGBA_LTL2TGBA_HH

18
src/tgbaalgos/save.cc
View file

@ -10,18 +10,18 @@ namespace spot
/// Process successors. /// Process successors.
static void static void
save_rec(std::ostream& os, const tgba& g, state* st, seen_set& m) save_rec(std::ostream& os, const tgba* g, state* st, seen_set& m)
{ {
m.insert(st); m.insert(st);
std::string cur = g.format_state(st); std::string cur = g->format_state(st);
tgba_succ_iterator* si = g.succ_iter(st); tgba_succ_iterator* si = g->succ_iter(st);
for (si->first(); !si->done(); si->next()) for (si->first(); !si->done(); si->next())
{ {
state* s = si->current_state(); state* s = si->current_state();
os << "\"" << cur << "\", \"" << g.format_state(s) << "\", "; os << "\"" << cur << "\", \"" << g->format_state(s) << "\", ";
bdd_print_sat(os, g.get_dict(), si->current_condition()) << ","; bdd_print_sat(os, g->get_dict(), si->current_condition()) << ",";
bdd_print_acc(os, g.get_dict(), si->current_accepting_conditions()) bdd_print_acc(os, g->get_dict(), si->current_accepting_conditions())
<< ";" << std::endl; << ";" << std::endl;
// Destination already explored? // Destination already explored?
@ -40,9 +40,9 @@ namespace spot
} }
std::ostream& std::ostream&
tgba_save_reachable(std::ostream& os, const tgba& g) tgba_save_reachable(std::ostream& os, const tgba* g)
{ {
const bdd_dict* d = g.get_dict(); const bdd_dict* d = g->get_dict();
os << "acc ="; os << "acc =";
for (bdd_dict::fv_map::const_iterator ai = d->acc_map.begin(); for (bdd_dict::fv_map::const_iterator ai = d->acc_map.begin();
ai != d->acc_map.end(); ++ai) ai != d->acc_map.end(); ++ai)
@ -53,7 +53,7 @@ namespace spot
os << ";" << std::endl; os << ";" << std::endl;
seen_set m; seen_set m;
state* state = g.get_init_state(); state* state = g->get_init_state();
save_rec(os, g, state, m); save_rec(os, g, state, m);
// Finally delete all states used as keys in m: // Finally delete all states used as keys in m:
for (seen_set::iterator i = m.begin(); i != m.end(); ++i) for (seen_set::iterator i = m.begin(); i != m.end(); ++i)

2
src/tgbaalgos/save.hh
View file

@ -7,7 +7,7 @@
namespace spot namespace spot
{ {
/// \brief Save reachable states in text format. /// \brief Save reachable states in text format.
std::ostream& tgba_save_reachable(std::ostream& os, const tgba& g); std::ostream& tgba_save_reachable(std::ostream& os, const tgba* g);
} }
#endif // SPOT_TGBAALGOS_SAVE_HH #endif // SPOT_TGBAALGOS_SAVE_HH

2
src/tgbatest/explicit.cc
View file

@ -29,7 +29,7 @@ main()
a->add_accepting_condition(t1, e.require("q")); a->add_accepting_condition(t1, e.require("q"));
a->add_accepting_condition(t2, e.require("r")); a->add_accepting_condition(t2, e.require("r"));
spot::dotty_reachable(std::cout, *a); spot::dotty_reachable(std::cout, a);
delete a; delete a;
delete dict; delete dict;

4
src/tgbatest/explprod.cc
View file

@ -35,8 +35,8 @@ main(int argc, char** argv)
return 2; return 2;
{ {
spot::tgba_product p(*a1, *a2); spot::tgba_product p(a1, a2);
spot::tgba_save_reachable(std::cout, p); spot::tgba_save_reachable(std::cout, &p);
} }
assert(spot::ltl::unop::instance_count() == 0); assert(spot::ltl::unop::instance_count() == 0);

21
src/tgbatest/ltl2tgba.cc
View file

@ -88,7 +88,7 @@ main(int argc, char** argv)
spot::bdd_dict* dict = new spot::bdd_dict(); spot::bdd_dict* dict = new spot::bdd_dict();
if (f) if (f)
{ {
spot::tgba_bdd_concrete a = spot::ltl_to_tgba(f, dict); spot::tgba_bdd_concrete* a = spot::ltl_to_tgba(f, dict);
spot::ltl::destroy(f); spot::ltl::destroy(f);
switch (output) switch (output)
{ {
@ -96,23 +96,23 @@ main(int argc, char** argv)
spot::dotty_reachable(std::cout, a); spot::dotty_reachable(std::cout, a);
break; break;
case 1: case 1:
spot::bdd_print_dot(std::cout, a.get_dict(), spot::bdd_print_dot(std::cout, a->get_dict(),
a.get_core_data().relation); a->get_core_data().relation);
break; break;
case 2: case 2:
spot::bdd_print_dot(std::cout, a.get_dict(), spot::bdd_print_dot(std::cout, a->get_dict(),
a.get_core_data().accepting_conditions); a->get_core_data().accepting_conditions);
break; break;
case 3: case 3:
spot::bdd_print_set(std::cout, a.get_dict(), spot::bdd_print_set(std::cout, a->get_dict(),
a.get_core_data().relation); a->get_core_data().relation);
break; break;
case 4: case 4:
spot::bdd_print_set(std::cout, a.get_dict(), spot::bdd_print_set(std::cout, a->get_dict(),
a.get_core_data().accepting_conditions); a->get_core_data().accepting_conditions);
break; break;
case 5: case 5:
a.get_dict()->dump(std::cout); a->get_dict()->dump(std::cout);
break; break;
case 6: case 6:
spot::lbtt_reachable(std::cout, a); spot::lbtt_reachable(std::cout, a);
@ -120,6 +120,7 @@ main(int argc, char** argv)
default: default:
assert(!"unknown output option"); assert(!"unknown output option");
} }
delete a;
} }
else else
{ {

12
src/tgbatest/ltlprod.cc
View file

@ -39,18 +39,20 @@ main(int argc, char** argv)
spot::bdd_dict* dict = new spot::bdd_dict(); spot::bdd_dict* dict = new spot::bdd_dict();
{ {
spot::tgba_bdd_concrete a1 = spot::ltl_to_tgba(f1, dict); spot::tgba_bdd_concrete* a1 = spot::ltl_to_tgba(f1, dict);
spot::tgba_bdd_concrete a2 = spot::ltl_to_tgba(f2, dict); spot::tgba_bdd_concrete* a2 = spot::ltl_to_tgba(f2, dict);
spot::ltl::destroy(f1); spot::ltl::destroy(f1);
spot::ltl::destroy(f2); spot::ltl::destroy(f2);
#ifdef BDD_CONCRETE_PRODUCT #ifdef BDD_CONCRETE_PRODUCT
spot::tgba_bdd_concrete p = spot::product(a1, a2); spot::tgba_bdd_concrete* p = spot::product(a1, a2);
#else #else
spot::tgba_product p(a1, a2); spot::tgba_product* p = new spot::tgba_product(a1, a2);
#endif #endif
spot::dotty_reachable(std::cout, p); spot::dotty_reachable(std::cout, p);
delete p;
delete a1;
delete a2;
} }
assert(spot::ltl::atomic_prop::instance_count() == 0); assert(spot::ltl::atomic_prop::instance_count() == 0);

8
src/tgbatest/mixprod.cc
View file

@ -39,11 +39,11 @@ main(int argc, char** argv)
return 2; return 2;
{ {
spot::tgba_bdd_concrete a1 = spot::ltl_to_tgba(f1, dict); spot::tgba_bdd_concrete* a1 = spot::ltl_to_tgba(f1, dict);
spot::ltl::destroy(f1); spot::ltl::destroy(f1);
spot::tgba_product p(a1, *a2); spot::tgba_product p(a1, a2);
spot::tgba_save_reachable(std::cout, &p);
spot::tgba_save_reachable(std::cout, p); delete a1;
} }
assert(spot::ltl::unop::instance_count() == 0); assert(spot::ltl::unop::instance_count() == 0);

2
src/tgbatest/readsave.cc
View file

@ -43,7 +43,7 @@ main(int argc, char** argv)
if (a) if (a)
{ {
spot::tgba_save_reachable(std::cout, *a); spot::tgba_save_reachable(std::cout, a);
delete a; delete a;
} }
else else

3
src/tgbatest/spotlbtt.cc
View file

@ -48,9 +48,10 @@ main(int argc, char** argv)
if (f) if (f)
{ {
spot::tgba_bdd_concrete a = spot::ltl_to_tgba(f, dict); spot::tgba_bdd_concrete* a = spot::ltl_to_tgba(f, dict);
spot::ltl::destroy(f); spot::ltl::destroy(f);
spot::lbtt_reachable(std::cout, a); spot::lbtt_reachable(std::cout, a);
delete a;
} }
else else
{ {

2
src/tgbatest/tgbaread.cc
View file

@ -43,7 +43,7 @@ main(int argc, char** argv)
if (a) if (a)
{ {
spot::dotty_reachable(std::cout, *a); spot::dotty_reachable(std::cout, a);
delete a; delete a;
} }
else else

6
src/tgbatest/tripprod.cc
View file

@ -39,9 +39,9 @@ main(int argc, char** argv)
return 2; return 2;
{ {
spot::tgba_product p(*a1, *a2); spot::tgba_product p(a1, a2);
spot::tgba_product p2(p, *a3); spot::tgba_product p2(&p, a3);
spot::tgba_save_reachable(std::cout, p2); spot::tgba_save_reachable(std::cout, &p2);
} }
assert(spot::ltl::unop::instance_count() == 0); assert(spot::ltl::unop::instance_count() == 0);