Commit cb392101 authored by Alexandre Duret-Lutz's avatar Alexandre Duret-Lutz

kill the ltl namespace

* NEWS: Mention it.
* bench/stutter/stutter_invariance_formulas.cc,
bench/stutter/stutter_invariance_randomgraph.cc, doc/mainpage.dox,
doc/org/tut01.org, doc/org/tut02.org, doc/org/tut10.org, doc/tl/tl.tex,
iface/ltsmin/ltsmin.cc, iface/ltsmin/ltsmin.hh,
iface/ltsmin/modelcheck.cc, src/bin/autfilt.cc,
src/bin/common_aoutput.cc, src/bin/common_aoutput.hh,
src/bin/common_finput.cc, src/bin/common_finput.hh,
src/bin/common_output.cc, src/bin/common_output.hh, src/bin/common_r.hh,
src/bin/common_trans.cc, src/bin/common_trans.hh, src/bin/dstar2tgba.cc,
src/bin/genltl.cc, src/bin/ltl2tgba.cc, src/bin/ltl2tgta.cc,
src/bin/ltlcross.cc, src/bin/ltldo.cc, src/bin/ltlfilt.cc,
src/bin/ltlgrind.cc, src/bin/randaut.cc, src/bin/randltl.cc,
src/kripke/kripkeexplicit.cc, src/kripke/kripkeexplicit.hh,
src/kripkeparse/kripkeparse.yy, src/kripkeparse/public.hh,
src/ltlparse/fmterror.cc, src/ltlparse/ltlparse.yy,
src/ltlparse/ltlscan.ll, src/ltlparse/parsedecl.hh,
src/ltlparse/public.hh, src/parseaut/parseaut.yy,
src/parseaut/public.hh, src/tests/checkpsl.cc, src/tests/checkta.cc,
src/tests/complementation.cc, src/tests/consterm.cc,
src/tests/emptchk.cc, src/tests/equalsf.cc, src/tests/ikwiad.cc,
src/tests/kind.cc, src/tests/length.cc, src/tests/ltlprod.cc,
src/tests/ltlrel.cc, src/tests/parse.test,
src/tests/parse_print_test.cc, src/tests/randtgba.cc,
src/tests/readltl.cc, src/tests/reduc.cc, src/tests/syntimpl.cc,
src/tests/taatgba.cc, src/tests/tostring.cc, src/tests/tostring.test,
src/tl/apcollect.cc, src/tl/apcollect.hh, src/tl/contain.cc,
src/tl/contain.hh, src/tl/declenv.cc, src/tl/declenv.hh,
src/tl/defaultenv.cc, src/tl/defaultenv.hh, src/tl/dot.cc,
src/tl/dot.hh, src/tl/environment.hh, src/tl/exclusive.cc,
src/tl/exclusive.hh, src/tl/formula.cc, src/tl/formula.hh,
src/tl/length.cc, src/tl/length.hh, src/tl/mark.cc, src/tl/mark.hh,
src/tl/mutation.cc, src/tl/mutation.hh, src/tl/nenoform.cc,
src/tl/nenoform.hh, src/tl/print.cc, src/tl/print.hh,
src/tl/randomltl.cc, src/tl/randomltl.hh, src/tl/relabel.cc,
src/tl/relabel.hh, src/tl/remove_x.cc, src/tl/remove_x.hh,
src/tl/simpfg.cc, src/tl/simpfg.hh, src/tl/simplify.cc,
src/tl/simplify.hh, src/tl/snf.cc, src/tl/snf.hh, src/tl/unabbrev.cc,
src/tl/unabbrev.hh, src/twa/bdddict.cc, src/twa/bdddict.hh,
src/twa/bddprint.cc, src/twa/formula2bdd.cc, src/twa/formula2bdd.hh,
src/twa/taatgba.cc, src/twa/taatgba.hh, src/twa/twa.hh,
src/twa/twagraph.cc, src/twa/twagraph.hh, src/twaalgos/compsusp.cc,
src/twaalgos/compsusp.hh, src/twaalgos/ltl2taa.cc,
src/twaalgos/ltl2taa.hh, src/twaalgos/ltl2tgba_fm.cc,
src/twaalgos/ltl2tgba_fm.hh, src/twaalgos/minimize.cc,
src/twaalgos/minimize.hh, src/twaalgos/neverclaim.cc,
src/twaalgos/postproc.cc, src/twaalgos/postproc.hh,
src/twaalgos/powerset.cc, src/twaalgos/powerset.hh,
src/twaalgos/randomgraph.cc, src/twaalgos/randomgraph.hh,
src/twaalgos/relabel.cc, src/twaalgos/relabel.hh,
src/twaalgos/remprop.cc, src/twaalgos/remprop.hh, src/twaalgos/stats.cc,
src/twaalgos/stats.hh, src/twaalgos/stutter.cc, src/twaalgos/stutter.hh,
src/twaalgos/translate.cc, src/twaalgos/translate.hh,
wrap/python/spot_impl.i: Remove the ltl namespace.
parent 6ded5e75
......@@ -28,9 +28,9 @@ New in spot 1.99.3a (not yet released)
* The class hierarchy for temporal formulas has been entirely
rewritten. This change is actually quite massive (~13200 lines
removed, ~8200 lines added), and brings some nice benefits:
- LTL/PSL formulas are now represented by lightweight ltl::formula
objects (instead of ltl::formula* pointers) that perform
reference counting automatically.
- LTL/PSL formulas are now represented by lightweight formula
objects (instead of pointers to children of an abstract formula
class) that perform reference counting automatically.
- There is no hierachy anymore: all operators are represented by a
single type of node in the syntax tree, and an enumerator is
used to distinguish between operators.
......@@ -41,10 +41,13 @@ New in spot 1.99.3a (not yet released)
more friendly, and several algorithms that spanned a few pages
have been reduced to a few lines.
* The source directories ltlast/, ltlenv/, and ltlvisit/, have been
merged into a single tl/ directory (for temporal logic). This is
motivated by the fact that these formulas are not restricted to
LTL, and by the fact that we no longuer use the "visitor" pattern.
* Directories ltlast/, ltlenv/, and ltlvisit/, have been merged into
a single tl/ directory (for temporal logic). This is motivated by
the fact that these formulas are not restricted to LTL, and by the
fact that we no longuer use the "visitor" pattern.
* For similar reasons, the spot::ltl namespace has been merged
with the spot namespace.
New in spot 1.99.3 (2015-08-26)
......
......@@ -62,12 +62,12 @@ namespace
}
int
process_formula(spot::ltl::formula f, const char*, int)
process_formula(spot::formula f, const char*, int)
{
spot::twa_graph_ptr a = trans.run(f);
spot::twa_graph_ptr na = trans.run(spot::ltl::formula::Not(f));
spot::ltl::atomic_prop_set* ap = spot::ltl::atomic_prop_collect(f);
bdd apdict = spot::ltl::atomic_prop_collect_as_bdd(f, a);
spot::twa_graph_ptr na = trans.run(spot::formula::Not(f));
spot::atomic_prop_set* ap = spot::atomic_prop_collect(f);
bdd apdict = spot::atomic_prop_collect_as_bdd(f, a);
std::cout << formula << ',' << ap->size() << ',';
stats.print(a);
......
......@@ -55,7 +55,7 @@ main(int argc, char** argv)
constexpr unsigned n = 10;
// random ap set
auto ap = spot::ltl::create_atomic_prop_set(props_n);
auto ap = spot::create_atomic_prop_set(props_n);
// ap set as bdd
bdd apdict = bddtrue;
for (auto& i: ap)
......
......@@ -19,12 +19,12 @@
///
/// \section pointers Handy starting points
///
/// \li spot::ltl::formula Base class for an LTL or PSL formula.
/// \li spot::ltl::parse_infix_psl Parsing a text string into a
/// spot::ltl::formula.
/// \li spot::formula Base class for an LTL or PSL formula.
/// \li spot::parse_infix_psl Parsing a text string into a
/// spot::formula.
/// \li spot::twa Base class for Transition-based
/// ω-Automata.
/// \li spot::translator Convert a spot::ltl::formula into a
/// \li spot::translator Convert a spot::formula into a
/// spot::tgba.
/// \li spot::kripke Base class for Kripke structures.
/// \li spot::twa_product On-the-fly product of two spot::twa.
......
......@@ -71,8 +71,8 @@ exceptions.
int main()
{
print_latex_psl(std::cout, spot::ltl::parse_formula("[]<>p0 || <>[]p1")) << '\n';
spot::ltl::formula f = spot::ltl::parse_formula("& & G p0 p1 p2");
print_latex_psl(std::cout, spot::parse_formula("[]<>p0 || <>[]p1")) << '\n';
spot::formula f = spot::parse_formula("& & G p0 p1 p2");
print_lbt_ltl(std::cout, f) << '\n';
print_spin_ltl(std::cout, f, true) << '\n';
return 0;
......@@ -110,9 +110,9 @@ Here is how to call the infix parser explicitly,:
int main()
{
std::string input = "[]<>p0 || <>[]p1";
spot::ltl::parse_error_list pel;
spot::ltl::formula f = spot::ltl::parse_infix_psl(input, pel);
if (spot::ltl::format_parse_errors(std::cerr, input, pel))
spot::parse_error_list pel;
spot::formula f = spot::parse_infix_psl(input, pel);
if (spot::format_parse_errors(std::cerr, input, pel))
return 1;
print_latex_psl(std::cout, f) << '\n';
return 0;
......@@ -152,11 +152,11 @@ with the "fixed" formula if you wish. Here is an example:
int main()
{
std::string input = "(a U b))";
spot::ltl::parse_error_list pel;
spot::ltl::formula f = spot::ltl::parse_infix_psl(input, pel);
spot::parse_error_list pel;
spot::formula f = spot::parse_infix_psl(input, pel);
// Use std::cout instead of std::cerr because we can only
// show the output of std::cout in this documentation.
(void) spot::ltl::format_parse_errors(std::cout, input, pel);
(void) spot::format_parse_errors(std::cout, input, pel);
if (f == nullptr)
return 1;
std::cout << "Parsed formula: ";
......@@ -194,9 +194,9 @@ of =parse_infix_psl()=.
int main()
{
std::string input = "& & G p0 p1 p2";
spot::ltl::parse_error_list pel;
spot::ltl::formula f = spot::ltl::parse_prefix_ltl(input, pel);
if (spot::ltl::format_parse_errors(std::cerr, input, pel))
spot::parse_error_list pel;
spot::formula f = spot::parse_prefix_ltl(input, pel);
if (spot::format_parse_errors(std::cerr, input, pel))
return 1;
print_lbt_ltl(std::cout, f) << '\n';
print_spin_ltl(std::cout, f, true) << '\n';
......@@ -236,9 +236,9 @@ For instance, let's see what happens if a PSL formulas is passed to
int main()
{
std::string input = "{a*;b}<>->(a U (b & GF c))";
spot::ltl::parse_error_list pel;
spot::ltl::formula f = spot::ltl::parse_infix_psl(input, pel);
if (spot::ltl::format_parse_errors(std::cerr, input, pel))
spot::parse_error_list pel;
spot::formula f = spot::parse_infix_psl(input, pel);
if (spot::format_parse_errors(std::cerr, input, pel))
return 1;
print_spin_ltl(std::cout, f) << '\n';
return 0;
......@@ -266,9 +266,9 @@ The first is to simply diagnose non-LTL formulas.
int main()
{
std::string input = "{a*;b}<>->(a U (b & GF c))";
spot::ltl::parse_error_list pel;
spot::ltl::formula f = spot::ltl::parse_infix_psl(input, pel);
if (spot::ltl::format_parse_errors(std::cerr, input, pel))
spot::parse_error_list pel;
spot::formula f = spot::parse_infix_psl(input, pel);
if (spot::format_parse_errors(std::cerr, input, pel))
return 1;
if (!f.is_ltl_formula())
{
......@@ -296,13 +296,13 @@ prepared to reject the formula any way. In our example, we are lucky
int main()
{
std::string input = "{a*;b}<>->(a U (b & GF c))";
spot::ltl::parse_error_list pel;
spot::ltl::formula f = spot::ltl::parse_infix_psl(input, pel);
if (spot::ltl::format_parse_errors(std::cerr, input, pel))
spot::parse_error_list pel;
spot::formula f = spot::parse_infix_psl(input, pel);
if (spot::format_parse_errors(std::cerr, input, pel))
return 1;
if (!f.is_ltl_formula())
{
spot::ltl::ltl_simplifier simp;
spot::ltl_simplifier simp;
f = simp.simplify(f);
}
if (!f.is_ltl_formula())
......
......@@ -74,7 +74,7 @@ print(g.to_str('spin', True))
* C++
The =spot::ltl::relabeling_map= is just a =std::map= with a custom
The =spot::relabeling_map= is just a =std::map= with a custom
destructor.
#+BEGIN_SRC C++ :results verbatim :exports both
......@@ -87,12 +87,12 @@ destructor.
int main()
{
std::string input = "\"Proc@Here\" U (\"var > 10\" | \"var < 4\")";
spot::ltl::parse_error_list pel;
spot::ltl::formula f = spot::ltl::parse_infix_psl(input, pel);
if (spot::ltl::format_parse_errors(std::cerr, input, pel))
spot::parse_error_list pel;
spot::formula f = spot::parse_infix_psl(input, pel);
if (spot::format_parse_errors(std::cerr, input, pel))
return 1;
spot::ltl::relabeling_map m;
f = spot::ltl::relabel(f, spot::ltl::Pnn, &m);
spot::relabeling_map m;
f = spot::relabel(f, spot::Pnn, &m);
for (auto& i: m)
{
std::cout << "#define ";
......@@ -115,8 +115,8 @@ destructor.
** Two ways to name atomic propositions
Instead of =--relabel=pnn= (or =spot.Pnn=, or =spot::ltl::Pnn=), you can
actually use =--relabel=abc= (or =spot.Abc=, or =spot::ltl::Abc=) to have
Instead of =--relabel=pnn= (or =spot.Pnn=, or =spot::Pnn=), you can
actually use =--relabel=abc= (or =spot.Abc=, or =spot::Abc=) to have
the atomic propositions named =a=, =b=, =c=, etc.
** Relabeling Boolean sub-expressions
......
......@@ -137,9 +137,9 @@ never claim is done via the =print_never_claim= function.
int main()
{
std::string input = "[]<>p0 || <>[]p1";
spot::ltl::parse_error_list pel;
spot::ltl::formula f = spot::ltl::parse_infix_psl(input, pel);
if (spot::ltl::format_parse_errors(std::cerr, input, pel))
spot::parse_error_list pel;
spot::formula f = spot::parse_infix_psl(input, pel);
if (spot::format_parse_errors(std::cerr, input, pel))
return 1;
spot::translator trans;
trans.set_type(spot::postprocessor::BA);
......
......@@ -1001,7 +1001,7 @@ both right-associative, other have only $\IMPLIES$ as right-associative.
When Spot builds a formula (represented by an AST with shared
subtrees) it computes a set of properties for each node. These
properties can be queried from any \texttt{spot::ltl::formula}
properties can be queried from any \texttt{spot::formula}
instance using the following methods:
\noindent
......
......@@ -323,10 +323,10 @@ namespace spot
int
convert_aps(const ltl::atomic_prop_set* aps,
convert_aps(const atomic_prop_set* aps,
const spins_interface* d,
bdd_dict_ptr dict,
ltl::formula dead,
formula dead,
prop_set& out)
{
int errors = 0;
......@@ -353,7 +353,7 @@ namespace spot
enum_map[i].emplace(d->get_type_value_name(i, j), j);
}
for (ltl::atomic_prop_set::const_iterator ap = aps->begin();
for (atomic_prop_set::const_iterator ap = aps->begin();
ap != aps->end(); ++ap)
{
if (*ap == dead)
......@@ -602,7 +602,7 @@ namespace spot
public:
spins_kripke(const spins_interface* d, const bdd_dict_ptr& dict,
const spot::prop_set* ps, ltl::formula dead,
const spot::prop_set* ps, formula dead,
int compress)
: kripke(dict),
d_(d),
......@@ -1016,8 +1016,8 @@ namespace spot
kripke_ptr
load_ltsmin(const std::string& file_arg, const bdd_dict_ptr& dict,
const ltl::atomic_prop_set* to_observe,
const ltl::formula dead, int compress, bool verbose)
const atomic_prop_set* to_observe,
const formula dead, int compress, bool verbose)
{
std::string file;
if (file_arg.find_first_of("/\\") != std::string::npos)
......
......@@ -57,7 +57,7 @@ namespace spot
// \a verbose whether to output verbose messages
SPOT_API kripke_ptr
load_ltsmin(const std::string& file, const bdd_dict_ptr& dict,
const ltl::atomic_prop_set* to_observe,
ltl::formula dead = ltl::formula::tt(),
const atomic_prop_set* to_observe,
formula dead = formula::tt(),
int compress = 0, bool verbose = true);
}
......@@ -150,11 +150,11 @@ checked_main(int argc, char **argv)
if (argc != 3)
syntax(argv[0]);
spot::ltl::default_environment& env =
spot::ltl::default_environment::instance();
spot::default_environment& env =
spot::default_environment::instance();
spot::ltl::atomic_prop_set ap;
spot::atomic_prop_set ap;
auto dict = spot::make_bdd_dict();
spot::const_kripke_ptr model = nullptr;
spot::const_twa_ptr prop = nullptr;
......@@ -162,16 +162,16 @@ checked_main(int argc, char **argv)
spot::emptiness_check_instantiator_ptr echeck_inst = nullptr;
int exit_code = 0;
spot::postprocessor post;
spot::ltl::formula deadf = nullptr;
spot::ltl::formula f = nullptr;
spot::formula deadf = nullptr;
spot::formula f = nullptr;
if (!dead || !strcasecmp(dead, "true"))
{
deadf = spot::ltl::formula::tt();
deadf = spot::formula::tt();
}
else if (!strcasecmp(dead, "false"))
{
deadf = spot::ltl::formula::ff();
deadf = spot::formula::ff();
}
else
{
......@@ -193,9 +193,9 @@ checked_main(int argc, char **argv)
tm.start("parsing formula");
{
spot::ltl::parse_error_list pel;
f = spot::ltl::parse_infix_psl(argv[2], pel, env, false);
exit_code = spot::ltl::format_parse_errors(std::cerr, argv[2], pel);
spot::parse_error_list pel;
f = spot::parse_infix_psl(argv[2], pel, env, false);
exit_code = spot::format_parse_errors(std::cerr, argv[2], pel);
}
tm.stop("parsing formula");
......@@ -366,6 +366,6 @@ main(int argc, char **argv)
auto exit_code = checked_main(argc, argv);
// Additional checks to debug reference counts in formulas.
assert(spot::ltl::fnode::instances_check());
assert(spot::fnode::instances_check());
exit(exit_code);
}
......@@ -505,7 +505,7 @@ namespace
}
int
process_formula(spot::ltl::formula, const char*, int)
process_formula(spot::formula, const char*, int)
{
SPOT_UNREACHABLE();
}
......
......@@ -287,7 +287,7 @@ automaton_printer::automaton_printer(stat_style input)
void
automaton_printer::print(const spot::twa_graph_ptr& aut,
spot::ltl::formula f,
spot::formula f,
// Input location for errors and statistics.
const char* filename,
int loc,
......
......@@ -107,7 +107,7 @@ public:
std::ostream&
print(const spot::const_parsed_aut_ptr& haut,
const spot::const_twa_graph_ptr& aut,
spot::ltl::formula f,
spot::formula f,
const char* filename, int loc, double run_time)
{
filename_ = filename ? filename : "";
......@@ -225,7 +225,7 @@ public:
void
print(const spot::twa_graph_ptr& aut,
spot::ltl::formula f = nullptr,
spot::formula f = nullptr,
// Input location for errors and statistics.
const char* filename = nullptr,
int loc = -1,
......
......@@ -77,14 +77,14 @@ parse_opt_finput(int key, char* arg, struct argp_state*)
return 0;
}
spot::ltl::formula
parse_formula(const std::string& s, spot::ltl::parse_error_list& pel)
spot::formula
parse_formula(const std::string& s, spot::parse_error_list& pel)
{
if (lbt_input)
return spot::ltl::parse_prefix_ltl(s, pel);
return spot::parse_prefix_ltl(s, pel);
else
return spot::ltl::parse_infix_psl
(s, pel, spot::ltl::default_environment::instance(), false, lenient);
return spot::parse_infix_psl
(s, pel, spot::default_environment::instance(), false, lenient);
}
job_processor::job_processor()
......@@ -109,14 +109,14 @@ job_processor::process_string(const std::string& input,
const char* filename,
int linenum)
{
spot::ltl::parse_error_list pel;
spot::parse_error_list pel;
auto f = parse_formula(input, pel);
if (!f || !pel.empty())
{
if (filename)
error_at_line(0, 0, filename, linenum, "parse error:");
spot::ltl::format_parse_errors(std::cerr, input, pel);
spot::format_parse_errors(std::cerr, input, pel);
return 1;
}
return process_formula(f, filename, linenum);
......
......@@ -44,8 +44,8 @@ extern const struct argp finput_argp;
int parse_opt_finput(int key, char* arg, struct argp_state* state);
spot::ltl::formula
parse_formula(const std::string& s, spot::ltl::parse_error_list& error_list);
spot::formula
parse_formula(const std::string& s, spot::parse_error_list& error_list);
class job_processor
......@@ -58,7 +58,7 @@ public:
virtual ~job_processor();
virtual int
process_formula(spot::ltl::formula f,
process_formula(spot::formula f,
const char* filename = nullptr, int linenum = 0) = 0;
virtual int
......
......@@ -70,10 +70,10 @@ const struct argp output_argp = { options, parse_opt_output,
static
void
report_not_ltl(spot::ltl::formula f,
report_not_ltl(spot::formula f,
const char* filename, int linenum, const char* syn)
{
std::string s = spot::ltl::str_psl(f);
std::string s = spot::str_psl(f);
static const char msg[] =
"formula '%s' cannot be written %s's syntax because it is not LTL";
if (filename)
......@@ -84,36 +84,36 @@ report_not_ltl(spot::ltl::formula f,
std::ostream&
stream_formula(std::ostream& out,
spot::ltl::formula f, const char* filename, int linenum)
spot::formula f, const char* filename, int linenum)
{
switch (output_format)
{
case lbt_output:
if (f.is_ltl_formula())
spot::ltl::print_lbt_ltl(out, f);
spot::print_lbt_ltl(out, f);
else
report_not_ltl(f, filename, linenum, "LBT");
break;
case spot_output:
spot::ltl::print_psl(out, f, full_parenth);
spot::print_psl(out, f, full_parenth);
break;
case spin_output:
if (f.is_ltl_formula())
spot::ltl::print_spin_ltl(out, f, full_parenth);
spot::print_spin_ltl(out, f, full_parenth);
else
report_not_ltl(f, filename, linenum, "Spin");
break;
case wring_output:
if (f.is_ltl_formula())
spot::ltl::print_wring_ltl(out, f);
spot::print_wring_ltl(out, f);
else
report_not_ltl(f, filename, linenum, "Wring");
break;
case utf8_output:
spot::ltl::print_utf8_psl(out, f, full_parenth);
spot::print_utf8_psl(out, f, full_parenth);
break;
case latex_output:
spot::ltl::print_latex_psl(out, f, full_parenth);
spot::print_latex_psl(out, f, full_parenth);
break;
case count_output:
case quiet_output:
......@@ -124,7 +124,7 @@ stream_formula(std::ostream& out,
static void
stream_escapable_formula(std::ostream& os,
spot::ltl::formula f,
spot::formula f,
const char* filename, int linenum)
{
if (escape_csv)
......@@ -146,7 +146,7 @@ namespace
{
struct formula_with_location
{
spot::ltl::formula f;
spot::formula f;
const char* filename;
int line;
const char* prefix;
......@@ -260,7 +260,7 @@ parse_opt_output(int key, char* arg, struct argp_state*)
static void
output_formula(std::ostream& out,
spot::ltl::formula f,
spot::formula f,
const char* filename = nullptr, int linenum = 0,
const char* prefix = nullptr, const char* suffix = nullptr)
{
......@@ -286,7 +286,7 @@ void
}
void
output_formula_checked(spot::ltl::formula f,
output_formula_checked(spot::formula f,
const char* filename, int linenum,
const char* prefix, const char* suffix)
{
......
......@@ -43,20 +43,20 @@ int parse_opt_output(int key, char* arg, struct argp_state* state);
// Low-level output
std::ostream&
stream_formula(std::ostream& out,
spot::ltl::formula f, const char* filename, int linenum);
spot::formula f, const char* filename, int linenum);
void output_formula_checked(spot::ltl::formula f,
void output_formula_checked(spot::formula f,
const char* filename = nullptr, int linenum = 0,
const char* prefix = nullptr,
const char* suffix = nullptr);
class printable_formula:
public spot::printable_value<spot::ltl::formula>
public spot::printable_value<spot::formula>
{
public:
printable_formula&
operator=(spot::ltl::formula new_val)
operator=(spot::formula new_val)
{
val_ = new_val;
return *this;
......@@ -79,7 +79,7 @@ public:
std::ostream&
print(const spot::const_twa_graph_ptr& aut,
spot::ltl::formula f = nullptr,
spot::formula f = nullptr,
double run_time = -1.)
{
formula_ = f;
......
......@@ -44,4 +44,4 @@
extern int simplification_level;
void parse_r(const char* arg);
spot::ltl::ltl_simplifier_options simplifier_options();
spot::ltl_simplifier_options simplifier_options();
......@@ -290,16 +290,16 @@ translator_runner::formula() const
}
void
translator_runner::round_formula(spot::ltl::formula f, unsigned serial)
translator_runner::round_formula(spot::formula f, unsigned serial)
{
if (has('f') || has('F'))
string_ltl_spot = spot::ltl::str_psl(f, true);
string_ltl_spot = spot::str_psl(f, true);
if (has('s') || has('S'))
string_ltl_spin = spot::ltl::str_spin_ltl(f, true);
string_ltl_spin = spot::str_spin_ltl(f, true);
if (has('l') || has('L'))
string_ltl_lbt = spot::ltl::str_lbt_ltl(f);
string_ltl_lbt = spot::str_lbt_ltl(f);
if (has('w') || has('W'))
string_ltl_wring = spot::ltl::str_wring_ltl(f);
string_ltl_wring = spot::str_wring_ltl(f);
if (has('F'))
string_to_tmp(string_ltl_spot, serial, filename_ltl_spot);
if (has('S'))
......
......@@ -94,7 +94,7 @@ public:
bool no_output_allowed = false);
void string_to_tmp(std::string& str, unsigned n, std::string& tmpname);
const std::string& formula() const;
void round_formula(spot::ltl::formula f, unsigned serial);