Add text I/O for Kripke structures.

* src/kripke/kripkeexplicit.cc, src/kripke/kripkeexplicit.hh,
src/kripke/kripkeprint.cc, src/kripke/kripkeprint.hh: New files.
* src/kripke/Makefile.am: Add them.
* src/kripkeparse/fmterror.cc, src/kripkeparse/kripkeparse.yy,
src/kripkeparse/kripkescan.ll, src/kripkeparse/parsedecl.hh,
src/kripkeparse/public.hh, src/kripkeparse/scankripke.ll: New
files.
* src/kripkeparse/Makefile.am: Add them.
* src/kripketest/bad_parsing.test, src/kripketest/defs.in,
src/kripketest/kripke.test, src/kripketest/origin,
src/kripketest/parse_print_test.cc: New files.
* src/kripketest/Makefile.am: Add them.
* src/Makefile.am (SUBDIRS): Add kripkeparse and kripketest.
* README: Document src/kripketest/ and src/kripkeparse/.
* configure.ac: Generate src/kripkeparse/Makefile,
src/kripketest/Makefile, src/kripketest/defs.
* iface/dve2/defs.in (run2): New function.
* iface/dve2/dve2check.cc (syntax, main): Add option -gK.
* iface/dve2/kripke.test: New file.
* iface/dve2/Makefile.am (TESTS): Add kripke.test.

src/kripke/Makefile.am

@@ -24,9 +24,13 @@ kripkedir = $(pkgincludedir)/kripke
 
 kripke_HEADERS = \
   fairkripke.hh \
-  kripke.hh
+  kripke.hh \
+  kripkeexplicit.hh \
+  kripkeprint.hh
 
 noinst_LTLIBRARIES = libkripke.la
 libkripke_la_SOURCES = \
   fairkripke.cc \
-  kripke.cc
+  kripke.cc \
+  kripkeexplicit.cc \
+  kripkeprint.cc

src/kripke/kripkeexplicit.cc

