Get rid of all dynamic_cast<>s while working on LTL formulae.
They are too slow. * src/ltlast/formula.hh (opkind, kind, kind_): Use an enum to indicate the actual kind of the formula. This way we can check the kind of a formula without relying on dynamic_cast. * src/ltlast/atomic_prop.cc, src/ltlast/automatop.cc, src/ltlast/binop.cc, src/ltlast/bunop.cc, src/ltlast/constant.cc, src/ltlast/multop.cc, src/ltlast/refformula.cc, src/ltlast/refformula.hh, src/ltlast/unop.cc: Adjust constructors. * src/ltlvisit/basicreduce.cc, src/ltlvisit/mark.cc, src/ltlvisit/reduce.cc, src/ltlvisit/syntimpl.cc, src/ltlvisit/tostring.cc: Replace all dynamic_cast by a call to kind() followed by a static_cast.
This commit is contained in:
Alexandre Duret-Lutz
parent
48cde88b9b
commit
957ba664b7
15 changed files with 743 additions and 609 deletions
|
|
@ -32,7 +32,7 @@ namespace spot
|
|||
{
|
||||
|
||||
atomic_prop::atomic_prop(const std::string& name, environment& env)
|
||||
: name_(name), env_(&env)
|
||||
: ref_formula(AtomicProp), name_(name), env_(&env)
|
||||
{
|
||||
is.boolean = true;
|
||||
is.sugar_free_boolean = true;
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@ namespace spot
|
|||
namespace ltl
|
||||
{
|
||||
automatop::automatop(const nfa::ptr nfa, vec* v, bool negated)
|
||||
: nfa_(nfa), children_(v), negated_(negated)
|
||||
: ref_formula(AutomatOp), nfa_(nfa), children_(v), negated_(negated)
|
||||
{
|
||||
is.boolean = false;
|
||||
is.sugar_free_boolean = true;
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ namespace spot
|
|||
namespace ltl
|
||||
{
|
||||
binop::binop(type op, formula* first, formula* second)
|
||||
: op_(op), first_(first), second_(second)
|
||||
: ref_formula(BinOp), op_(op), first_(first), second_(second)
|
||||
{
|
||||
// Beware: (f U g) is purely eventual if both operands
|
||||
// are purely eventual, unlike in the proceedings of
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@ namespace spot
|
|||
namespace ltl
|
||||
{
|
||||
bunop::bunop(type op, formula* child, unsigned min, unsigned max)
|
||||
: op_(op), child_(child), min_(min), max_(max)
|
||||
: ref_formula(BUnOp), op_(op), child_(child), min_(min), max_(max)
|
||||
{
|
||||
props = child->get_props();
|
||||
|
||||
|
|
@ -314,9 +314,9 @@ namespace spot
|
|||
|
||||
// - Exp[*i..j][*min..max] = Exp[*i(min)..j(max)]
|
||||
// if i*(min+1)<=j(min)+1.
|
||||
bunop* s = dynamic_cast<bunop*>(child);
|
||||
if (s)
|
||||
if (child->kind() == BUnOp)
|
||||
{
|
||||
bunop* s = static_cast<bunop*>(child);
|
||||
unsigned i = s->min();
|
||||
unsigned j = s->max();
|
||||
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ namespace spot
|
|||
constant constant::empty_word_instance_(constant::EmptyWord);
|
||||
|
||||
constant::constant(type val)
|
||||
: val_(val)
|
||||
: formula(Constant), val_(val)
|
||||
{
|
||||
switch (val)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -71,11 +71,20 @@ namespace spot
|
|||
class formula
|
||||
{
|
||||
public:
|
||||
formula() : count_(max_count++)
|
||||
/// Kind of a sub-formula
|
||||
enum opkind { Constant,
|
||||
AtomicProp,
|
||||
UnOp,
|
||||
BinOp,
|
||||
MultOp,
|
||||
BUnOp,
|
||||
AutomatOp };
|
||||
|
||||
formula(opkind k) : count_(max_count++), kind_(k)
|
||||
{
|
||||
// If the counter of formulae ever loops, we want to skip the
|
||||
// first three values, because they are permanently associated
|
||||
// to constants, and its convenient to have constants smaller
|
||||
// to constants, and it is convenient to have constants smaller
|
||||
// than all other formulae.
|
||||
if (max_count == 0)
|
||||
max_count = 3;
|
||||
|
|
@ -100,6 +109,12 @@ namespace spot
|
|||
/// Return a canonic representation of the formula
|
||||
virtual std::string dump() const = 0;
|
||||
|
||||
/// Return the kind of the top-level operator.
|
||||
opkind kind() const
|
||||
{
|
||||
return kind_;
|
||||
}
|
||||
|
||||
////////////////
|
||||
// Properties //
|
||||
////////////////
|
||||
|
|
@ -279,6 +294,7 @@ namespace spot
|
|||
private:
|
||||
/// \brief Number of formulae created so far.
|
||||
static size_t max_count;
|
||||
opkind kind_;
|
||||
};
|
||||
|
||||
/// \brief Strict Weak Ordering for <code>const formula*</code>.
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ namespace spot
|
|||
namespace ltl
|
||||
{
|
||||
multop::multop(type op, vec* v)
|
||||
: op_(op), children_(v)
|
||||
: ref_formula(MultOp), op_(op), children_(v)
|
||||
{
|
||||
unsigned s = v->size();
|
||||
assert(s > 1);
|
||||
|
|
@ -177,17 +177,19 @@ namespace spot
|
|||
vec::iterator i = v->begin();
|
||||
while (i != v->end())
|
||||
{
|
||||
multop* p = dynamic_cast<multop*>(*i);
|
||||
if (p && p->op() == op)
|
||||
if ((*i)->kind() == MultOp)
|
||||
{
|
||||
multop* p = static_cast<multop*>(*i);
|
||||
if (p->op() == op)
|
||||
{
|
||||
unsigned ps = p->size();
|
||||
for (unsigned n = 0; n < ps; ++n)
|
||||
inlined.push_back(p->nth(n)->clone());
|
||||
(*i)->destroy();
|
||||
i = v->erase(i);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// All operator except "Concat" and "Fusion" are
|
||||
// commutative, so we just keep a list of the inlined
|
||||
// arguments that should later be added to the vector.
|
||||
|
|
@ -197,7 +199,6 @@ namespace spot
|
|||
inlined.push_back(*i);
|
||||
++i;
|
||||
}
|
||||
}
|
||||
if (op == Concat || op == Fusion)
|
||||
*v = inlined;
|
||||
else
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
// Copyright (C) 2010 Laboratoire de Recherche de Developpement de
|
||||
// l'EPITA (LRDE).
|
||||
// Copyright (C) 2003, 2004 Laboratoire d'Informatique de Paris 6 (LIP6),
|
||||
// département Systèmes Répartis Coopératifs (SRC), Université Pierre
|
||||
// et Marie Curie.
|
||||
|
|
@ -26,8 +28,8 @@ namespace spot
|
|||
{
|
||||
namespace ltl
|
||||
{
|
||||
ref_formula::ref_formula()
|
||||
: ref_counter_(0)
|
||||
ref_formula::ref_formula(opkind k)
|
||||
: formula(k), ref_counter_(0)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,8 @@
|
|||
// Copyright (C) 2003, 2004, 2005 Laboratoire d'Informatique de Paris 6 (LIP6),
|
||||
// département Systèmes Répartis Coopératifs (SRC), Université Pierre
|
||||
// et Marie Curie.
|
||||
// Copyright (C) 2010 Laboratoire de Recherche de Developpement de
|
||||
// l'EPITA (LRDE).
|
||||
// Copyright (C) 2003, 2004, 2005 Laboratoire d'Informatique de Paris
|
||||
// 6 (LIP6), département Systèmes Répartis Coopératifs (SRC),
|
||||
// Université Pierre et Marie Curie.
|
||||
//
|
||||
// This file is part of Spot, a model checking library.
|
||||
//
|
||||
|
|
@ -37,7 +39,7 @@ namespace spot
|
|||
{
|
||||
protected:
|
||||
virtual ~ref_formula();
|
||||
ref_formula();
|
||||
ref_formula(opkind k);
|
||||
void ref_();
|
||||
bool unref_();
|
||||
/// Number of references to this formula.
|
||||
|
|
|
|||
|
|
@ -33,13 +33,13 @@ namespace spot
|
|||
namespace ltl
|
||||
{
|
||||
unop::unop(type op, formula* child)
|
||||
: op_(op), child_(child)
|
||||
: ref_formula(UnOp), op_(op), child_(child)
|
||||
{
|
||||
props = child->get_props();
|
||||
switch (op)
|
||||
{
|
||||
case Not:
|
||||
is.in_nenoform = !!dynamic_cast<atomic_prop*>(child);
|
||||
is.in_nenoform = (child->kind() == AtomicProp);
|
||||
is.accepting_eword = false;
|
||||
break;
|
||||
case X:
|
||||
|
|
@ -162,11 +162,14 @@ namespace spot
|
|||
{
|
||||
case F:
|
||||
case G:
|
||||
{
|
||||
if (child->kind() == UnOp)
|
||||
{
|
||||
// F and G are idempotent.
|
||||
unop* u = dynamic_cast<unop*>(child);
|
||||
if (u && u->op() == op)
|
||||
unop* u = static_cast<unop*>(child);
|
||||
if (u->op() == op)
|
||||
return u;
|
||||
}
|
||||
|
||||
// F(0) = G(0) = 0
|
||||
// F(1) = G(1) = 1
|
||||
|
|
@ -191,9 +194,9 @@ namespace spot
|
|||
return bunop::instance(bunop::Star,
|
||||
constant::true_instance(), 1);
|
||||
|
||||
unop* u = dynamic_cast<unop*>(child);
|
||||
if (u)
|
||||
if (child->kind() == UnOp)
|
||||
{
|
||||
unop* u = static_cast<unop*>(child);
|
||||
// "Not" is an involution.
|
||||
if (u->op() == op)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -33,27 +33,31 @@ namespace spot
|
|||
bool
|
||||
is_GF(const formula* f)
|
||||
{
|
||||
const unop* op = dynamic_cast<const unop*>(f);
|
||||
if (op && op->op() == unop::G)
|
||||
{
|
||||
const unop* opchild = dynamic_cast<const unop*>(op->child());
|
||||
if (opchild && opchild->op() == unop::F)
|
||||
return true;
|
||||
}
|
||||
if (f->kind() != formula::UnOp)
|
||||
return false;
|
||||
const unop* op = static_cast<const unop*>(f);
|
||||
if (op->op() != unop::G)
|
||||
return false;
|
||||
const formula* c = op->child();
|
||||
if (c->kind() != formula::UnOp)
|
||||
return false;
|
||||
const unop* opchild = static_cast<const unop*>(c);
|
||||
return opchild->op() == unop::F;
|
||||
}
|
||||
|
||||
bool
|
||||
is_FG(const formula* f)
|
||||
{
|
||||
const unop* op = dynamic_cast<const unop*>(f);
|
||||
if (op && op->op() == unop::F)
|
||||
{
|
||||
const unop* opchild = dynamic_cast<const unop*>(op->child());
|
||||
if (opchild && opchild->op() == unop::G)
|
||||
return true;
|
||||
}
|
||||
if (f->kind() != formula::UnOp)
|
||||
return false;
|
||||
const unop* op = static_cast<const unop*>(f);
|
||||
if (op->op() != unop::F)
|
||||
return false;
|
||||
const formula* c = op->child();
|
||||
if (c->kind() != formula::UnOp)
|
||||
return false;
|
||||
const unop* opchild = static_cast<const unop*>(c);
|
||||
return opchild->op() == unop::G;
|
||||
}
|
||||
|
||||
namespace
|
||||
|
|
@ -134,7 +138,7 @@ namespace spot
|
|||
case unop::X:
|
||||
// X(true) = true
|
||||
// X(false) = false
|
||||
if (dynamic_cast<constant*>(result_))
|
||||
if (result_->kind() == formula::Constant)
|
||||
return;
|
||||
|
||||
// XGF(f) = GF(f)
|
||||
|
|
@ -143,9 +147,9 @@ namespace spot
|
|||
|
||||
// X(f1 & GF(f2)) = X(f1) & GF(F2)
|
||||
// X(f1 | GF(f2)) = X(f1) | GF(F2)
|
||||
mo = dynamic_cast<multop*>(result_);
|
||||
if (mo)
|
||||
if (result_->kind() == formula::MultOp)
|
||||
{
|
||||
mo = static_cast<multop*>(result_);
|
||||
result_ = param_case(mo, unop::X, mo->op());
|
||||
return;
|
||||
}
|
||||
|
|
@ -156,23 +160,25 @@ namespace spot
|
|||
case unop::F:
|
||||
// F(true) = true
|
||||
// F(false) = false
|
||||
if (dynamic_cast<constant*>(result_))
|
||||
if (result_->kind() == formula::Constant)
|
||||
return;
|
||||
|
||||
// FX(a) = XF(a)
|
||||
u = dynamic_cast<unop*>(result_);
|
||||
if (u && u->op() == unop::X)
|
||||
if (result_->kind() == formula::UnOp)
|
||||
{
|
||||
u = static_cast<unop*>(result_);
|
||||
if (u->op() == unop::X)
|
||||
{
|
||||
formula* res =
|
||||
unop::instance(unop::X,
|
||||
unop::instance(unop::F,
|
||||
basic_reduce(u->child())));
|
||||
unop::instance(unop::X, unop::instance
|
||||
(unop::F, basic_reduce(u->child())));
|
||||
u->destroy();
|
||||
// FXX(a) = XXF(a) ...
|
||||
result_ = basic_reduce(res);
|
||||
res->destroy();
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
#if 0
|
||||
// F(f1 & GF(f2)) = F(f1) & GF(F2)
|
||||
|
|
@ -189,12 +195,15 @@ namespace spot
|
|||
// GF(f2)) | (a & GF(b))) is indeed easier to translate.
|
||||
//
|
||||
// So let's not consider this rewriting rule.
|
||||
mo = dynamic_cast<multop*>(result_);
|
||||
if (mo && mo->op() == multop::And)
|
||||
if (result_->kind() == formula::MultOp)
|
||||
{
|
||||
mo = static_cast<multop*>(result_);
|
||||
if (mo->op() == multop::And)
|
||||
{
|
||||
result_ = param_case(mo, unop::F, multop::And);
|
||||
return;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
result_ = unop::instance(unop::F, result_);
|
||||
|
|
@ -203,27 +212,31 @@ namespace spot
|
|||
case unop::G:
|
||||
// G(true) = true
|
||||
// G(false) = false
|
||||
if (dynamic_cast<constant*>(result_))
|
||||
if (result_->kind() == formula::Constant)
|
||||
return;
|
||||
|
||||
// G(a R b) = G(b)
|
||||
bo = dynamic_cast<binop*>(result_);
|
||||
if (bo && bo->op() == binop::R)
|
||||
if (result_->kind() == formula::BinOp)
|
||||
{
|
||||
bo = static_cast<binop*>(result_);
|
||||
if (bo->op() == binop::R)
|
||||
{
|
||||
result_ = unop::instance(unop::G,
|
||||
basic_reduce(bo->second()));
|
||||
bo->destroy();
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// GX(a) = XG(a)
|
||||
u = dynamic_cast<unop*>(result_);
|
||||
if (u && u->op() == unop::X)
|
||||
if (result_->kind() == formula::UnOp)
|
||||
{
|
||||
u = static_cast<unop*>(result_);
|
||||
if (u->op() == unop::X)
|
||||
{
|
||||
formula* res =
|
||||
unop::instance(unop::X,
|
||||
unop::instance(unop::G,
|
||||
basic_reduce(u->child())));
|
||||
unop::instance(unop::X, unop::instance
|
||||
(unop::G, basic_reduce(u->child())));
|
||||
u->destroy();
|
||||
// GXX(a) = XXG(a) ...
|
||||
// GXF(a) = XGF(a) = GF(a) ...
|
||||
|
|
@ -231,14 +244,18 @@ namespace spot
|
|||
res->destroy();
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// G(f1 | GF(f2)) = G(f1) | GF(F2)
|
||||
mo = dynamic_cast<multop*>(result_);
|
||||
if (mo && mo->op() == multop::Or)
|
||||
if (result_->kind() == formula::MultOp)
|
||||
{
|
||||
mo = static_cast<multop*>(result_);
|
||||
if (mo->op() == multop::Or)
|
||||
{
|
||||
result_ = param_case(mo, unop::G, multop::Or);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
result_ = unop::instance(unop::G, result_);
|
||||
return;
|
||||
|
|
@ -297,19 +314,23 @@ namespace spot
|
|||
// a R true = true
|
||||
// a W true = true
|
||||
// a M false = false
|
||||
if (dynamic_cast<constant*>(f2))
|
||||
if (f2->kind() == formula::Constant)
|
||||
{
|
||||
result_ = f2;
|
||||
f1->destroy();
|
||||
return;
|
||||
}
|
||||
|
||||
// Same effect as dynamic_cast<unop*>, only faster.
|
||||
unop* fu1 =
|
||||
(f1->kind() == formula::UnOp) ? static_cast<unop*>(f1) : 0;
|
||||
unop* fu2 =
|
||||
(f2->kind() == formula::UnOp) ? static_cast<unop*>(f2) : 0;
|
||||
|
||||
// X(a) U X(b) = X(a U b)
|
||||
// X(a) R X(b) = X(a R b)
|
||||
// X(a) W X(b) = X(a W b)
|
||||
// X(a) M X(b) = X(a M b)
|
||||
unop* fu1 = dynamic_cast<unop*>(f1);
|
||||
unop* fu2 = dynamic_cast<unop*>(f2);
|
||||
if (fu1 && fu2
|
||||
&& fu1->op() == unop::X
|
||||
&& fu2->op() == unop::X)
|
||||
|
|
@ -337,14 +358,18 @@ namespace spot
|
|||
|
||||
// a U (b | G(a)) = a W b
|
||||
// a W (b | G(a)) = a W b
|
||||
multop* fm2 = dynamic_cast<multop*>(f2);
|
||||
if (fm2 && fm2->op() == multop::Or)
|
||||
if (f2->kind() == formula::MultOp)
|
||||
{
|
||||
multop* fm2 = static_cast<multop*>(f2);
|
||||
if (fm2->op() == multop::Or)
|
||||
{
|
||||
int s = fm2->size();
|
||||
for (int i = 0; i < s; ++i)
|
||||
{
|
||||
unop* c = dynamic_cast<unop*>(fm2->nth(i));
|
||||
if (c && c->op() == unop::G && c->child() == f1)
|
||||
if (fm2->nth(i)->kind() != formula::UnOp)
|
||||
continue;
|
||||
unop* c = static_cast<unop*>(fm2->nth(i));
|
||||
if (c->op() == unop::G && c->child() == f1)
|
||||
{
|
||||
multop::vec* v = new multop::vec;
|
||||
v->reserve(s - 1);
|
||||
|
|
@ -354,16 +379,16 @@ namespace spot
|
|||
// skip j=i
|
||||
for (++j; j < s; ++j)
|
||||
v->push_back(fm2->nth(j)->clone());
|
||||
result_ =
|
||||
binop::instance(binop::W, f1,
|
||||
multop::instance(multop::Or,
|
||||
v));
|
||||
result_ = binop::instance
|
||||
(binop::W, f1,
|
||||
multop::instance(multop::Or, v));
|
||||
f2->destroy();
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (op == binop::M || op == binop::R)
|
||||
{
|
||||
// a R Fa = Fa
|
||||
|
|
@ -377,14 +402,18 @@ namespace spot
|
|||
|
||||
// a R (b & F(a)) = a M b
|
||||
// a M (b & F(a)) = a M b
|
||||
multop* fm2 = dynamic_cast<multop*>(f2);
|
||||
if (fm2 && fm2->op() == multop::And)
|
||||
if (f2->kind() == formula::MultOp)
|
||||
{
|
||||
multop* fm2 = static_cast<multop*>(f2);
|
||||
if (fm2->op() == multop::And)
|
||||
{
|
||||
int s = fm2->size();
|
||||
for (int i = 0; i < s; ++i)
|
||||
{
|
||||
unop* c = dynamic_cast<unop*>(fm2->nth(i));
|
||||
if (c && c->op() == unop::F && c->child() == f1)
|
||||
if (fm2->nth(i)->kind() != formula::UnOp)
|
||||
continue;
|
||||
unop* c = static_cast<unop*>(fm2->nth(i));
|
||||
if (c->op() == unop::F && c->child() == f1)
|
||||
{
|
||||
multop::vec* v = new multop::vec;
|
||||
v->reserve(s - 1);
|
||||
|
|
@ -394,16 +423,16 @@ namespace spot
|
|||
// skip j=i
|
||||
for (++j; j < s; ++j)
|
||||
v->push_back(fm2->nth(j)->clone());
|
||||
result_ =
|
||||
binop::instance(binop::M, f1,
|
||||
multop::instance(multop::And,
|
||||
v));
|
||||
result_ = binop::instance
|
||||
(binop::M, f1,
|
||||
multop::instance(multop::And, v));
|
||||
f2->destroy();
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
result_ = binop::instance(op, f1, f2);
|
||||
return;
|
||||
|
|
@ -449,10 +478,11 @@ namespace spot
|
|||
// of the vector to mark them as redundant. Skip them.
|
||||
if (!*i)
|
||||
continue;
|
||||
unop* uo = dynamic_cast<unop*>(*i);
|
||||
binop* bo = dynamic_cast<binop*>(*i);
|
||||
if (uo)
|
||||
switch ((*i)->kind())
|
||||
{
|
||||
case formula::UnOp:
|
||||
{
|
||||
unop* uo = static_cast<unop*>(*i);
|
||||
if (uo->op() == unop::X)
|
||||
{
|
||||
// Xa & Xb = X(a & b)
|
||||
|
|
@ -461,7 +491,7 @@ namespace spot
|
|||
else if (is_FG(*i))
|
||||
{
|
||||
// FG(a) & FG(b) = FG(a & b)
|
||||
unop* uo2 = dynamic_cast<unop*>(uo->child());
|
||||
unop* uo2 = static_cast<unop*>(uo->child());
|
||||
tmpFG->push_back(uo2->child()->clone());
|
||||
}
|
||||
else if (uo->op() == unop::G)
|
||||
|
|
@ -482,9 +512,10 @@ namespace spot
|
|||
{
|
||||
if (!*j)
|
||||
continue;
|
||||
binop* b = dynamic_cast<binop*>(*j);
|
||||
if (b && (b->op() == binop::R
|
||||
|| b->op() == binop::M)
|
||||
if ((*i)->kind() != formula::BinOp)
|
||||
continue;
|
||||
binop* b = static_cast<binop*>(*j);
|
||||
if ((b->op() == binop::R || b->op() == binop::M)
|
||||
&& b->first() == a)
|
||||
{
|
||||
formula* r =
|
||||
|
|
@ -496,7 +527,7 @@ namespace spot
|
|||
*j = 0;
|
||||
rewritten = true;
|
||||
}
|
||||
else if (b && (b->op() == binop::W
|
||||
else if ((b->op() == binop::W
|
||||
|| b->op() == binop::U)
|
||||
&& b->second() == a)
|
||||
{
|
||||
|
|
@ -517,16 +548,18 @@ namespace spot
|
|||
{
|
||||
tmpOther->push_back((*i)->clone());
|
||||
}
|
||||
break;
|
||||
}
|
||||
else if (bo)
|
||||
case formula::BinOp:
|
||||
{
|
||||
binop* bo = static_cast<binop*>(*i);
|
||||
if (bo->op() == binop::U || bo->op() == binop::W)
|
||||
{
|
||||
// (a U b) & (c U b) = (a & c) U b
|
||||
// (a U b) & (c W b) = (a & c) U b
|
||||
// (a W b) & (c W b) = (a & c) W b
|
||||
bool weak = true;
|
||||
formula* ftmp = dynamic_cast<binop*>(*i)->second();
|
||||
formula* ftmp = bo->second();
|
||||
multop::vec* right = new multop::vec;
|
||||
for (multop::vec::iterator j = i; j != res->end();
|
||||
j++)
|
||||
|
|
@ -535,16 +568,22 @@ namespace spot
|
|||
continue;
|
||||
// (a U b) & Fb = a U b.
|
||||
// (a W b) & Fb = a U b.
|
||||
unop* uo2 = dynamic_cast<unop*>(*j);
|
||||
if (uo2 && uo2->op() == unop::F
|
||||
if ((*j)->kind() == formula::UnOp)
|
||||
{
|
||||
unop* uo2 = static_cast<unop*>(*j);
|
||||
if (uo2->op() == unop::F
|
||||
&& uo2->child() == ftmp)
|
||||
{
|
||||
(*j)->destroy();
|
||||
*j = 0;
|
||||
weak = false;
|
||||
continue;
|
||||
}
|
||||
binop* bo2 = dynamic_cast<binop*>(*j);
|
||||
if (bo2 && (bo2->op() == binop::U
|
||||
}
|
||||
if ((*j)->kind() == formula::BinOp)
|
||||
{
|
||||
binop* bo2 = static_cast<binop*>(*j);
|
||||
if ((bo2->op() == binop::U
|
||||
|| bo2->op() == binop::W)
|
||||
&& ftmp == bo2->second())
|
||||
{
|
||||
|
|
@ -555,6 +594,8 @@ namespace spot
|
|||
{
|
||||
(*j)->destroy();
|
||||
*j = 0;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -571,7 +612,7 @@ namespace spot
|
|||
// (a R b) & (a R c) = a R (b & c)
|
||||
// (a R b) & (a M c) = a M (b & c)
|
||||
bool weak = true;
|
||||
formula* ftmp = dynamic_cast<binop*>(*i)->first();
|
||||
formula* ftmp = bo->first();
|
||||
multop::vec* right = new multop::vec;
|
||||
for (multop::vec::iterator j = i; j != res->end();
|
||||
j++)
|
||||
|
|
@ -580,26 +621,35 @@ namespace spot
|
|||
continue;
|
||||
// (a R b) & Fa = a M b.
|
||||
// (a M b) & Fa = a M b.
|
||||
unop* uo2 = dynamic_cast<unop*>(*j);
|
||||
if (uo2 && uo2->op() == unop::F
|
||||
if ((*j)->kind() == formula::UnOp)
|
||||
{
|
||||
unop* uo2 = static_cast<unop*>(*j);
|
||||
if (uo2->op() == unop::F
|
||||
&& uo2->child() == ftmp)
|
||||
{
|
||||
(*j)->destroy();
|
||||
*j = 0;
|
||||
weak = false;
|
||||
continue;
|
||||
}
|
||||
binop* bo2 = dynamic_cast<binop*>(*j);
|
||||
if (bo2 && (bo2->op() == binop::R
|
||||
}
|
||||
if ((*j)->kind() == formula::BinOp)
|
||||
{
|
||||
binop* bo2 = static_cast<binop*>(*j);
|
||||
if ((bo2->op() == binop::R
|
||||
|| bo2->op() == binop::M)
|
||||
&& ftmp == bo2->first())
|
||||
{
|
||||
if (bo2->op() == binop::M)
|
||||
weak = false;
|
||||
right->push_back(bo2->second()->clone());
|
||||
right->push_back
|
||||
(bo2->second()->clone());
|
||||
if (j != i)
|
||||
{
|
||||
(*j)->destroy();
|
||||
*j = 0;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -615,9 +665,9 @@ namespace spot
|
|||
{
|
||||
tmpOther->push_back((*i)->clone());
|
||||
}
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
default:
|
||||
tmpOther->push_back((*i)->clone());
|
||||
}
|
||||
(*i)->destroy();
|
||||
|
|
@ -630,10 +680,11 @@ namespace spot
|
|||
{
|
||||
if (!*i)
|
||||
continue;
|
||||
unop* uo = dynamic_cast<unop*>(*i);
|
||||
binop* bo = dynamic_cast<binop*>(*i);
|
||||
if (uo)
|
||||
switch ((*i)->kind())
|
||||
{
|
||||
case formula::UnOp:
|
||||
{
|
||||
unop* uo = static_cast<unop*>(*i);
|
||||
if (uo->op() == unop::X)
|
||||
{
|
||||
// Xa | Xb = X(a | b)
|
||||
|
|
@ -642,7 +693,7 @@ namespace spot
|
|||
else if (is_GF(*i))
|
||||
{
|
||||
// GF(a) | GF(b) = GF(a | b)
|
||||
unop* uo2 = dynamic_cast<unop*>(uo->child());
|
||||
unop* uo2 = static_cast<unop*>(uo->child());
|
||||
tmpGF->push_back(uo2->child()->clone());
|
||||
}
|
||||
else if (uo->op() == unop::F)
|
||||
|
|
@ -661,9 +712,10 @@ namespace spot
|
|||
{
|
||||
if (!*j)
|
||||
continue;
|
||||
binop* b = dynamic_cast<binop*>(*j);
|
||||
if (b && (b->op() == binop::U
|
||||
|| b->op() == binop::W)
|
||||
if ((*j)->kind() != formula::BinOp)
|
||||
continue;
|
||||
binop* b = static_cast<binop*>(*j);
|
||||
if ((b->op() == binop::U || b->op() == binop::W)
|
||||
&& b->first() == a)
|
||||
{
|
||||
formula* r =
|
||||
|
|
@ -683,9 +735,11 @@ namespace spot
|
|||
{
|
||||
tmpOther->push_back((*i)->clone());
|
||||
}
|
||||
break;
|
||||
}
|
||||
else if (bo)
|
||||
case formula::BinOp:
|
||||
{
|
||||
binop* bo = static_cast<binop*>(*i);
|
||||
if (bo->op() == binop::U || bo->op() == binop::W)
|
||||
{
|
||||
// (a U b) | (a U c) = a U (b | c)
|
||||
|
|
@ -700,26 +754,35 @@ namespace spot
|
|||
continue;
|
||||
// (a U b) | Ga = a W b.
|
||||
// (a W b) | Ga = a W b.
|
||||
unop* uo2 = dynamic_cast<unop*>(*j);
|
||||
if (uo2 && uo2->op() == unop::G
|
||||
if ((*j)->kind() == formula::UnOp)
|
||||
{
|
||||
unop* uo2 = static_cast<unop*>(*j);
|
||||
if (uo2->op() == unop::G
|
||||
&& uo2->child() == ftmp)
|
||||
{
|
||||
(*j)->destroy();
|
||||
*j = 0;
|
||||
weak = true;
|
||||
continue;
|
||||
}
|
||||
binop* bo2 = dynamic_cast<binop*>(*j);
|
||||
if (bo2 && (bo2->op() == binop::U ||
|
||||
}
|
||||
if ((*j)->kind() == formula::BinOp)
|
||||
{
|
||||
binop* bo2 = static_cast<binop*>(*j);
|
||||
if ((bo2->op() == binop::U ||
|
||||
bo2->op() == binop::W)
|
||||
&& ftmp == bo2->first())
|
||||
{
|
||||
if (bo2->op() == binop::W)
|
||||
weak = true;
|
||||
right->push_back(bo2->second()->clone());
|
||||
right->push_back
|
||||
(bo2->second()->clone());
|
||||
if (j != i)
|
||||
{
|
||||
(*j)->destroy();
|
||||
*j = 0;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -736,7 +799,7 @@ namespace spot
|
|||
// (a R b) | (c M b) = (a | c) R b
|
||||
// (a M b) | (c M b) = (a | c) M b
|
||||
bool weak = false;
|
||||
formula* ftmp = dynamic_cast<binop*>(*i)->second();
|
||||
formula* ftmp = bo->second();
|
||||
multop::vec* right = new multop::vec;
|
||||
for (multop::vec::iterator j = i; j != res->end();
|
||||
j++)
|
||||
|
|
@ -745,16 +808,22 @@ namespace spot
|
|||
continue;
|
||||
// (a R b) | Gb = a R b.
|
||||
// (a M b) | Gb = a R b.
|
||||
unop* uo2 = dynamic_cast<unop*>(*j);
|
||||
if (uo2 && uo2->op() == unop::G
|
||||
if ((*j)->kind() == formula::UnOp)
|
||||
{
|
||||
unop* uo2 = static_cast<unop*>(*j);
|
||||
if (uo2->op() == unop::G
|
||||
&& uo2->child() == ftmp)
|
||||
{
|
||||
(*j)->destroy();
|
||||
*j = 0;
|
||||
weak = true;
|
||||
continue;
|
||||
}
|
||||
binop* bo2 = dynamic_cast<binop*>(*j);
|
||||
if (bo2 && (bo2->op() == binop::R
|
||||
}
|
||||
if ((*j)->kind() == formula::BinOp)
|
||||
{
|
||||
binop* bo2 = static_cast<binop*>(*j);
|
||||
if ((bo2->op() == binop::R
|
||||
|| bo2->op() == binop::M)
|
||||
&& ftmp == bo2->second())
|
||||
{
|
||||
|
|
@ -765,6 +834,8 @@ namespace spot
|
|||
{
|
||||
(*j)->destroy();
|
||||
*j = 0;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -780,14 +851,13 @@ namespace spot
|
|||
{
|
||||
tmpOther->push_back((*i)->clone());
|
||||
}
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
default:
|
||||
tmpOther->push_back((*i)->clone());
|
||||
}
|
||||
(*i)->destroy();
|
||||
}
|
||||
|
||||
break;
|
||||
case multop::Concat:
|
||||
case multop::AndNLM:
|
||||
|
|
|
|||
|
|
@ -221,13 +221,13 @@ namespace spot
|
|||
{
|
||||
formula* f = mo->nth(i);
|
||||
|
||||
binop* bo = dynamic_cast<binop*>(f);
|
||||
if (!bo)
|
||||
if (f->kind() != formula::BinOp)
|
||||
{
|
||||
res->push_back(recurse(f));
|
||||
}
|
||||
else
|
||||
{
|
||||
binop* bo = static_cast<binop*>(f);
|
||||
switch (bo->op())
|
||||
{
|
||||
case binop::Xor:
|
||||
|
|
|
|||
|
|
@ -179,9 +179,10 @@ namespace spot
|
|||
}
|
||||
/* a < b => a U (b U c) = (b U c) */
|
||||
/* a < b => a U (b W c) = (b W c) */
|
||||
if (f2->kind() == formula::BinOp)
|
||||
{
|
||||
binop* bo = dynamic_cast<binop*>(f2);
|
||||
if (bo && (bo->op() == binop::U || bo->op() == binop::W)
|
||||
binop* bo = static_cast<binop*>(f2);
|
||||
if ((bo->op() == binop::U || bo->op() == binop::W)
|
||||
&& syntactic_implication(f1, bo->first()))
|
||||
{
|
||||
result_ = f2;
|
||||
|
|
@ -206,22 +207,21 @@ namespace spot
|
|||
f1->destroy();
|
||||
return;
|
||||
}
|
||||
if (f2->kind() == formula::BinOp)
|
||||
{
|
||||
/* b < a => a R (b R c) = b R c */
|
||||
/* b < a => a R (b M c) = b M c */
|
||||
{
|
||||
binop* bo = dynamic_cast<binop*>(f2);
|
||||
if (bo && (bo->op() == binop::R || bo->op() == binop::M)
|
||||
binop* bo = static_cast<binop*>(f2);
|
||||
if ((bo->op() == binop::R || bo->op() == binop::M)
|
||||
&& syntactic_implication(bo->first(), f1))
|
||||
{
|
||||
result_ = f2;
|
||||
f1->destroy();
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
/* a < b => a R (b R c) = a R c */
|
||||
{
|
||||
binop* bo = dynamic_cast<binop*>(f2);
|
||||
if (bo && bo->op() == binop::R
|
||||
if (bo->op() == binop::R
|
||||
&& syntactic_implication(f1, bo->first()))
|
||||
{
|
||||
result_ = binop::instance(binop::R, f1,
|
||||
|
|
@ -249,9 +249,10 @@ namespace spot
|
|||
return;
|
||||
}
|
||||
/* a < b => a W (b W c) = (b W c) */
|
||||
if (f2->kind() == formula::BinOp)
|
||||
{
|
||||
binop* bo = dynamic_cast<binop*>(f2);
|
||||
if (bo && bo->op() == binop::W
|
||||
binop* bo = static_cast<binop*>(f2);
|
||||
if (bo->op() == binop::W
|
||||
&& syntactic_implication(f1, bo->first()))
|
||||
{
|
||||
result_ = f2;
|
||||
|
|
@ -277,22 +278,21 @@ namespace spot
|
|||
f2->destroy();
|
||||
return;
|
||||
}
|
||||
/* b < a => a M (b M c) = b M c */
|
||||
if (f2->kind() == formula::BinOp)
|
||||
{
|
||||
binop* bo = dynamic_cast<binop*>(f2);
|
||||
if (bo && bo->op() == binop::M
|
||||
/* b < a => a M (b M c) = b M c */
|
||||
binop* bo = static_cast<binop*>(f2);
|
||||
if (bo->op() == binop::M
|
||||
&& syntactic_implication(bo->first(), f1))
|
||||
{
|
||||
result_ = f2;
|
||||
f1->destroy();
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
/* a < b => a M (b M c) = a M c */
|
||||
/* a < b => a M (b R c) = a M c */
|
||||
{
|
||||
binop* bo = dynamic_cast<binop*>(f2);
|
||||
if (bo && (bo->op() == binop::M || bo->op() == binop::R)
|
||||
if ((bo->op() == binop::M || bo->op() == binop::R)
|
||||
&& syntactic_implication(f1, bo->first()))
|
||||
{
|
||||
result_ = binop::instance(binop::M, f1,
|
||||
|
|
|
|||
|
|
@ -96,8 +96,10 @@ namespace spot
|
|||
return;
|
||||
case unop::X:
|
||||
{
|
||||
const unop* op = dynamic_cast<const unop*>(f);
|
||||
if (op && op->op() == unop::X)
|
||||
if (f->kind() != formula::UnOp)
|
||||
return;
|
||||
const unop* op = static_cast<const unop*>(f);
|
||||
if (op->op() == unop::X)
|
||||
result_ = syntactic_implication(op->child(), f1);
|
||||
}
|
||||
return;
|
||||
|
|
@ -124,8 +126,6 @@ namespace spot
|
|||
{
|
||||
const formula* f1 = bo->first();
|
||||
const formula* f2 = bo->second();
|
||||
const binop* fb = dynamic_cast<const binop*>(f);
|
||||
const unop* fu = dynamic_cast<const unop*>(f);
|
||||
switch (bo->op())
|
||||
{
|
||||
case binop::Xor:
|
||||
|
|
@ -141,39 +141,55 @@ namespace spot
|
|||
result_ = true;
|
||||
return;
|
||||
case binop::R:
|
||||
if (fb && fb->op() == binop::R)
|
||||
if (syntactic_implication(fb->first(), f1) &&
|
||||
syntactic_implication(fb->second(), f2))
|
||||
if (f->kind() == formula::BinOp)
|
||||
{
|
||||
const binop* fb = static_cast<const binop*>(f);
|
||||
if (fb->op() == binop::R
|
||||
&& syntactic_implication(fb->first(), f1)
|
||||
&& syntactic_implication(fb->second(), f2))
|
||||
{
|
||||
result_ = true;
|
||||
return;
|
||||
}
|
||||
if (fu && fu->op() == unop::G)
|
||||
if (f1 == constant::false_instance() &&
|
||||
syntactic_implication(fu->child(), f2))
|
||||
}
|
||||
if (f->kind() == formula::UnOp)
|
||||
{
|
||||
const unop* fu = static_cast<const unop*>(f);
|
||||
if (fu->op() == unop::G
|
||||
&& f1 == constant::false_instance()
|
||||
&& syntactic_implication(fu->child(), f2))
|
||||
{
|
||||
result_ = true;
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (syntactic_implication(f, f1)
|
||||
&& syntactic_implication(f, f2))
|
||||
result_ = true;
|
||||
return;
|
||||
case binop::M:
|
||||
if (fb && fb->op() == binop::M)
|
||||
if (syntactic_implication(fb->first(), f1) &&
|
||||
syntactic_implication(fb->second(), f2))
|
||||
if (f->kind() == formula::BinOp)
|
||||
{
|
||||
const binop* fb = static_cast<const binop*>(f);
|
||||
if (fb->op() == binop::M
|
||||
&& syntactic_implication(fb->first(), f1)
|
||||
&& syntactic_implication(fb->second(), f2))
|
||||
{
|
||||
result_ = true;
|
||||
return;
|
||||
}
|
||||
if (fu && fu->op() == unop::F)
|
||||
if (f2 == constant::true_instance() &&
|
||||
syntactic_implication(fu->child(), f1))
|
||||
}
|
||||
if (f->kind() == formula::UnOp)
|
||||
{
|
||||
const unop* fu = static_cast<const unop*>(f);
|
||||
if (fu->op() == unop::F
|
||||
&& f2 == constant::true_instance()
|
||||
&& syntactic_implication(fu->child(), f1))
|
||||
{
|
||||
result_ = true;
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (syntactic_implication(f, f1)
|
||||
&& syntactic_implication(f, f2))
|
||||
result_ = true;
|
||||
|
|
@ -238,8 +254,10 @@ namespace spot
|
|||
bool
|
||||
special_case(const binop* f2)
|
||||
{
|
||||
const binop* fb = dynamic_cast<const binop*>(f);
|
||||
if (fb && fb->op() == f2->op()
|
||||
if (f->kind() != formula::BinOp)
|
||||
return false;
|
||||
const binop* fb = static_cast<const binop*>(f);
|
||||
if (fb->op() == f2->op()
|
||||
&& syntactic_implication(f2->first(), fb->first())
|
||||
&& syntactic_implication(f2->second(), fb->second()))
|
||||
return true;
|
||||
|
|
@ -249,10 +267,9 @@ namespace spot
|
|||
bool
|
||||
special_case_check(const formula* f2)
|
||||
{
|
||||
const binop* f2b = dynamic_cast<const binop*>(f2);
|
||||
if (!f2b)
|
||||
if (f2->kind() != formula::BinOp)
|
||||
return false;
|
||||
return special_case(f2b);
|
||||
return special_case(static_cast<const binop*>(f2));
|
||||
}
|
||||
|
||||
int
|
||||
|
|
@ -307,9 +324,10 @@ namespace spot
|
|||
result_ = true;
|
||||
return;
|
||||
case unop::X:
|
||||
if (f->kind() == formula::UnOp)
|
||||
{
|
||||
const unop* op = dynamic_cast<const unop*>(f);
|
||||
if (op && op->op() == unop::X)
|
||||
const unop* op = static_cast<const unop*>(f);
|
||||
if (op->op() == unop::X)
|
||||
result_ = syntactic_implication(f1, op->child());
|
||||
}
|
||||
return;
|
||||
|
|
@ -367,8 +385,6 @@ namespace spot
|
|||
|
||||
const formula* f1 = bo->first();
|
||||
const formula* f2 = bo->second();
|
||||
const binop* fb = dynamic_cast<const binop*>(f);
|
||||
const unop* fu = dynamic_cast<const unop*>(f);
|
||||
switch (bo->op())
|
||||
{
|
||||
case binop::Xor:
|
||||
|
|
@ -380,63 +396,87 @@ namespace spot
|
|||
return;
|
||||
case binop::U:
|
||||
/* (a < c) && (c < d) => a U b < c U d */
|
||||
if (fb && fb->op() == binop::U)
|
||||
if (syntactic_implication(f1, fb->first()) &&
|
||||
syntactic_implication(f2, fb->second()))
|
||||
if (f->kind() == formula::BinOp)
|
||||
{
|
||||
const binop* fb = static_cast<const binop*>(f);
|
||||
if (fb->op() == binop::U
|
||||
&& syntactic_implication(f1, fb->first())
|
||||
&& syntactic_implication(f2, fb->second()))
|
||||
{
|
||||
result_ = true;
|
||||
return;
|
||||
}
|
||||
if (fu && fu->op() == unop::F)
|
||||
if (f1 == constant::true_instance() &&
|
||||
syntactic_implication(f2, fu->child()))
|
||||
}
|
||||
if (f->kind() == formula::UnOp)
|
||||
{
|
||||
const unop* fu = static_cast<const unop*>(f);
|
||||
if (fu->op() == unop::F
|
||||
&& f1 == constant::true_instance()
|
||||
&& syntactic_implication(f2, fu->child()))
|
||||
{
|
||||
result_ = true;
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (syntactic_implication(f1, f)
|
||||
&& syntactic_implication(f2, f))
|
||||
result_ = true;
|
||||
return;
|
||||
case binop::W:
|
||||
/* (a < c) && (c < d) => a W b < c W d */
|
||||
if (fb && fb->op() == binop::W)
|
||||
if (syntactic_implication(f1, fb->first()) &&
|
||||
syntactic_implication(f2, fb->second()))
|
||||
if (f->kind() == formula::BinOp)
|
||||
{
|
||||
const binop* fb = static_cast<const binop*>(f);
|
||||
if (fb->op() == binop::W
|
||||
&& syntactic_implication(f1, fb->first())
|
||||
&& syntactic_implication(f2, fb->second()))
|
||||
{
|
||||
result_ = true;
|
||||
return;
|
||||
}
|
||||
if (fu && fu->op() == unop::G)
|
||||
if (f2 == constant::false_instance() &&
|
||||
syntactic_implication(f1, fu->child()))
|
||||
}
|
||||
if (f->kind() == formula::UnOp)
|
||||
{
|
||||
const unop* fu = static_cast<const unop*>(f);
|
||||
if (fu && fu->op() == unop::G
|
||||
&& f2 == constant::false_instance()
|
||||
&& syntactic_implication(f1, fu->child()))
|
||||
{
|
||||
result_ = true;
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (syntactic_implication(f1, f)
|
||||
&& syntactic_implication(f2, f))
|
||||
result_ = true;
|
||||
return;
|
||||
case binop::R:
|
||||
if (fu && fu->op() == unop::G)
|
||||
if (f1 == constant::false_instance() &&
|
||||
syntactic_implication(f2, fu->child()))
|
||||
if (f->kind() == formula::UnOp)
|
||||
{
|
||||
const unop* fu = static_cast<const unop*>(f);
|
||||
if (fu->op() == unop::G
|
||||
&& f1 == constant::false_instance()
|
||||
&& syntactic_implication(f2, fu->child()))
|
||||
{
|
||||
result_ = true;
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (syntactic_implication(f2, f))
|
||||
result_ = true;
|
||||
return;
|
||||
case binop::M:
|
||||
if (fu && fu->op() == unop::F)
|
||||
if (f2 == constant::true_instance() &&
|
||||
syntactic_implication(f1, fu->child()))
|
||||
if (f->kind() == formula::UnOp)
|
||||
{
|
||||
const unop* fu = static_cast<const unop*>(f);
|
||||
if (fu->op() == unop::F
|
||||
&& f2 == constant::true_instance()
|
||||
&& syntactic_implication(f1, fu->child()))
|
||||
{
|
||||
result_ = true;
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (syntactic_implication(f2, f))
|
||||
result_ = true;
|
||||
return;
|
||||
|
|
|
|||
|
|
@ -188,7 +188,7 @@ namespace spot
|
|||
// a[*] is OK, no need to print {a}[*].
|
||||
// However want braces for {!a}[*], the only unary
|
||||
// operator that can be nested with [*].
|
||||
bool need_parent = !!dynamic_cast<const unop*>(bo->child());
|
||||
bool need_parent = (bo->child()->kind() == formula::UnOp);
|
||||
|
||||
if (need_parent || full_parent_)
|
||||
openp();
|
||||
|
|
@ -206,7 +206,7 @@ namespace spot
|
|||
top_level_ = false;
|
||||
// The parser treats F0, F1, G0, G1, X0, and X1 as atomic
|
||||
// propositions. So make sure we output F(0), G(1), etc.
|
||||
bool need_parent = !!dynamic_cast<const constant*>(uo->child());
|
||||
bool need_parent = (uo->child()->kind() == formula::Constant);
|
||||
bool top_level = top_level_;
|
||||
|
||||
if (full_parent_)
|
||||
|
|
@ -456,7 +456,7 @@ namespace spot
|
|||
case unop::X:
|
||||
// The parser treats X0, and X1 as atomic
|
||||
// propositions. So make sure we output X(0) and X(1).
|
||||
need_parent = !!dynamic_cast<const constant*>(uo->child());
|
||||
need_parent = (uo->child()->kind() == formula::Constant);
|
||||
if (full_parent_)
|
||||
need_parent = false;
|
||||
os_ << "X";
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue