Explicit automata can now have arbitrary logic formula on their

arcs.  ltl2tgba_fm benefits from this and join multiple arcs with
the same destination and acceptance conditions.
* src/tgba/formula2bdd.cc, src/tgba/formula2bdd.hh: New files.
* src/tgba/Makefile.am (tgba_HEADERS, libtgba_la_SOURCES): Add them.
* src/tgba/bddprint.cc, src/tgba/bddprint.hh (bdd_pring_formula,
bdd_format_formula): New functions.
* src/tgba/tgbaexplicit.hh (tgba_explicit::get_condition,
tgba_explicit::add_condition, tgba_explicit::add_neg_condition,
tgba_explicit::declare_accepting_condition,
tgba_explicit::has_accepting_condition,
tgba_explicit::get_accepting_condition,
tgba_explicit::add_accepting_condition): Take a const formula*.
* src/tgba/tgbaexplicit.cc (tgba_explicit::add_condition):
Rewrite using formula_to_bdd.
* src/tgbaalgos/dotty.cc (dotty_bfs::process_link): Use
bdd_print_formula to display conditions.
* src/tgbaalgos/save.cc (save_bfs::process_state): Likewise.
* src/tgbaalgos/ltl2tgba_fm.cc (translate_dict::bdd_to_formula):
New function.
(translate_dict::conj_bdd_to_atomic_props): Remove.
(ltl_to_tgba_fm): Factor successors on accepting conditions
and destinations, not conditions.  Use bdd_to_formula to translate
the conditions.
* src/tgbaparse/tgbaparse.yy: Expect conditions as a formula
in a string, call the LTL parser for this.
* src/tgbaparse/tgbascan.ll: Process " and \ escapes in
strings.
* src/tgbatest/emptchke.test, src/tgbatest/explicit.test,
src/tgbatest/explpro2.test, src/tgbatest/explpro3.test,
src/tgbatest/explprod.test, src/tgbatest/mixprod.test,
src/tgbatest/readsave.test, src/tgbatest/tgbaread.test,
src/tgbatest/tripprod.test: Adjust to new syntax for explicit
automata.

src/tgbatest/emptchke.test

@@ -27,8 +27,8 @@ set -e
 
 cat >input <<'EOF'
 acc = c d;
-s1, "s2", a!b, c d;
-"s2", "state 3", a, c;
+s1, "s2", "a & !b", c d;
+"s2", "state 3", "a", c;
 "state 3", s1,,;
 EOF
 

src/tgbatest/explicit.test

@@ -32,11 +32,11 @@ digraph G {
   0 [label="", style=invis, height=0]
   0 -> 1
   1 [label="state 0"]
-  1 -> 2 [label="T\n<Acc[p]:0, Acc[q]:1, Acc[r]:0><Acc[p]:1, Acc[q]:0, Acc[r]:0>"]
+  1 -> 2 [label="1\n<Acc[p]:0, Acc[q]:1, Acc[r]:0><Acc[p]:1, Acc[q]:0, Acc[r]:0>"]
   2 [label="state 1"]
-  2 -> 3 [label="<a:1>\n<Acc[p]:0, Acc[q]:0, Acc[r]:1>"]
+  2 -> 3 [label="a\n<Acc[p]:0, Acc[q]:0, Acc[r]:1>"]
   3 [label="state 2"]
-  3 -> 1 [label="<b:1, c:1>\nF"]
+  3 -> 1 [label="(b & c)\nF"]
 }
 EOF
 

src/tgbatest/explpro2.test

@@ -27,27 +27,27 @@ set -e
 
 cat >input1 <<EOF
 acc = p1 p2;
-s1, s2, !a, p1;
-s1, s3, !b, p2;
+s1, s2, "!a", p1;
+s1, s3, "!b", p2;
 EOF
 
 cat >input2 <<EOF
 acc = p2 p3;
-s1, s2, b, p2;
-s1, s3, a, p3;
+s1, s2, "b", p2;
+s1, s3, "a", p3;
 EOF
 
 cat >expected <<EOF
 acc = "p1" "p2" "p3";
-"s1 * s1", "s2 * s2", ! a b,  "p1" "p2";
-"s1 * s1", "s3 * s3", a ! b,  "p2" "p3";
+"s1 * s1", "s2 * s2", "(!a & b)",  "p1" "p2";
+"s1 * s1", "s3 * s3", "(a & !b)",  "p2" "p3";
 EOF
 
 ./explprod input1 input2 > stdout
 
 # Sort out some possible inversions in the output.
 # (The order is not guaranteed by SPOT.)
-perl -pe 's/("\w+") ("\w+")(?: ("\w+"))?/@{[sort $1, $2, $3]}/g' \
+perl -pe 's/("\w+") ("\w+")(?: ("\w+"))?/@{[sort $1, $2, $3]}/g;s/\(!b & a\)/(a & !b)/g;s/\(!c & a\)/(a & !c)/g' \
   stdout > tmp_ && mv tmp_ stdout
 
 cat stdout

