debug_position

#if (defined(_DEBUG) && !defined(MBLQI_DONT_DEBUG_RULES)) || defined(MBLQI_DEBUG_RULES)
#   define MBL_QI_DEBUG_PARSER( pdbg, pname, ppos )     \
    ::mbl::debug_position( pdbg, pname, ppos )
#   define MBL_QI_DEBUG_PARSER_( pdbg, pname, ppos )    MBL_QI_DEBUG_PARSER( pdbg, pname, ppos ) >>
#   define _MBL_QI_DEBUG_PARSER( pdbg, pname, ppos )    >> MBL_QI_DEBUG_PARSER( pdbg, pname, ppos )
#else
#   define MBL_QI_DEBUG_PARSER( pdbg, pname, ppos )
#   define MBL_QI_DEBUG_PARSER_( pdbg, pname, ppos )
#   define _MBL_QI_DEBUG_PARSER( pdbg, pname, ppos )
#endif

#define MBL_QI_DEBUG_MSG_START                      "<START>"
#define MBL_QI_DEBUG_MSG_END                        "<END>"
#define MBL_QI_DEBUG_PARSER_START( pdbg, pname )    MBL_QI_DEBUG_PARSER_( pdbg, pname, MBL_QI_DEBUG_MSG_START )
#define MBL_QI_DEBUG_PARSER_END( pdbg, pname )      _MBL_QI_DEBUG_PARSER( pdbg, pname, MBL_QI_DEBUG_MSG_END )

namespace mbl {

    struct parser_debugger {
        // could be virtual, but I want my type to be POD
        bool (*report)( parser_debugger*, char const* parserName, char const* msg,
            std::string const& pos );
    };

    static bool report_impl_base( parser_debugger*, char const* pname,
        char const* msg, std::string const& pos, std::ostream& os, size_t line_size,
        size_t pname_len, size_t msg_len )
    {
        size_t n = strlen( msg );
        std::string pad;
        if( n < msg_len ) pad.assign( (msg_len - n) / 2, ' ' );

        std::ios_base::fmtflags f = os.flags();
        os.flags( f | std::ios_base::left );
        os << std::setw(pname_len) << pname
            << '(' << pad << std::setw(msg_len - pad.size()) << msg << "): ";
        os.flags( f );

        bool sp = false;
        std::size_t cnt = (std::max<size_t>)(strlen(pname), pname_len) +
            (std::max<size_t>)(n, msg_len) + 4;

        for( auto i = pos.begin(); i != pos.end(); i++ ) {
            char c = *i;
            if( ::isspace(c) ) {
                if( sp ) continue;
                sp = true;
                c = ' ';
            } else {
                sp = false;
            }

            if( cnt++ >= line_size ) {
                os << "...";
                break;
            } else {
                os << c;
            }
        }
        os << std::endl;
        return true;
    }
    static bool report_impl( parser_debugger* pd, char const* pname, char const* msg,
        std::string const& pos )
    {
        return report_impl_base( pd, pname, msg, pos, std::clog, 100, 20, 10 );
    }
    static parser_debugger& default_parser_debugger() {
        static parser_debugger res = { {&report_impl} };
        return res;
    }

    BOOST_SPIRIT_TERMINAL_EX( debug_position );
    struct debug_position_parser : qi::primitive_parser<debug_position_parser> {
        debug_position_parser( parser_debugger* pdebugger, char const* pname, char const* msg )
            : pdebugger_( pdebugger ), pname_( pname ), msg_( msg ) {}

        template< typename ContextT, typename IteratorT >
        struct attribute { typedef spirit::unused_type  type; };

        template< typename IteratorT, typename ContextT, typename SkipperT, typename AttributeT >
        bool parse( IteratorT& first, IteratorT const& last, ContextT& context,
            SkipperT const& skipper, AttributeT& attr ) const
        {
            typedef std::iterator_traits<IteratorT>::value_type char_type;
            typedef std::basic_string<char_type>    string_type;

            qi::skip_over( first, last, skipper );
            if( !pdebugger_ ) return true;

            pdebugger_->report( pdebugger_, pname_, msg_,
                boost::locale::conv::utf_to_utf<char>(string_type(first, last)) );

            return true;
        }

        template< class ContextT >
        spirit::info what( ContextT& context ) const {
            return spirit::info( "debug_position", expression_ );
        }

        char const* pname_;
        char const* msg_;
        parser_debugger* pdebugger_;
    };

}

namespace boost { namespace spirit {

    template<>
    struct use_terminal<qi::domain, mbl::tag::debug_position>
        : mpl::true_ {};    // enable debug_position
    template< typename A0, typename A1, typename A2 >
    struct use_terminal<qi::domain,
        terminal_ex<mbl::tag::debug_position, fusion::vector3<A0, A1, A2> >
    > : is_convertible<A0, mbl::parser_debugger*> {}; // enable debug_position( debugger, name, pos )
    template<>
    struct use_lazy_terminal<qi::domain, mbl::tag::debug_position, 3 /*arity*/>
        : mpl::true_ {};    // enable lazy support for debug_position

    namespace qi {

        template< typename A0, typename A1, typename A2, typename ModifiersT >
        struct make_primitive<
            terminal_ex<mbl::tag::debug_position, fusion::vector3<A0, A1, A2> >, ModifiersT >
        {
            typedef mbl::debug_position_parser result_type;

            template< typename TerminalT >
            result_type operator()( TerminalT const& term, unused_type ) const {
                return result_type( fusion::at_c<0>(term.args),
                    fusion::at_c<1>(term.args), fusion::at_c<2>(term.args) );
            }
        };

    }

} }