Modify the ELTL parser to be able to support PSL operators. Add a

new keyword in the ELTL format: finish, which applies to an
automaton operator and tells whether it just completed.

* src/eltlparse/eltlparse.yy: Clean it. Add finish.
* src/eltlparse/eltlscan.ll: Add finish.
* src/formula_tree.cc, src/formula_tree.hh: New files. Define a
small AST representing formulae where atomic props are unknown
which is used in the ELTL parser.
* src/ltlast/automatop.cc, ltlast/automatop.hh, ltlast/nfa.cc,
ltlast/nfa.hh: Adjust.
* src/ltlast/unop.cc, src/ltlast/unop.hh: Finish is an unop.
* src/ltlvisit/basicreduce.cc, src/ltlvisit/nenoform.cc,
src/ltlvisit/reduce.cc, src/ltlvisit/syntimpl.cc,
src/ltlvisit/tostring.cc, src/ltlvisit/tunabbrev.cc,
src/tgba/formula2bdd.cc, src/tgbaalgos/ltl2tgba_fm.cc,
src/tgbaalgos/ltl2tgba_lacim.cc: Handle finish in switches.
* src/tgbaalgos/eltl2tgba_lacim.cc: Translate finish.
* src/tgbatest/eltl2tgba.test: More tests.

src/ltlast/Makefile.am

@@ -31,6 +31,7 @@ ltlast_HEADERS = \
   binop.hh \
   constant.hh \
   formula.hh \
+  formula_tree.hh \
   multop.hh \
   nfa.hh \
   predecl.hh \
@@ -45,6 +46,7 @@ libltlast_la_SOURCES = \
   binop.cc \
   constant.cc \
   formula.cc \
+  formula_tree.cc \
   multop.cc \
   nfa.cc \
   refformula.cc \

src/ltlast/automatop.cc

@@ -21,6 +21,7 @@
 
 #include <iostream>
 #include "automatop.hh"
+#include "nfa.hh"
 #include "visitor.hh"
 
 namespace spot

src/ltlast/automatop.hh

@@ -88,11 +88,11 @@ namespace spot
       typedef std::map<triplet, formula*, paircmp> map;
       static map instances;
 
-      automatop(const nfa::ptr nfa, vec* v, bool negated);
+      automatop(const nfa::ptr, vec* v, bool negated);
       virtual ~automatop();
 
     private:
-      nfa::ptr nfa_;
+      const nfa::ptr nfa_;
       vec* children_;
       bool negated_;
     };

src/ltlast/formula_tree.cc

@@ -0,0 +1,88 @@
+// Copyright (C) 2009 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.
+//
+// Spot is free software; you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// Spot is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
+// License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Spot; see the file COPYING.  If not, write to the Free
+// Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+// 02111-1307, USA.
+
+#include <cassert>
+#include "formula_tree.hh"
+#include "allnodes.hh"
+#include "ltlvisit/clone.hh"
+
+namespace spot
+{
+  namespace ltl
+  {
+    namespace formula_tree
+    {
+      formula*
+      instanciate(const node_ptr np, const std::vector<formula*>& v)
+      {
+	if (node_atomic* n = dynamic_cast<node_atomic*>(np.get()))
+	  return n->i == True ? constant::true_instance() :
+	    n->i == False ? constant::false_instance() : clone(v.at(n->i));
+
+	if (node_unop* n = dynamic_cast<node_unop*>(np.get()))
+	  return unop::instance(n->op, instanciate(n->child, v));
+	if (node_nfa* n = dynamic_cast<node_nfa*>(np.get()))
+	{
+	  automatop::vec* va = new automatop::vec;
+	  std::vector<node_ptr>::const_iterator i = n->children.begin();
+	  while (i != n->children.end())
+	    va->push_back(instanciate(*i++, v));
+	  return automatop::instance(n->nfa, va, false);
+	}
+	if (node_binop* n = dynamic_cast<node_binop*>(np.get()))
+	  return binop::instance(n->op,
+				 instanciate(n->lhs, v),
+				 instanciate(n->rhs, v));
+	if (node_multop* n = dynamic_cast<node_multop*>(np.get()))
+	  return multop::instance(n->op,
+				  instanciate(n->lhs, v),
+				  instanciate(n->rhs, v));
+
+	/* Unreachable code.  */
+	assert(0);
+      }
+
+      size_t
+      arity(const node_ptr np)
+      {
+	if (node_atomic* n = dynamic_cast<node_atomic*>(np.get()))
+	  return std::max(n->i + 1, 0);
+	if (node_unop* n = dynamic_cast<node_unop*>(np.get()))
+	  return arity(n->child);
+	if (node_nfa* n = dynamic_cast<node_nfa*>(np.get()))
+	{
+	  size_t res = 0;
+	  std::vector<node_ptr>::const_iterator i = n->children.begin();
+	  while (i != n->children.end())
+	    res = std::max(arity(*i++), res);
+	  return res;
+	}
+	if (node_binop* n = dynamic_cast<node_binop*>(np.get()))
+	  return std::max(arity(n->lhs), arity(n->rhs));
+	if (node_multop* n = dynamic_cast<node_multop*>(np.get()))
+	  return std::max(arity(n->lhs), arity(n->rhs));
+
+	/* Unreachable code.  */
+	assert(0);
+      }
+    }
+  }
+}