@@ -0,0 +1,290 @@
+// Copyright (C) 2011 Laboratoire de Recherche et Developpement
+// de l'Epita (LRDE)
+//
+// 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 "kripkeexplicit.hh"
+#include "../tgba/bddprint.hh"
+#include "tgba/formula2bdd.hh"
+#include <iostream>
+#include "../tgba/state.hh"
+
+namespace spot
+{
+
+  state_kripke::state_kripke()
+    : bdd_ (bddtrue)
+  {
+  }
+
+  void state_kripke::add_conditions(bdd f)
+  {
+    bdd_ &= f;
+  }
+
+  void state_kripke::add_succ(state_kripke* add_me)
+  {
+    // This method must add only state_kripke for now.
+    state_kripke* to_add = down_cast<state_kripke*>(add_me);
+    assert(to_add);
+    succ_.push_back(to_add);
+  }
+
+  int state_kripke::compare(const state* other) const
+  {
+    // This method should not be called to compare states from different
+    // automata, and all states from the same automaton will use the same
+    // state class.
+    const state_kripke* s = down_cast<const state_kripke*>(other);
+    assert(s);
+    return s - this;
+  }
+
+  size_t
+  state_kripke::hash() const
+  {
+    return
+    reinterpret_cast<const char*>(this) - static_cast<const char*>(0);
+  }
+
+  state_kripke*
+  state_kripke::clone() const
+  {
+    return const_cast<state_kripke*>(this);
+  }
+
+  ////////////////////////////
+  // Support for succ_iterator
+
+  const std::list<state_kripke*>&
+  state_kripke::get_succ() const
+  {
+    return succ_;
+  }
+
+
+
+
+
+
+
+
+
+  /////////////////////////////////////
+  // kripke_explicit_succ_iterator
+
+  kripke_explicit_succ_iterator::kripke_explicit_succ_iterator
+  (const state_kripke* s, bdd cond)
+    : kripke_succ_iterator(cond),
+      s_(s)
+  {
+  }
+
+
+  kripke_explicit_succ_iterator::~kripke_explicit_succ_iterator()
+  {
+  }
+
+  void kripke_explicit_succ_iterator::first()
+  {
+    it_ = s_->get_succ().begin();
+  }
+
+  void kripke_explicit_succ_iterator::next()
+  {
+    ++it_;
+  }
+
+  bool kripke_explicit_succ_iterator::done() const
+  {
+    return it_ == s_->get_succ().end();
+  }
+
+  state_kripke* kripke_explicit_succ_iterator::current_state() const
+  {
+    assert(!done());
+    return *it_;
+  }
+
+  /////////////////////////////////////
+  // kripke_explicit
+
+
+  kripke_explicit::kripke_explicit(bdd_dict* dict)
+    : dict_(dict),
+      init_(0)
+  {
+  }
+
+  kripke_explicit::kripke_explicit(bdd_dict* dict,
+                                   state_kripke*  init)
+    : dict_(dict),
+      init_ (init)
+  {
+  }
+
+
+  std::string
+  kripke_explicit::format_state(const spot::state* s) const
+  {
+    assert(s);
+    const state_kripke* se = down_cast<const state_kripke*>(s);
+    assert(se);
+    std::map<const state_kripke*, std::string>::const_iterator it =
+      sn_nodes_.find (se);
+    assert(it != sn_nodes_.end());
+    return it->second;
+  }
+
+  kripke_explicit::~kripke_explicit()
+  {
+    dict_->unregister_all_my_variables(this);
+    std::map<const std::string, state_kripke*>::iterator it;
+    for (it = ns_nodes_.begin(); it != ns_nodes_.end(); it++)
+    {
+      state_kripke* del_me = it->second;
+      delete del_me;
+    }
+  }
+
+  state_kripke*
+  kripke_explicit::get_init_state() const
+  {
+    return init_;
+  }
+
+  bdd_dict*
+  kripke_explicit::get_dict() const
+  {
+    return dict_;
+  }
+
+  // FIXME : Change the bddtrue.
+  kripke_explicit_succ_iterator*
+  kripke_explicit::succ_iter(const spot::state* local_state,
+                            const spot::state* global_state,
+                            const tgba* global_automaton) const
+  {
+    const state_kripke* s = down_cast<const state_kripke*>(local_state);
+    assert(s);
+    (void) global_state;
+    (void) global_automaton;
+    state_kripke* it = const_cast<state_kripke*>(s);
+    return new kripke_explicit_succ_iterator(it, bddtrue);
+  }
+
+  bdd
+  kripke_explicit::state_condition(const state* s) const
+  {
+    const state_kripke* f = down_cast<const state_kripke*>(s);
+    assert(f);
+    return (f->as_bdd());
+  }
+
+  bdd
+  kripke_explicit::state_condition(const std::string name) const
+  {
+    std::map<const std::string, state_kripke*>::const_iterator it;
+    it = ns_nodes_.find(name);
+    assert(it != ns_nodes_.end());
+    return state_condition(it->second);
+  }
+
+  const std::map<const state_kripke*, std::string>&
+  kripke_explicit::sn_get() const
+  {
+    return sn_nodes_;
+  }
+
+
+  void kripke_explicit::add_state(std::string name,
+                                 state_kripke* state)
+  {
+    if (ns_nodes_.find(name) == ns_nodes_.end())
+    {
+      ns_nodes_[name] = state;
+      sn_nodes_[state] = name;
+      if (!init_)
+        init_ = state;
+    }
+  }
+
+  void kripke_explicit::add_state(std::string name)
+  {
+    if (ns_nodes_.find(name) == ns_nodes_.end())
+    {
+      state_kripke* state = new state_kripke;
+      add_state(name, state);
+    }
+  }
+
+  void kripke_explicit::add_transition(state_kripke* source,
+                                       const state_kripke* dest)
+  {
+    state_kripke* Dest = const_cast<state_kripke*>(dest);
+    source->add_succ(Dest);
+  }
+
+  void kripke_explicit::add_transition(std::string source,
+                                       const state_kripke* dest)
+  {
+    add_transition(ns_nodes_[source], dest);
+  }
+
+  void kripke_explicit::add_transition(std::string source,
+                                       std::string dest)
+  {
+    state_kripke* neo = 0;
+    std::map<std::string, state_kripke*>::iterator destination
+      = ns_nodes_.find(dest);
+
+    if (ns_nodes_.find(dest) == ns_nodes_.end())
+    {
+      neo = new state_kripke;
+      add_state(dest, neo);
+      add_transition(source, neo);
+    }
+    else
+    {
+      add_transition(source, destination->second);
+    }
+  }
+
+  void kripke_explicit::add_conditions(bdd add,
+                                       state_kripke* on_me)
+  {
+    on_me->add_conditions(add);
+  }
+
+  void kripke_explicit::add_conditions(bdd add,
+                                       std::string on_me)
+  {
+    add_conditions(add, ns_nodes_[on_me]);
+  }
+
+
+  void kripke_explicit::add_condition(const ltl::formula* f,
+                                      std::string on_me)
+  {
+    add_conditions(formula_to_bdd(f, dict_, this), on_me);
+    f->destroy();
+  }
+
+
+} // End namespace spot.