src/tgbatest/explpro3.test

@@ -27,27 +27,27 @@ set -e
 
 cat >input1 <<EOF
 acc = ;
-s1, s2, !a,;
-s1, s3, !b,;
+s1, s2, "!a",;
+s1, s3, "!b",;
 EOF
 
 cat >input2 <<EOF
 acc = p2 p3;
-s1, s2, b, p2;
-s1, s3, a, p3;
+s1, s2, "b", p2;
+s1, s3, "a", p3;
 EOF
 
 cat >expected <<EOF
 acc = "p2" "p3";
-"s1 * s1", "s2 * s2", ! a b, "p2";
-"s1 * s1", "s3 * s3", a ! b, "p3";
+"s1 * s1", "s2 * s2", "(!a & b)", "p2";
+"s1 * s1", "s3 * s3", "(a & !b)", "p3";
 EOF
 
 ./explprod input1 input2 > stdout
 
 # Sort out some possible inversions in the output.
 # (The order is not guaranteed by SPOT.)
-sed 's/"p3" "p2"/"p2" "p3"/g' stdout > tmp_ && mv tmp_ stdout
+sed 's/"p3" "p2"/"p2" "p3"/g;s/(!b & a)/(a \& !b)/g' stdout > tmp_ && mv tmp_ stdout
 
 cat stdout
 diff stdout expected

src/tgbatest/explprod.test

@@ -27,29 +27,29 @@ set -e
 
 cat >input1 <<EOF
 acc = p1;
-s1, s3, a, true;
-s1, s2, b, p1;
-s2, s1, !a, true;
-s2, s3, c, true;
+s1, s3, "a", true;
+s1, s2, "b", p1;
+s2, s1, "!a", true;
+s2, s3, "c", true;
 EOF
 
 cat >input2 <<EOF
 acc=p2 p3;
-s1, s2, b, p2;
-s2, s1, a, p3;
+s1, s2, "b", p2;
+s2, s1, "a", p3;
 EOF
 
 cat >expected <<EOF
 acc = "p1" "p2" "p3";
-"s1 * s1", "s3 * s2", a b,  "p1" "p2";
-"s1 * s1", "s2 * s2", b,  "p1" "p2";
-"s2 * s2", "s3 * s1", a c,  "p1" "p3";
+"s1 * s1", "s3 * s2", "(a & b)",  "p1" "p2";
+"s1 * s1", "s2 * s2", "b",  "p1" "p2";
+"s2 * s2", "s3 * s1", "(a & c)",  "p1" "p3";
 EOF
 
 ./explprod input1 input2 > stdout
 # Sort out some possible inversions in the output.
 # (The order is not guaranteed by SPOT.)
-perl -pe 's/("\w+") ("\w+")(?: ("\w+"))?/@{[sort $1, $2, $3]}/g' \
+perl -pe 's/("\w+") ("\w+")(?: ("\w+"))?/@{[sort $1, $2, $3]}/g;s/\(c & a\)/(a & c)/g;s/\(b & a\)/(a & b)/g' \
   stdout > tmp_ && mv tmp_ stdout
 
 cat stdout

src/tgbatest/mixprod.test

@@ -30,10 +30,10 @@ set -e
 
 cat >input1 <<EOF
 acc = p1;
-s1, s3, a,;
-s1, s2, b, p1;
-s2, s1, !a,;
-s2, s3, c,;
+s1, s3, "a",;
+s1, s2, "b", p1;
+s2, s1, "!a",;
+s2, s3, "c",;
 EOF
 
 ./mixprod 'F(a U b) & Xa' input1 >stdout

src/tgbatest/readsave.test

@@ -27,8 +27,8 @@ set -e
 
 cat >input <<EOF
 acc = c d;
-s1, "s2", a!b, c d;
-"s2", "state 3", a, c;
+s1, "s2", "a&!b", c d;
+"s2", "state 3", "a", c;
 "state 3", s1,,;
 EOF
 
@@ -36,14 +36,14 @@ EOF
 
 cat >expected <<EOF
 acc = "c" "d";
-"s1", "s2", a ! b, "c" "d";
-"s2", "state 3", a, "c";
-"state 3", "s1", ,;
+"s1", "s2", "(a & !b)", "c" "d";
+"s2", "state 3", "a", "c";
+"state 3", "s1", "1",;
 EOF
 
 # Sort out some possible inversions in the output.
 # (The order is not guaranteed by SPOT.)
-sed 's/"d" "c"/"c" "d"/g' stdout > tmp_ && mv tmp_ stdout
+sed 's/"d" "c"/"c" "d"/g;s/!b & a/a \& !b/g' stdout > tmp_ && mv tmp_ stdout
 
 diff stdout expected
 