src/ltlast/formula_tree.hh

@@ -0,0 +1,88 @@
+// Copyright (C) 2009 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.
+//
+// Spot is free software; you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// Spot is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
+// License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Spot; see the file COPYING.  If not, write to the Free
+// Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+// 02111-1307, USA.
+
+/// \file ltlast/formula_tree.hh
+/// \brief Trees representing formulae where atomic propositions are unknown
+#ifndef SPOT_LTLAST_FORMULA_TREE_HH
+# define SPOT_LTLAST_FORMULA_TREE_HH
+
+# include <vector>
+# include <boost/shared_ptr.hpp>
+# include "formula.hh"
+# include "multop.hh"
+# include "binop.hh"
+# include "unop.hh"
+# include "nfa.hh"
+
+namespace spot
+{
+  namespace ltl
+  {
+    /// Trees representing formulae where atomic propositions are unknown.
+    namespace formula_tree
+    {
+      struct node
+      {
+	virtual ~node() {};
+      };
+      /// We use boost::shared_ptr to easily handle deletion.
+      typedef boost::shared_ptr<node> node_ptr;
+
+      struct node_unop : node
+      {
+	unop::type op;
+	node_ptr child;
+      };
+      struct node_binop : node
+      {
+	binop::type op;
+	node_ptr lhs;
+	node_ptr rhs;
+      };
+      struct node_multop : node
+      {
+	multop::type op;
+	node_ptr lhs;
+	node_ptr rhs;
+      };
+      struct node_nfa : node
+      {
+	std::vector<node_ptr> children;
+	spot::ltl::nfa::ptr nfa;
+      };
+      /// Integer values for True and False used in node_atomic.
+      enum { True = -1, False = -2 };
+      struct node_atomic : node
+      {
+	int i;
+      };
+
+      /// Instanciate the formula corresponding to the node with
+      /// atomic propositions taken from \a v.
+      formula* instanciate(const node_ptr np, const std::vector<formula*>& v);
+
+      /// Get the arity.
+      size_t arity(const node_ptr np);
+    }
+  }
+}
+
+#endif // SPOT_LTLAST_FORMULA_TREE_HH_

src/ltlast/nfa.cc

@@ -21,6 +21,7 @@
 
 #include <cassert>
 #include "nfa.hh"
+#include "formula_tree.hh"
 
 namespace spot
 {
@@ -61,15 +62,16 @@ namespace spot
     }
 
     void
-    nfa::add_transition(int src, int dst, int label)
+    nfa::add_transition(int src, int dst, const label lbl)
     {
       state* s = add_state(src);
       nfa::transition* t = new transition;
       t->dst = add_state(dst);
-      t->label = label;
+      t->lbl = lbl;
       s->push_back(t);
-      if (label >= arity_)
-	arity_ = label + 1;
+      size_t arity = formula_tree::arity(formula_tree::node_ptr(lbl));
+      if (arity >= arity_)
+	arity_ = arity;
     }
 
     void

src/ltlast/nfa.hh

@@ -36,31 +36,39 @@ namespace spot
   {
     /// Forward declaration. See below.
     class succ_iterator;
+    /// Forward declaration. NFA's labels are reprensented by nodes
+    /// which are defined in formula_tree.hh, included in nfa.cc.
+    namespace formula_tree
+    {
+      class node;
+    }
 
     /// \brief Nondeterministic Finite Automata used by automata operators.
     ///
-    /// States & labels are represented by integers.
+    /// States are represented by integers.
+    /// Labels are represented by formula_tree's nodes.
     /// Currently, only one initial state is possible.
     class nfa
     {
     public:
-      struct				transition;
-      typedef std::list<transition*>	state;
+      struct transition;
+      typedef std::list<transition*> state;
+      typedef boost::shared_ptr<formula_tree::node> label;
       /// Iterator over the successors of a state.
-      typedef succ_iterator		iterator;
-      typedef boost::shared_ptr<nfa>	ptr;
+      typedef succ_iterator iterator;
+      typedef boost::shared_ptr<nfa> ptr;
 
       /// Explicit transitions.
       struct transition
       {
-	int label;
+	label lbl;
       	const state* dst;
       };
 
       nfa();
       ~nfa();
 
-      void add_transition(int src, int dst, int label);
+      void add_transition(int src, int dst, const label lbl);
       void set_init_state(int name);
       void set_final(int name);
 
@@ -101,7 +109,7 @@ namespace spot
       is_map is_;
       si_map si_;
 
-      int arity_;
+      size_t arity_;
       std::string name_;
 
       state* init_;

src/ltlast/unop.cc

@@ -88,6 +88,8 @@ namespace spot
 	  return "F";
 	case G:
 	  return "G";
+	case Finish:
+	  return "Finish";
 	}
       // Unreachable code.
       assert(0);

src/ltlast/unop.hh

@@ -37,7 +37,7 @@ namespace spot
     class unop : public ref_formula
     {
     public:
-      enum type { Not, X, F, G };
+      enum type { Not, X, F, G, Finish }; // Finish is used in ELTL formulae.
 
       /// Build an unary operator with operation \a op and
       /// child \a child.