printer.hh

Go to the documentation of this file.

#ifndef VCSN_CORE_RAT_PRINTER_HH
# define VCSN_CORE_RAT_PRINTER_HH

# include <iostream>

# include <vcsn/ctx/traits.hh>
# include <vcsn/core/rat/identities.hh>
# include <vcsn/core/rat/visitor.hh>
# include <vcsn/misc/attributes.hh>
# include <vcsn/misc/cast.hh>
# include <vcsn/misc/symbol.hh>

namespace vcsn
{
  namespace rat
  {

    template <typename RatExpSet>
    class printer
      : public RatExpSet::const_visitor
    {
    public:
      using ratexpset_t = RatExpSet;
      using context_t = context_t_of<ratexpset_t>;
      using identities_t = typename ratexpset_t::identities_t;
      using weight_t = typename context_t::weightset_t::value_t;
      using super_t = typename ratexpset_t::const_visitor;
      using node_t = typename super_t::node_t;
      using inner_t = typename super_t::inner_t;
      template <type_t Type>
      using unary_t = typename super_t::template unary_t<Type>;
      template <type_t Type>
      using variadic_t = typename super_t::template variadic_t<Type>;
      using leaf_t = typename super_t::leaf_t;

      printer(const ratexpset_t& rs,
              std::ostream& out,
              const bool debug = !!getenv("VCSN_PARENS"));

      void format(symbol format);

      std::ostream& operator()(const node_t& v);

      std::ostream&
      operator()(const std::shared_ptr<const node_t>& v)
      {
        return operator()(*v);
      }

    private:

# define DEFINE(Type)                                        \
      using Type ## _t = typename super_t::Type ## _t;       \
      virtual void visit(const Type ## _t& v)

      DEFINE(atom);
      DEFINE(complement)    { print_(v, complement_); }
      DEFINE(conjunction)   { print_(v, conjunction_); }
      DEFINE(ldiv)          { print_(v, ldiv_); }
      DEFINE(lweight);
      DEFINE(one);
      DEFINE(prod)          { print_(v, product_); }
      DEFINE(rweight);
      DEFINE(shuffle)       { print_(v, shuffle_); }
      DEFINE(star)          { print_(v, star_); }
      DEFINE(sum)           { print_(v, sum_); }
      DEFINE(transposition) { print_(v, transposition_); }
      DEFINE(zero);

# undef DEFINE

      bool is_word_(const node_t& v) const
      {
        const atom_t* atom = dynamic_cast<const atom_t*>(&v);
        return atom && ! ctx_.labelset()->is_letter(atom->value());
      }

      enum class precedence_t
      {
        sum,
        shuffle,
        conjunction,
        ldiv,
        prod,
        word = prod, // Multi-letter atoms.
        lweight,
        rweight,
        star,
        complement,
        transposition,
        zero,
        one,
        atom,
      };

      precedence_t precedence_(const node_t& v) const;

      void print_child_(const node_t& child, const node_t& parent);

      template <rat::exp::type_t Type>
      void print_(const unary_t<Type>& n, const char* op);

      template <rat::exp::type_t Type>
      void print_(const variadic_t<Type>& n, const char* op);

      ATTRIBUTE_PURE
      bool shows_left_weight_(const node_t& n)
      {
        return n.type() == rat::type_t::lweight;
      }

      std::ostream& out_;
      std::string format_;
      const context_t& ctx_;
      const identities_t identities_;
      const bool debug_;

      const char* lgroup_ = nullptr;
      const char* rgroup_ = nullptr;
      const char* langle_ = nullptr;
      const char* rangle_ = nullptr;
      const char* lparen_ = nullptr;
      const char* rparen_ = nullptr;
      const char* lmul_ = nullptr;
      const char* rmul_ = nullptr;
      const char* ldiv_ = nullptr;
      const char* star_ = nullptr;
      const char* complement_ = nullptr;
      const char* transposition_ = nullptr;
      const char* conjunction_ = nullptr;
      const char* shuffle_ = nullptr;
      const char* product_ = nullptr;
      const char* sum_ = nullptr;
      const char* zero_ = nullptr;
      const char* one_ = nullptr;
    };

  } // namespace rat
} // namespace vcsn

# include <vcsn/core/rat/printer.hxx>

#endif // !VCSN_CORE_RAT_PRINTER_HH