Add an LTL printer in LBT's syntax.

* src/ltlvisit/lbt.cc, src/ltlvisit/lbt.hh: New files.
* src/ltlvisit/Makefile.am: Add them.
* src/bin/common_output.cc, src/bin/common_output.hh: Add
support for LBT output, and reporting formulae that cannot
be output in this syntax.
* src/bin/ltlfilt.cc: Pass filename and linenum to
output_formula() for better error reporting.

src/bin/common_output.cc

@@ -19,10 +19,13 @@
 // Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 // 02111-1307, USA.
 
+#include "common_sys.hh"
 #include "common_output.hh"
 #include <iostream>
 #include "ltlvisit/tostring.hh"
+#include "ltlvisit/lbt.hh"
 #include "common_cout.hh"
+#include "error.h"
 
 #define OPT_SPOT 1
 
@@ -35,6 +38,7 @@ static const argp_option options[] =
       "output fully-parenthesized formulas", -20 },
     { "spin", 's', 0, 0, "output in Spin's syntax", -20 },
     { "spot", OPT_SPOT, 0, 0, "output in Spot's syntax (default)", -20 },
+    { "lbt", 'l', 0, 0, "output in LBT's syntax", -20 },
     { "utf8", '8', 0, 0, "output using UTF-8 characters", -20 },
     { 0, 0, 0, 0, 0, 0 }
   };
@@ -50,6 +54,9 @@ parse_opt_output(int key, char*, struct argp_state*)
     case '8':
       output_format = utf8_output;
       break;
+    case 'l':
+      output_format = lbt_output;
+      break;
     case 'p':
       full_parenth = true;
       break;
@@ -65,16 +72,40 @@ parse_opt_output(int key, char*, struct argp_state*)
   return 0;
 }
 
+static
 void