src/kripke/kripkeexplicit.hh

@@ -0,0 +1,194 @@
+// Copyright (C) 2011 Laboratoire de Recherche et Developpement
+// de l'Epita (LRDE)
+//
+// 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.
+
+
+#ifndef SPOT_KRIPKE_KRIPKEEXPLICIT_HH
+# define SPOT_KRIPKE_KRIPKEEXPLICIT_HH
+
+# include <iosfwd>
+# include "kripke.hh"
+# include "ltlast/formula.hh"
+# include "kripkeprint.hh"
+
+namespace spot
+{
+  // Define in kripkeprint.hh
+  class KripkeVisitor;
+
+/// \brief Concrete class for kripke states.
+  class state_kripke : public state
+  {
+      friend class kripke_explicit;
+      friend class kripke_explicit_succ_iterator;
+    private:
+      state_kripke();
+
+      /// \brief Compare two states.
+      ///
+      /// This method returns an integer less than, equal to, or greater
+      /// than zero if \a this is found, respectively, to be less than, equal
+      /// to, or greater than \a other according to some implicit total order.
+      ///
+      /// For moment, this method only compare the adress on the heap of the
+      /// twice pointers.
+      virtual int compare (const state* other) const;
+
+      /// \brief Hash a state
+      ///
+      /// \FIXME For moment : Only there to can instantiate state_kripke.
+      virtual size_t hash() const;
+
+      /// \brief Duplicate a state.
+      virtual state_kripke* clone() const;
+
+      /// \brief Add a condition to the conditions already in the state.
+      /// \param f The condition to add.
+      void add_conditions(bdd f);
+
+      /// \brief Add a new successor in the list.
+      /// \param add_me The state to add.
+      void add_succ(state_kripke*);
+
+      virtual bdd
+      as_bdd() const
+      {
+        return bdd_;
+      }
+
+      /// \brief Release a state.
+      ///
+      virtual void destroy() const
+      {
+      }
+
+      virtual ~state_kripke ()
+      {
+      }
+
+      ////////////////////////////////
+      // Management for succ_iterator
+
+      const std::list<state_kripke*>& get_succ() const;
+
+      bdd                 bdd_;
+      std::list<state_kripke*>   succ_;
+  };
+
+
+  /// \class kripke_explicit_succ_iterator
+  /// \brief Implement iterator pattern on successor of a state_kripke.
+  class kripke_explicit_succ_iterator : public kripke_succ_iterator
+  {
+    public:
+      kripke_explicit_succ_iterator(const state_kripke*,
+                                   bdd);
+
+      ~kripke_explicit_succ_iterator();
+
+      virtual void first();
+      virtual void next();
+      virtual bool done() const;
+
+      virtual state_kripke* current_state() const;
+
+    private:
+      const state_kripke*       s_;
+      std::list<state_kripke*>::const_iterator it_;
+  };
+
+
+  /// \class kripke_explicit
+  /// \brief Kripke Structure.
+  class kripke_explicit : public kripke
+  {
+    public:
+      kripke_explicit(bdd_dict*);
+      kripke_explicit(bdd_dict*, state_kripke*);
+      ~kripke_explicit();
+
+      bdd_dict* get_dict() const;
+      state_kripke* get_init_state() const;
+
+      /// \brief Allow to get an iterator on the state we passed in parameter.
+      kripke_explicit_succ_iterator* succ_iter(const spot::state* local_state,
+                                    const spot::state* global_state = 0,
+                                    const tgba* global_automaton = 0) const;
+
+      /// \function state_condition
+      /// \brief Get the condition on the state, designed by the adress,
+      /// or by his name.
+      bdd state_condition(const state* s) const;
+      bdd state_condition(const std::string) const;
+
+      /// \brief Return the name of the state.
+      std::string format_state(const state*) const;
+
+
+
+      /// \brief Check if the state already exist, and create it if not.
+      /// used by the parser for more simplicity.
+      void add_state(std::string);
+
+      /// \function add_transition
+      /// \brief Add a transition between two state.
+      /// Allow to do this with the two adress, or just the source adress,
+      void add_transition(std::string source,
+                          std::string dest);
+
+      /// \function add_conditions
+      /// \brief Add a condition in bdd format to the state,
+      /// name by his name or his address.
+      /// \param add the condition.
+      /// \param on_me where add the condition.
+      void add_conditions(bdd add,
+                          std::string on_me);
+
+      /// \brief Add a formula to the state corresponding to the name.
+      /// \param on_me The state where add.
+      /// \param f the formula to add.
+      void add_condition(const ltl::formula* f,
+                         std::string on_me);
+
+      const std::map<const state_kripke*, std::string>&
+      sn_get() const;
+
+    private:
+      /// \brief Add a state in the two map.
+      void add_state(std::string, state_kripke*);
+
+      void add_conditions(bdd add,
+                          state_kripke* on_me);
+
+      /// or with the two name.
+      void add_transition(state_kripke* source,
+                           const state_kripke* dest);
+      void add_transition(std::string source,
+                          const state_kripke* dest);
+
+
+
+
+      bdd_dict*          dict_;
+      state_kripke*           init_;
+      std::map<const std::string, state_kripke*>     ns_nodes_;
+      std::map<const state_kripke*, std::string> sn_nodes_;
+  };
+}
+#endif /* !SPOT_KRIPKEEXPLICIT_HH_ */

