LCOV - code coverage report
Current view: top level - modal_formula/include/mcrl2/modal_formula - print.h (source / functions) Hit Total Coverage
Test: mcrl2_coverage.info.cleaned Lines: 213 329 64.7 %
Date: 2020-04-01 00:44:46 Functions: 46 181 25.4 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : // Author(s): Wieger Wesselink
       2             : // Copyright: see the accompanying file COPYING or copy at
       3             : // https://github.com/mCRL2org/mCRL2/blob/master/COPYING
       4             : //
       5             : // Distributed under the Boost Software License, Version 1.0.
       6             : // (See accompanying file LICENSE_1_0.txt or copy at
       7             : // http://www.boost.org/LICENSE_1_0.txt)
       8             : //
       9             : /// \file mcrl2/modal_formula/print.h
      10             : /// \brief add your file description here.
      11             : 
      12             : #ifndef MCRL2_MODAL_FORMULA_PRINT_H
      13             : #define MCRL2_MODAL_FORMULA_PRINT_H
      14             : 
      15             : #include "mcrl2/lps/print.h"
      16             : #include "mcrl2/modal_formula/traverser.h"
      17             : 
      18             : namespace mcrl2 {
      19             : 
      20             : namespace action_formulas {
      21             : 
      22           0 : constexpr inline int precedence(const forall&) { return 21; }
      23           0 : constexpr inline int precedence(const exists&) { return 21; }
      24           0 : constexpr inline int precedence(const imp&)    { return 22; }
      25           0 : constexpr inline int precedence(const or_&)    { return 23; }
      26           0 : constexpr inline int precedence(const and_&)   { return 24; }
      27           0 : constexpr inline int precedence(const at&)     { return 25; }
      28           7 : constexpr inline int precedence(const not_&)   { return 26; }
      29           7 : inline int precedence(const action_formula& x)
      30             : {
      31           7 :   if (is_forall(x))      { return precedence(atermpp::down_cast<forall>(x)); }
      32           7 :   else if (is_exists(x)) { return precedence(atermpp::down_cast<exists>(x)); }
      33           7 :   else if (is_imp(x))    { return precedence(atermpp::down_cast<imp>(x)); }
      34           7 :   else if (is_or(x))     { return precedence(atermpp::down_cast<or_>(x)); }
      35           7 :   else if (is_and(x))    { return precedence(atermpp::down_cast<and_>(x)); }
      36           7 :   else if (is_at(x))     { return precedence(atermpp::down_cast<at>(x)); }
      37           7 :   else if (is_not(x))    { return precedence(atermpp::down_cast<not_>(x)); }
      38           5 :   return core::detail::max_precedence;
      39             : }
      40             : 
      41             : // only defined for binary operators
      42           0 : inline bool is_left_associative(const imp&)  { return false; }
      43           0 : inline bool is_left_associative(const or_&)  { return true; }
      44           0 : inline bool is_left_associative(const and_&) { return true; }
      45             : inline bool is_left_associative(const action_formula& x)
      46             : {
      47             :   if (is_imp(x))      { return is_left_associative(atermpp::down_cast<imp>(x)); }
      48             :   else if (is_or(x))  { return is_left_associative(atermpp::down_cast<or_>(x)); }
      49             :   else if (is_and(x)) { return is_left_associative(atermpp::down_cast<and_>(x)); }
      50             :   return false;
      51             : }
      52             : 
      53           0 : inline bool is_right_associative(const imp&)  { return true; }
      54           0 : inline bool is_right_associative(const or_&)  { return true; }
      55           0 : inline bool is_right_associative(const and_&) { return true; }
      56             : inline bool is_right_associative(const action_formula& x)
      57             : {
      58             :   if (is_imp(x))      { return is_right_associative(atermpp::down_cast<imp>(x)); }
      59             :   else if (is_or(x))  { return is_right_associative(atermpp::down_cast<or_>(x)); }
      60             :   else if (is_and(x)) { return is_right_associative(atermpp::down_cast<and_>(x)); }
      61             :   return false;
      62             : }
      63             : 
      64             : namespace detail
      65             : {
      66             : 
      67             : template <typename Derived>
      68          96 : struct printer: public action_formulas::add_traverser_sort_expressions<lps::detail::printer, Derived>
      69             : {
      70             :   typedef action_formulas::add_traverser_sort_expressions<lps::detail::printer, Derived> super;
      71             : 
      72             :   using super::enter;
      73             :   using super::leave;
      74             :   using super::apply;
      75             :   using super::derived;
      76             :   using super::print_abstraction;
      77             :   using super::print_list;
      78             :   using super::print_action_declarations;
      79             :   using super::print_expression;
      80             :   using super::print_unary_left_operation;
      81             :   using super::print_binary_operation;
      82             : 
      83          14 :   void apply(const action_formulas::true_& x)
      84             :   {
      85          14 :     derived().enter(x);
      86          14 :     derived().print("true");
      87          14 :     derived().leave(x);
      88          14 :   }
      89             : 
      90           0 :   void apply(const action_formulas::false_& x)
      91             :   {
      92           0 :     derived().enter(x);
      93           0 :     derived().print("false");
      94           0 :     derived().leave(x);
      95           0 :   }
      96             : 
      97           5 :   void apply(const action_formulas::not_& x)
      98             :   {
      99           5 :     derived().enter(x);
     100           5 :     print_unary_left_operation(x, "!");
     101           5 :     derived().leave(x);
     102           5 :   }
     103             : 
     104           1 :   void apply(const action_formulas::and_& x)
     105             :   {
     106           1 :     derived().enter(x);
     107           1 :     print_binary_operation(x, " && ");
     108           1 :     derived().leave(x);
     109           1 :   }
     110             : 
     111           0 :   void apply(const action_formulas::or_& x)
     112             :   {
     113           0 :     derived().enter(x);
     114           0 :     print_binary_operation(x, " || ");
     115           0 :     derived().leave(x);
     116           0 :   }
     117             : 
     118           0 :   void apply(const action_formulas::imp& x)
     119             :   {
     120           0 :     derived().enter(x);
     121           0 :     print_binary_operation(x, " => ");
     122           0 :     derived().leave(x);
     123           0 :   }
     124             : 
     125           0 :   void apply(const action_formulas::forall& x)
     126             :   {
     127           0 :     derived().enter(x);
     128           0 :     print_abstraction(x, "forall");
     129           0 :     derived().leave(x);
     130           0 :   }
     131             : 
     132           0 :   void apply(const action_formulas::exists& x)
     133             :   {
     134           0 :     derived().enter(x);
     135           0 :     print_abstraction(x, "exists");
     136           0 :     derived().leave(x);
     137           0 :   }
     138             : 
     139           0 :   void apply(const action_formulas::at& x)
     140             :   {
     141           0 :     derived().enter(x);
     142           0 :     derived().apply(x.operand());
     143           0 :     derived().print(" @ ");
     144           0 :     print_expression(x.time_stamp(), precedence(x.time_stamp()) < core::detail::max_precedence);
     145           0 :     derived().leave(x);
     146           0 :   }
     147             : 
     148          11 :   void apply(const action_formulas::multi_action& x)
     149             :   {
     150          11 :     derived().enter(x);
     151          11 :     if (x.actions().empty())
     152             :     {
     153           0 :       derived().print("tau");
     154             :     }
     155             :     else
     156             :     {
     157          11 :       print_list(x.actions(), "", "", "|");
     158             :     }
     159          11 :     derived().leave(x);
     160          11 :   }
     161             : };
     162             : 
     163             : } // namespace detail
     164             : 
     165             : /// \brief Prints the object t to a stream.
     166             : template <typename T>
     167           0 : void pp(const T& t, std::ostream& out)
     168             : {
     169           0 :   core::detail::apply_printer<action_formulas::detail::printer> printer(out);
     170           0 :   printer.apply(t);
     171           0 : }
     172             : 
     173             : /// \brief Returns a string representation of the object t.
     174             : template <typename T>
     175           0 : std::string pp(const T& t)
     176             : {
     177           0 :   std::ostringstream out;
     178           0 :   action_formulas::pp(t, out);
     179           0 :   return out.str();
     180             : }
     181             : 
     182             : } // namespace action_formulas
     183             : 
     184             : namespace regular_formulas {
     185             : 
     186           0 : constexpr inline int precedence(const seq&)          { return 31; }
     187           0 : constexpr inline int precedence(const alt&)          { return 32; }
     188           0 : constexpr inline int precedence(const trans&)        { return 33; }
     189           3 : constexpr inline int precedence(const trans_or_nil&) { return 33; }
     190           3 : inline int precedence(const regular_formula& x)
     191             : {
     192           3 :   if (is_seq(x))               { return precedence(atermpp::down_cast<seq>(x)); }
     193           3 :   else if (is_alt(x))          { return precedence(atermpp::down_cast<alt>(x)); }
     194           3 :   else if (is_trans(x))        { return precedence(atermpp::down_cast<trans>(x)); }
     195           3 :   else if (is_trans_or_nil(x)) { return precedence(atermpp::down_cast<trans_or_nil>(x)); }
     196           3 :   return core::detail::max_precedence;
     197             : }
     198             : 
     199             : // only defined for binary operators
     200           0 : inline bool is_left_associative(const seq&)  { return false; }
     201           0 : inline bool is_left_associative(const alt&)  { return true; }
     202             : inline bool is_left_associative(const regular_formula& x)
     203             : {
     204             :   if (is_seq(x))      { return is_left_associative(atermpp::down_cast<seq>(x)); }
     205             :   else if (is_alt(x)) { return is_left_associative(atermpp::down_cast<alt>(x)); }
     206             :   return false;
     207             : }
     208             : 
     209           0 : inline bool is_right_associative(const seq&)  { return true; }
     210           0 : inline bool is_right_associative(const alt&)  { return true; }
     211             : inline bool is_right_associative(const regular_formula& x)
     212             : {
     213             :   if (is_seq(x))      { return is_right_associative(atermpp::down_cast<seq>(x)); }
     214             :   else if (is_alt(x)) { return is_right_associative(atermpp::down_cast<alt>(x)); }
     215             :   return false;
     216             : }
     217             : 
     218             : namespace detail
     219             : {
     220             : 
     221             : template <typename Derived>
     222          96 : struct printer: public regular_formulas::add_traverser_sort_expressions<action_formulas::detail::printer, Derived>
     223             : {
     224             :   typedef regular_formulas::add_traverser_sort_expressions<action_formulas::detail::printer, Derived> super;
     225             : 
     226             :   using super::enter;
     227             :   using super::leave;
     228             :   using super::apply;
     229             :   using super::derived;
     230             :   using super::print_action_declarations;
     231             : 
     232             :   using super::print_expression;
     233             :   using super::print_unary_left_operation;
     234             :   using super::print_unary_right_operation;
     235             :   using super::print_binary_operation;
     236             : 
     237           0 :   void apply(const regular_formulas::seq& x)
     238             :   {
     239           0 :     derived().enter(x);
     240           0 :     print_binary_operation(x, " . ");
     241           0 :     derived().leave(x);
     242           0 :   }
     243             : 
     244           0 :   void apply(const regular_formulas::alt& x)
     245             :   {
     246           0 :     derived().enter(x);
     247           0 :     print_binary_operation(x, " + ");
     248           0 :     derived().leave(x);
     249           0 :   }
     250             : 
     251           0 :   void apply(const regular_formulas::trans& x)
     252             :   {
     253           0 :     derived().enter(x);
     254           0 :     print_unary_right_operation(x, "+");
     255           0 :     derived().leave(x);
     256           0 :   }
     257             : 
     258           3 :   void apply(const regular_formulas::trans_or_nil& x)
     259             :   {
     260           3 :     derived().enter(x);
     261           3 :     print_unary_right_operation(x, "*");
     262           3 :     derived().leave(x);
     263           3 :   }
     264             : 
     265           0 :   void apply(const regular_formulas::untyped_regular_formula& x)
     266             :   {
     267           0 :     derived().enter(x);
     268           0 :     print_expression(x.left(), false);
     269           0 :     derived().print(" " + std::string(x.name()) + " ");
     270           0 :     print_expression(x.right(), false);
     271           0 :     derived().leave(x);
     272           0 :   }
     273             : };
     274             : 
     275             : } // namespace detail
     276             : 
     277             : /// \brief Prints the object t to a stream.
     278             : template <typename T>
     279           0 : void pp(const T& t, std::ostream& out)
     280             : {
     281           0 :   core::detail::apply_printer<regular_formulas::detail::printer> printer(out);
     282           0 :   printer.apply(t);
     283           0 : }
     284             : 
     285             : /// \brief Returns a string representation of the object t.
     286             : template <typename T>
     287           0 : std::string pp(const T& t)
     288             : {
     289           0 :   std::ostringstream out;
     290           0 :   regular_formulas::pp(t, out);
     291           0 :   return out.str();
     292             : }
     293             : 
     294             : } // namespace regular_formulas
     295             : 
     296             : namespace state_formulas {
     297             : 
     298          31 : constexpr inline int precedence(const mu&)     { return 41; }
     299           2 : constexpr inline int precedence(const nu&)     { return 41; }
     300           3 : constexpr inline int precedence(const forall&) { return 42; }
     301           0 : constexpr inline int precedence(const exists&) { return 42; }
     302           0 : constexpr inline int precedence(const imp&)    { return 43; }
     303           3 : constexpr inline int precedence(const or_&)    { return 44; }
     304           4 : constexpr inline int precedence(const and_&)   { return 45; }
     305          33 : constexpr inline int precedence(const must&)   { return 46; }
     306          10 : constexpr inline int precedence(const may&)    { return 46; }
     307          20 : constexpr inline int precedence(const not_&)   { return 47; }
     308         139 : inline int precedence(const state_formula& x)
     309             : {
     310         139 :   if      (is_mu(x))     { return precedence(atermpp::down_cast<mu>(x)); }
     311         108 :   else if (is_nu(x))     { return precedence(atermpp::down_cast<nu>(x)); }
     312         106 :   else if (is_forall(x)) { return precedence(atermpp::down_cast<forall>(x)); }
     313         103 :   else if (is_exists(x)) { return precedence(atermpp::down_cast<exists>(x)); }
     314         103 :   else if (is_imp(x))    { return precedence(atermpp::down_cast<imp>(x)); }
     315         103 :   else if (is_or(x))     { return precedence(atermpp::down_cast<or_>(x)); }
     316         100 :   else if (is_and(x))    { return precedence(atermpp::down_cast<and_>(x)); }
     317          96 :   else if (is_must(x))   { return precedence(atermpp::down_cast<must>(x)); }
     318          84 :   else if (is_may(x))    { return precedence(atermpp::down_cast<may>(x)); }
     319          80 :   else if (is_not(x))    { return precedence(atermpp::down_cast<not_>(x)); }
     320          76 :   return core::detail::max_precedence;
     321             : }
     322             : 
     323             : // only defined for binary operators
     324           0 : inline bool is_left_associative(const imp&)  { return false; }
     325           0 : inline bool is_left_associative(const or_&)  { return true; }
     326           0 : inline bool is_left_associative(const and_&) { return true; }
     327             : inline bool is_left_associative(const state_formula& x)
     328             : {
     329             :   if (is_imp(x))      { return is_left_associative(atermpp::down_cast<imp>(x)); }
     330             :   else if (is_or(x))  { return is_left_associative(atermpp::down_cast<or_>(x)); }
     331             :   else if (is_and(x)) { return is_left_associative(atermpp::down_cast<and_>(x)); }
     332             :   return false;
     333             : }
     334             : 
     335           0 : inline bool is_right_associative(const imp&)  { return true; }
     336           0 : inline bool is_right_associative(const or_&)  { return true; }
     337           3 : inline bool is_right_associative(const and_&) { return true; }
     338             : inline bool is_right_associative(const state_formula& x)
     339             : {
     340             :   if (is_imp(x))      { return is_right_associative(atermpp::down_cast<imp>(x)); }
     341             :   else if (is_or(x))  { return is_right_associative(atermpp::down_cast<or_>(x)); }
     342             :   else if (is_and(x)) { return is_right_associative(atermpp::down_cast<and_>(x)); }
     343             :   return false;
     344             : }
     345             : 
     346             : namespace detail
     347             : {
     348             : 
     349             : template <typename Derived>
     350         192 : struct printer: public state_formulas::add_traverser_sort_expressions<regular_formulas::detail::printer, Derived>
     351             : {
     352             :   typedef state_formulas::add_traverser_sort_expressions<regular_formulas::detail::printer, Derived> super;
     353             : 
     354             :   using super::enter;
     355             :   using super::leave;
     356             :   using super::apply;
     357             :   using super::derived;
     358             :   using super::print_abstraction;
     359             :   using super::print_variables;
     360             :   using super::print_list;
     361             :   using super::print_action_declarations;
     362             : 
     363             :   using super::print_expression;
     364             :   using super::print_unary_left_operation;
     365             :   using super::print_binary_operation;
     366             :   using super::print_unary_operand;
     367             : 
     368             :   // Determines whether or not data expressions should be wrapped inside 'val'.
     369             :   std::vector<bool> val;
     370             : 
     371         176 :   void disable_val()
     372             :   {
     373         176 :     val.push_back(false);
     374         176 :   }
     375             : 
     376         116 :   void enable_val()
     377             :   {
     378         116 :     assert(!val.empty());
     379         116 :     val.pop_back();
     380         116 :   }
     381             : 
     382          52 :   void apply(const data::data_expression& x)
     383             :   {
     384          52 :     bool print_val = val.empty();
     385          52 :     derived().enter(x);
     386          52 :     if (print_val)
     387             :     {
     388          12 :       disable_val();
     389          12 :       derived().print("val(");
     390             :     }
     391          52 :     super::apply(x);
     392          52 :     if (print_val)
     393             :     {
     394          12 :       derived().print(")");
     395          12 :       enable_val();
     396             :     }
     397          52 :     derived().leave(x);
     398          52 :   }
     399             : 
     400          33 :   void apply(const state_formulas::true_& x)
     401             :   {
     402          33 :     derived().enter(x);
     403          33 :     derived().print("true");
     404          33 :     derived().leave(x);
     405          33 :   }
     406             : 
     407          23 :   void apply(const state_formulas::false_& x)
     408             :   {
     409          23 :     derived().enter(x);
     410          23 :     derived().print("false");
     411          23 :     derived().leave(x);
     412          23 :   }
     413             : 
     414          16 :   void apply(const state_formulas::not_& x)
     415             :   {
     416          16 :     derived().enter(x);
     417          16 :     print_unary_left_operation(x, "!");
     418          16 :     derived().leave(x);
     419          16 :   }
     420             : 
     421          26 :   void apply(const state_formulas::and_& x)
     422             :   {
     423          26 :     derived().enter(x);
     424          26 :     print_binary_operation(x, " && ");
     425          26 :     derived().leave(x);
     426          26 :   }
     427             : 
     428          20 :   void apply(const state_formulas::or_& x)
     429             :   {
     430          20 :     derived().enter(x);
     431          20 :     print_binary_operation(x, " || ");
     432          20 :     derived().leave(x);
     433          20 :   }
     434             : 
     435           2 :   void apply(const state_formulas::imp& x)
     436             :   {
     437           2 :     derived().enter(x);
     438           2 :     print_binary_operation(x, " => ");
     439           2 :     derived().leave(x);
     440           2 :   }
     441             : 
     442           7 :   void apply(const state_formulas::forall& x)
     443             :   {
     444           7 :     derived().enter(x);
     445           7 :     print_abstraction(x, "forall");
     446           7 :     derived().leave(x);
     447           7 :   }
     448             : 
     449           3 :   void apply(const state_formulas::exists& x)
     450             :   {
     451           3 :     derived().enter(x);
     452           3 :     print_abstraction(x, "exists");
     453           3 :     derived().leave(x);
     454           3 :   }
     455             : 
     456          21 :   void apply(const state_formulas::must& x)
     457             :   {
     458          21 :     derived().enter(x);
     459          21 :     derived().print("[");
     460          21 :     disable_val();
     461          21 :     derived().apply(x.formula());
     462          21 :     enable_val();
     463          21 :     derived().print("]");
     464          21 :     print_unary_operand(x, x.operand());
     465          21 :     derived().leave(x);
     466          21 :   }
     467             : 
     468           6 :   void apply(const state_formulas::may& x)
     469             :   {
     470           6 :     derived().enter(x);
     471           6 :     derived().print("<");
     472           6 :     disable_val();
     473           6 :     derived().apply(x.formula());
     474           6 :     enable_val();
     475           6 :     derived().print(">");
     476           6 :     print_unary_operand(x, x.operand());
     477           6 :     derived().leave(x);
     478           6 :   }
     479             : 
     480           0 :   void apply(const state_formulas::yaled& x)
     481             :   {
     482           0 :     derived().enter(x);
     483           0 :     derived().print("yaled");
     484           0 :     derived().leave(x);
     485           0 :   }
     486             : 
     487           0 :   void apply(const state_formulas::yaled_timed& x)
     488             :   {
     489           0 :     disable_val();
     490           0 :     derived().enter(x);
     491           0 :     derived().print("yaled");
     492           0 :     derived().print(" @ ");
     493           0 :     print_expression(x.time_stamp(), precedence(x.time_stamp()) < core::detail::max_precedence);
     494           0 :     derived().leave(x);
     495           0 :     enable_val();
     496           0 :   }
     497             : 
     498           0 :   void apply(const state_formulas::delay& x)
     499             :   {
     500           0 :     derived().enter(x);
     501           0 :     derived().print("delay");
     502           0 :     derived().leave(x);
     503           0 :   }
     504             : 
     505           2 :   void apply(const state_formulas::delay_timed& x)
     506             :   {
     507           2 :     disable_val();
     508           2 :     derived().enter(x);
     509           2 :     derived().print("delay");
     510           2 :     derived().print(" @ ");
     511           2 :     print_expression(x.time_stamp(), precedence(x.time_stamp()) < core::detail::max_precedence);
     512           2 :     derived().leave(x);
     513           2 :     enable_val();
     514           2 :   }
     515             : 
     516          72 :   void apply(const state_formulas::variable& x)
     517             :   {
     518          72 :     disable_val();
     519          72 :     derived().enter(x);
     520          72 :     derived().apply(x.name());
     521          72 :     print_list(x.arguments(), "(", ")", ", ", false);
     522          72 :     derived().leave(x);
     523          72 :     enable_val();
     524          72 :   }
     525             : 
     526             :   // TODO: merge this function with the version in data/print.h (?)
     527          63 :   void print_assignments(const data::assignment_list& assignments)
     528             :   {
     529          63 :     disable_val();
     530          63 :     if (assignments.empty())
     531             :     {
     532          60 :       return;
     533             :     }
     534           3 :     derived().print("(");
     535           7 :     for (auto i = assignments.begin(); i != assignments.end(); ++i)
     536             :     {
     537           4 :       if (i != assignments.begin())
     538             :       {
     539           1 :         derived().print(", ");
     540             :       }
     541           4 :       derived().apply(i->lhs());
     542           4 :       derived().print(": ");
     543           4 :       derived().apply(i->lhs().sort());
     544           4 :       derived().print(" = ");
     545           4 :       derived().apply(i->rhs());
     546             :     }
     547           3 :     derived().print(")");
     548           3 :     enable_val();
     549             :   }
     550             : 
     551          12 :   void apply(const state_formulas::nu& x)
     552             :   {
     553          12 :     derived().enter(x);
     554          12 :     derived().print("nu ");
     555          12 :     derived().apply(x.name());
     556          12 :     print_assignments(x.assignments());
     557          12 :     derived().print(". ");
     558          12 :     derived().apply(x.operand());
     559          12 :     derived().leave(x);
     560          12 :   }
     561             : 
     562          51 :   void apply(const state_formulas::mu& x)
     563             :   {
     564          51 :     derived().enter(x);
     565          51 :     derived().print("mu ");
     566          51 :     derived().apply(x.name());
     567          51 :     print_assignments(x.assignments());
     568          51 :     derived().print(". ");
     569          51 :     derived().apply(x.operand());
     570          51 :     derived().leave(x);
     571          51 :   }
     572             : 
     573           1 :   void apply(const state_formulas::state_formula_specification& x)
     574             :   {
     575           1 :     derived().enter(x);
     576           1 :     derived().apply(x.data());
     577           1 :     print_action_declarations(x.action_labels(), "act  ",";\n\n", ";\n     ");
     578           1 :     derived().print("form ");
     579           1 :     derived().apply(x.formula());
     580           1 :     derived().print(";\n");
     581           1 :     derived().leave(x);
     582           1 :   }
     583             : };
     584             : 
     585             : } // namespace detail
     586             : 
     587             : /// \brief Prints the object t to a stream.
     588             : template <typename T>
     589          96 : void pp(const T& t, std::ostream& out)
     590             : {
     591         192 :   core::detail::apply_printer<state_formulas::detail::printer> printer(out);
     592          96 :   printer.apply(t);
     593          96 : }
     594             : 
     595             : /// \brief Returns a string representation of the object t.
     596             : template <typename T>
     597          96 : std::string pp(const T& t)
     598             : {
     599         192 :   std::ostringstream out;
     600          96 :   state_formulas::pp(t, out);
     601         192 :   return out.str();
     602             : }
     603             : 
     604             : } // namespace state_formulas
     605             : 
     606             : } // namespace mcrl2
     607             : 
     608             : #endif // MCRL2_MODAL_FORMULA_PRINT_H
     609             : 

Generated by: LCOV version 1.13