-output_formula(const spot::ltl::formula* f)
+report_not_ltl(const spot::ltl::formula* f,
+	       const char* filename, int linenum, const char* syn)
+{
+  std::string s = spot::ltl::to_string(f);
+  static const char msg[] =
+    "formula '%s' cannot be written %s's syntax because it is not LTL";
+  if (filename)
+    error_at_line(2, 0, filename, linenum, msg, s.c_str(), syn);
+  else
+    error(2, 0, msg, s.c_str(), syn);
+}
+
+
+void
+output_formula(const spot::ltl::formula* f, const char* filename, int linenum)
 {
   switch (output_format)
     {
+    case lbt_output:
+      if (f->is_ltl_formula())
+	spot::ltl::to_lbt_string(f, std::cout);
+      else
+	report_not_ltl(f, filename, linenum, "LBT");
+      break;
     case spot_output:
       spot::ltl::to_string(f, std::cout, full_parenth);
       break;
     case spin_output:
-      spot::ltl::to_spin_string(f, std::cout, full_parenth);
+      if (f->is_ltl_formula())
+	spot::ltl::to_spin_string(f, std::cout, full_parenth);
+      else
+	report_not_ltl(f, filename, linenum, "Spin");
       break;
     case utf8_output:
       spot::ltl::to_utf8_string(f, std::cout, full_parenth);

src/bin/common_output.hh

@@ -27,13 +27,15 @@
 #include <argp.h>
 #include "ltlast/formula.hh"
 
-enum output_format_t { spot_output, spin_output, utf8_output };
+enum output_format_t { spot_output, spin_output, utf8_output, lbt_output };
 extern output_format_t output_format;
 extern bool full_parenth;
 
 extern const struct argp output_argp;
 
 int parse_opt_output(int key, char* arg, struct argp_state* state);
-void output_formula(const spot::ltl::formula* f);
+
+void output_formula(const spot::ltl::formula* f,
+		    const char* filename = 0, int linenum = 0);
 
 #endif // SPOT_BIN_COMMON_OUTPUT_HH

src/bin/ltlfilt.cc

@@ -483,7 +483,7 @@ namespace
       if (matched)
 	{
 	  one_match = true;
-	  output_formula(f);
+	  output_formula(f, filename, linenum);
 	}
       f->destroy();
       return 0;

src/ltlvisit/Makefile.am

@@ -34,6 +34,7 @@ ltlvisit_HEADERS = \
   destroy.hh \
   dotty.hh \
   dump.hh \
+  lbt.hh \
   length.hh \
   lunabbrev.hh \
   mark.hh \
@@ -56,6 +57,7 @@ libltlvisit_la_SOURCES = \
   destroy.cc \
   dotty.cc \
   dump.cc \
+  lbt.cc \
   length.cc \
   lunabbrev.cc \
   mark.cc \

src/ltlvisit/lbt.cc

@@ -0,0 +1,209 @@
+// -*- coding: utf-8 -*-
+// Copyright (C) 2012 Laboratoire de Recherche et
+// Développement 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 <cassert>
+#include <sstream>
+#include <ctype.h>
+#include <ostream>
+#include <cstring>
+#include "ltlast/allnodes.hh"
+#include "ltlast/visitor.hh"
+#include "lbt.hh"
+
+
+namespace spot
+{
+  namespace ltl
+  {
+    namespace
+    {
+      static bool
+      is_pnum(const char* str)
+      {
+	if (str[0] != 'p')
+	  return false;
+	while (*++str)
+	  if (*str < '0' || *str > '9')
+	    return false;
+	return true;
+      }
+
+      class lbt_visitor: public visitor
+      {
+      public:
+	lbt_visitor(std::ostream& os)
+	  : os_(os)
+	{
+	}
+
+	virtual
+	~lbt_visitor()
+	{
+	}
+
+	void
+	visit(const atomic_prop* ap)
+	{
+	  std::string str = ap->name();
+	  if (!is_pnum(str.c_str()))
+	    os_ << '"' << str << "\" ";
+	  else
+	    os_ << str << ' ';
+	}
+
+	void
+	visit(const constant* c)
+	{
+	  switch (c->val())
+	    {
+	    case constant::False:
+	      os_ << "f ";
+	      break;
+	    case constant::True:
+	      os_ << "t ";
+	      break;
+	    case constant::EmptyWord:
+	      assert(!"unsupported constant");
+	      break;
+	    }
+	}
+
+	void
+	visit(const binop* bo)
+	{
+	  switch (bo->op())
+	    {
+	    case binop::Xor:
+
+	      break;
+	    case binop::Implies:
+	      os_ << "i ";
+	      break;
+	    case binop::Equiv:
+	      os_ << "e ";
+	      break;
+	    case binop::U:
+	      os_ << "U ";
+	      break;
+	    case binop::R:
+	      os_ << "V ";
+	      break;
+	    case binop::W:
+	      os_ << "W ";
+	      break;
+	    case binop::M:
+	      os_ << "M ";
+	      break;
+	    case binop::UConcat:
+	    case binop::EConcat:
+	    case binop::EConcatMarked:
+	      assert(!"unsupported operator");
+	      break;
+	    }
+	  bo->first()->accept(*this);
+	  bo->second()->accept(*this);
+	}
+
+	void
+	visit(const bunop*)
+	{
+	  assert(!"unsupported operator");
+	}
+
+	void
+	visit(const unop* uo)
+	{
+	  switch (uo->op())
+	    {
+	    case unop::Not:
+	      os_ << "! ";
+	      break;
+	    case unop::X:
+	      os_ << "X ";
+	      break;
+	    case unop::F:
+	      os_ << "F ";
+	      break;
+	    case unop::G:
+	      os_ << "G ";
+	      break;
+	    case unop::Finish:
+	    case unop::Closure:
+	    case unop::NegClosure:
+	    case unop::NegClosureMarked:
+	      assert(!"unsupported operator");
+	      break;
+	    }
+	  uo->child()->accept(*this);
+	}
+
+	void
+	visit(const automatop*)
+	{
+	  assert(!"unsupported operator");
+	}
+
+	void
+	visit(const multop* mo)
+	{
+	  char o = 0;
+	  switch (mo->op())
+	    {
+	    case multop::Or:
+	      o = '|';
+	      break;
+	    case multop::And:
+	      o = '&';
+	      break;
+	    case multop::OrRat:
+	    case multop::AndRat:
+	    case multop::AndNLM:
+	    case multop::Concat:
+	    case multop::Fusion:
+	      assert(!"unsupported operator");
+	      break;
+	    }
+
+	  unsigned n = mo->size();
+	  for (unsigned i = n - 1; i != 0; --i)
+	    os_ << o << ' ';
+
+	  for (unsigned i = 0; i < n; ++i)
+	    {
+	      mo->nth(i)->accept(*this);
+	    }
+	}
+      protected:
+	std::ostream& os_;
+      };
+
+    } // anonymous
+
+    std::ostream&
+    to_lbt_string(const formula* f, std::ostream& os)
+    {
+      assert(f->is_ltl_formula());
+      lbt_visitor v(os);
+      f->accept(v);
+      return os;
+    }
+  }
+}

src/ltlvisit/lbt.hh

@@ -0,0 +1,51 @@
+// -*- coding: utf-8 -*-
+// Copyright (C) 2012 Laboratoire de Recherche et
+// Développement 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_LTLVISIT_LBT_HH
+# define SPOT_LTLVISIT_LBT_HH
+
+#include <ltlast/formula.hh>
+#include <iosfwd>
+
+namespace spot
+{
+  namespace ltl
+  {
+    /// \addtogroup ltl_io
+    /// @{
+
+    /// \brief Output an LTL formula as a string in LBT's format.
+    ///
+    /// The formula must be an LTL formula (ELTL and PSL operators
+    /// are not supported).  The M and W operator will be output
+    /// as-is, because this is accepted by LBTT, however if you
+    /// plan to use the output with other tools, you should probably
+    /// rewrite these two operators using unabbreviate_wm().
+    ///
+    /// \param f The formula to translate.
+    /// \param os The stream where it should be output.
+    std::ostream&
+    to_lbt_string(const formula* f, std::ostream& os);
+    /// @}
+  }
+}
+
+#endif // SPOT_LTLVISIT_TOSTRING_HH