src/kripke/kripkeprint.cc

@@ -0,0 +1,66 @@
+// Copyright (C) 2011 Laboratoire de Recherche et Developpement
+// de l'Epita (LRDE)
+//
+// 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 "kripkeprint.hh"
+#include "kripkeexplicit.hh"
+#include "../tgba/bddprint.hh"
+#include "misc/escape.hh"
+#include <iostream>
+
+namespace spot
+{
+  KripkePrinter::KripkePrinter(const kripke* automata,
+                               std::ostream& os)
+    : tgba_reachable_iterator_breadth_first(automata), os_(os)
+  {
+  }
+
+  void KripkePrinter::start()
+  {
+  }
+
+  void KripkePrinter::process_state(const state* s,
+                                    int,
+                                    tgba_succ_iterator* si)
+  {
+    const bdd_dict* d = automata_->get_dict();
+    std::string cur = automata_->format_state(s);
+    os_ << "\"";
+    escape_str(os_, automata_->format_state(s));
+    os_ << "\", \"";
+    const kripke* automata = down_cast<const kripke*>
+      (automata_);
+    assert(automata);
+    escape_str(os_, bdd_format_formula(d,
+                                       automata->state_condition(s)));
+
+    os_ << "\",";
+    for (si->first(); !si->done(); si->next())
+    {
+      state* dest = si->current_state();
+      os_ << " \"";
+      escape_str(os_, automata_->format_state(dest));
+      os_ << "\"";
+    }
+    os_ << ";" << std::endl;
+  }
+
+} // End namespace Spot

src/kripke/kripkeprint.hh

@@ -0,0 +1,53 @@
+// Copyright (C) 2011 Laboratoire de Recherche et Developpement
+// de l'Epita (LRDE)
+//
+// 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.
+
+
+#ifndef SPOT_KRIPKE_KRIPKEPRINT_HH
+# define SPOT_KRIPKE_KRIPKEPRINT_HH
+
+# include <iosfwd>
+# include "tgbaalgos/reachiter.hh"
+namespace spot
+{
+
+  class kripke_explicit;
+  class state_kripke;
+  class kripke_succ_iterator;
+  class kripke;
+
+  /// \brief Iterate over all reachable states of a spot::kripke
+  /// Override start and process_state methods from
+  /// tgba_reachable_iterator_breadth_first.
+  class KripkePrinter : public tgba_reachable_iterator_breadth_first
+  {
+    public:
+      KripkePrinter(const kripke* state, std::ostream& os);
+
+      void start();
+
+      void process_state(const state*, int, tgba_succ_iterator* si);
+
+    private:
+      std::ostream& os_;
+  };
+
+} // End namespace spot
+
+#endif /* !KRIPKEPRINT_HH_ */