@@ -52,7 +52,7 @@ mv stdout input
 
 # Sort out some possible inversions in the output.
 # (The order is not guaranteed by SPOT.)
-sed 's/"d" "c"/"c" "d"/g' stdout > tmp_ && mv tmp_ stdout
+sed 's/"d" "c"/"c" "d"/g;s/!b & a/a \& !b/g' stdout > tmp_ && mv tmp_ stdout
 
 diff input stdout
 

src/tgbatest/tgbaread.test

@@ -27,8 +27,8 @@ set -e
 
 cat >input <<EOF
 acc = c d;
-s1, "s2", a!b, c d;
-"s2", "state 3", a, c;
+s1, "s2", "a & !b", c d;
+"s2", "state 3", "a", c;
 "state 3", s1,,;
 EOF
 
@@ -39,14 +39,17 @@ digraph G {
   0 [label="", style=invis, height=0]
   0 -> 1
   1 [label="s1"]
-  1 -> 2 [label="<a:1, b:0>\n<Acc[c]:0, Acc[d]:1><Acc[c]:1, Acc[d]:0>"]
+  1 -> 2 [label="(a & !b)\n<Acc[c]:0, Acc[d]:1><Acc[c]:1, Acc[d]:0>"]
   2 [label="s2"]
-  2 -> 3 [label="<a:1>\n<Acc[c]:1, Acc[d]:0>"]
+  2 -> 3 [label="a\n<Acc[c]:1, Acc[d]:0>"]
   3 [label="state 3"]
-  3 -> 1 [label="T\nF"]
+  3 -> 1 [label="1\nF"]
 }
 EOF
 
+# Sort out some possible inversions in the output.
+# (The order is not guaranteed by SPOT.)
+sed 's/!b & a/a \& !b/g' stdout > tmp_ && mv tmp_ stdout
 diff stdout expected
 
 rm input stdout expected

src/tgbatest/tripprod.test

@@ -27,41 +27,41 @@ set -e
 
 cat >input1 <<EOF
 acc = p1;
-s1, s3, a, true;
-s1, s2, b, p1;
-s2, s1, !a, true;
-s2, s3, c,;
+s1, s3, "a", true;
+s1, s2, "b", p1;
+s2, s1, "!a", true;
+s2, s3, "c",;
 EOF
 
 cat >input2 <<EOF
 acc = p2 p3;
-s1, s2, b, p2;
-s2, s1, a, p3;
+s1, s2, "b", p2;
+s2, s1, "a", p3;
 EOF
 
 cat >input3 <<EOF
 acc = p4;
-s1, s2, a,;
-s1, s3, b,;
+s1, s2, "a",;
+s1, s3, "b",;
 s3, s2,, p4;
 s2, s3,, p4;
 EOF
 
 cat >expected <<EOF
 acc = "p1" "p2" "p3" "p4";
-"s1 * s1 * s1", "s3 * s2 * s2", a b,   "p1" "p2";
-"s1 * s1 * s1", "s2 * s2 * s2", a b,   "p1" "p2";
-"s1 * s1 * s1", "s3 * s2 * s3", a b,   "p1" "p2";
-"s1 * s1 * s1", "s2 * s2 * s3", b,   "p1" "p2";
-"s2 * s2 * s2", "s3 * s1 * s3", a c,   "p3" "p4";
-"s2 * s2 * s3", "s3 * s1 * s2", a c,   "p3" "p4";
+"s1 * s1 * s1", "s3 * s2 * s2", "(a & b)",   "p1" "p2";
+"s1 * s1 * s1", "s2 * s2 * s2", "(a & b)",   "p1" "p2";
+"s1 * s1 * s1", "s3 * s2 * s3", "(a & b)",   "p1" "p2";
+"s1 * s1 * s1", "s2 * s2 * s3", "b",   "p1" "p2";
+"s2 * s2 * s2", "s3 * s1 * s3", "(a & c)",   "p3" "p4";
+"s2 * s2 * s3", "s3 * s1 * s2", "(a & c)",   "p3" "p4";
 EOF
 
 ./tripprod input1 input2 input3 > stdout
 
 # Sort out some possible inversions in the output.
 # (The order is not guaranteed by SPOT.)
-perl -pe 's/c a/a c/g;s/b a/a b/g;s/("\w+") ("\w+")(?: ("\w+"))?(?: ("\w+"))?/@{[sort $1, $2, $3, $4]}/g' \
+perl -pe 's/("\w+") ("\w+")(?: ("\w+"))?(?: ("\w+"))?/@{[sort $1, $2, $3, $4]}/g;s/\(c & a\)/(a & c)/g;s/\(b & a\)/(a & b)/g' \
   stdout > tmp_ &&
   mv tmp_ stdout