LCOV - code coverage report
Current view: top level - bes/include/mcrl2/bes - print.h (source / functions) Hit Total Coverage
Test: mcrl2_coverage.info.cleaned Lines: 61 74 82.4 %
Date: 2020-10-20 00:45:57 Functions: 17 40 42.5 %
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/bes/print.h
      10             : /// \brief add your file description here.
      11             : 
      12             : #ifndef MCRL2_BES_PRINT_H
      13             : #define MCRL2_BES_PRINT_H
      14             : 
      15             : #include "mcrl2/bes/traverser.h"
      16             : 
      17             : namespace mcrl2 {
      18             : 
      19             : namespace bes {
      20             : 
      21             : /// \brief Returns the precedence of boolean expressions
      22           0 : constexpr inline int precedence(const imp&)    { return 2; }
      23           0 : constexpr inline int precedence(const or_&)    { return 3; }
      24           3 : constexpr inline int precedence(const and_&)   { return 4; }
      25           0 : constexpr inline int precedence(const not_&)   { return 5; }
      26          82 : inline int precedence(const boolean_expression& x)
      27             : {
      28          82 :   if (is_imp(x))      { return precedence(atermpp::down_cast<imp>(x)); }
      29          82 :   else if (is_or(x))  { return precedence(atermpp::down_cast<or_>(x)); }
      30          82 :   else if (is_and(x)) { return precedence(atermpp::down_cast<and_>(x)); }
      31          79 :   else if (is_not(x)) { return precedence(atermpp::down_cast<not_>(x)); }
      32          79 :   return core::detail::max_precedence;
      33             : }
      34             : 
      35             : // only defined for binary operators
      36           0 : inline bool is_left_associative(const imp&)  { return false; }
      37           0 : inline bool is_left_associative(const or_&)  { return true; }
      38           0 : inline bool is_left_associative(const and_&) { return true; }
      39             : inline bool is_left_associative(const boolean_expression& x)
      40             : {
      41             :   if (is_imp(x))      { return is_left_associative(atermpp::down_cast<imp>(x)); }
      42             :   else if (is_or(x))  { return is_left_associative(atermpp::down_cast<or_>(x)); }
      43             :   else if (is_and(x)) { return is_left_associative(atermpp::down_cast<and_>(x)); }
      44             :   return false;
      45             : }
      46             : 
      47           0 : inline bool is_right_associative(const imp&)  { return true; }
      48           0 : inline bool is_right_associative(const or_&)  { return true; }
      49           1 : inline bool is_right_associative(const and_&) { return true; }
      50             : inline bool is_right_associative(const boolean_expression& x)
      51             : {
      52             :   if (is_imp(x))      { return is_right_associative(atermpp::down_cast<imp>(x)); }
      53             :   else if (is_or(x))  { return is_right_associative(atermpp::down_cast<or_>(x)); }
      54             :   else if (is_and(x)) { return is_right_associative(atermpp::down_cast<and_>(x)); }
      55             :   return false;
      56             : }
      57             : 
      58             : namespace detail {
      59             : 
      60             : template <typename Derived>
      61             : struct printer: public bes::add_traverser_boolean_expressions<core::detail::printer, Derived>
      62             : {
      63             :   typedef bes::add_traverser_boolean_expressions<core::detail::printer, Derived> super;
      64             : 
      65             :   using super::enter;
      66             :   using super::leave;
      67             :   using super::apply;
      68             :   using super::derived;
      69             :   using super::print_expression;
      70             :   using super::print_unary_left_operation;
      71             :   using super::print_binary_operation;
      72             :   using super::print_list;
      73             : 
      74          43 :   void apply(const bes::boolean_equation& x)
      75             :   {
      76          43 :     derived().enter(x);
      77          43 :     derived().print(x.symbol().is_mu() ? "mu " : "nu ");
      78          43 :     derived().apply(x.variable());
      79          43 :     derived().print(" = ");
      80          43 :     derived().apply(x.formula());
      81          43 :     derived().leave(x);
      82          43 :   }
      83             : 
      84          16 :   void apply(const bes::boolean_equation_system& x)
      85             :   {
      86          16 :     print_list(x.equations(), "pbes\n    ", ";\n\n", ";\n    ");
      87          16 :     derived().print("init ");
      88          16 :     print_expression(x.initial_state(), false);
      89          16 :     derived().print(";\n");
      90          16 :     derived().leave(x);
      91          16 :   }
      92             : 
      93           3 :   void apply(const bes::true_& x)
      94             :   {
      95           3 :     derived().enter(x);
      96           3 :     derived().print("true");
      97           3 :     derived().leave(x);
      98           3 :   }
      99             : 
     100           2 :   void apply(const bes::false_& x)
     101             :   {
     102           2 :     derived().enter(x);
     103           2 :     derived().print("false");
     104           2 :     derived().leave(x);
     105           2 :   }
     106             : 
     107           0 :   void apply(const bes::not_& x)
     108             :   {
     109           0 :     derived().enter(x);
     110           0 :     print_unary_left_operation(x, "!");
     111           0 :     derived().leave(x);
     112           0 :   }
     113             : 
     114          19 :   void apply(const bes::and_& x)
     115             :   {
     116          19 :     derived().enter(x);
     117          19 :     print_binary_operation(x, " && ");
     118          19 :     derived().leave(x);
     119          19 :   }
     120             : 
     121          18 :   void apply(const bes::or_& x)
     122             :   {
     123          18 :     derived().enter(x);
     124          18 :     print_binary_operation(x, " || ");
     125          18 :     derived().leave(x);
     126          18 :   }
     127             : 
     128           4 :   void apply(const bes::imp& x)
     129             :   {
     130           4 :     derived().enter(x);
     131           4 :     print_binary_operation(x, " => ");
     132           4 :     derived().leave(x);
     133           4 :   }
     134             : 
     135         140 :   void apply(const bes::boolean_variable& x)
     136             :   {
     137         140 :     derived().enter(x);
     138         140 :     derived().apply(x.name());
     139         140 :     derived().leave(x);
     140         140 :   }
     141             : };
     142             : 
     143             : } // namespace detail
     144             : 
     145             : /// \brief Prints the object x to a stream.
     146             : struct stream_printer
     147             : {
     148             :   template <typename T>
     149          23 :   void operator()(const T& x, std::ostream& out)
     150             :   {
     151          23 :     core::detail::apply_printer<bes::detail::printer> printer(out);
     152          23 :     printer.apply(x);
     153          23 :   }
     154             : };
     155             : 
     156             : /// \brief Returns a string representation of the object x.
     157             : template <typename T>
     158          23 : std::string pp(const T& x)
     159             : {
     160          46 :   std::ostringstream out;
     161          23 :   stream_printer()(x, out);
     162          46 :   return out.str();
     163             : }
     164             : 
     165             : } // namespace bes
     166             : 
     167             : } // namespace mcrl2
     168             : 
     169             : #endif // MCRL2_BES_PRINT_H

Generated by: LCOV version 1.13