kakoune/src/highlighters.cc

#include "highlighters.hh"

#include "assert.hh"
#include "window.hh"
#include "display_buffer.hh"
#include "highlighter_registry.hh"
#include "highlighter_group.hh"
#include "regex.hh"

namespace Kakoune
{

using namespace std::placeholders;

typedef boost::regex_iterator<BufferIterator> RegexIterator;

void colorize_regex_range(DisplayBuffer& display_buffer,
                          const BufferIterator& range_begin,
                          const BufferIterator& range_end,
                          const Regex& ex,
                          Color fg_color, Color bg_color = Color::Default)
{
    assert(range_begin <= range_end);

    if (range_begin >= display_buffer.back().end() or
        range_end <= display_buffer.front().begin())
        return;

    BufferIterator display_begin = std::max(range_begin,
                                            display_buffer.front().begin());
    BufferIterator display_end   = std::min(range_end,
                                            display_buffer.back().end());

    RegexIterator re_it(display_begin, display_end, ex, boost::match_nosubs);
    RegexIterator re_end;
    DisplayBuffer::iterator atom_it = display_buffer.begin();
    for (; re_it != re_end; ++re_it)
    {
        BufferIterator begin = (*re_it)[0].first;
        BufferIterator end   = (*re_it)[0].second;
        assert(begin != end);

        auto begin_atom_it = display_buffer.atom_containing(begin, atom_it);
        assert(begin_atom_it != display_buffer.end());
        if (begin_atom_it->begin() != begin)
        {
            if (begin_atom_it->splitable())
                begin_atom_it = ++display_buffer.split(begin_atom_it, begin);
            else
                ++begin_atom_it;
        }

        auto end_atom_it = display_buffer.atom_containing(end, begin_atom_it);
        if (end_atom_it != display_buffer.end() and
            end_atom_it->begin() != end and end_atom_it->splitable())
            end_atom_it = ++display_buffer.split(end_atom_it, end);

        for (auto it = begin_atom_it; it != end_atom_it; ++it)
        {
            if (it->attribute() & Attributes::Final)
                continue;

            it->fg_color() = fg_color;
            it->bg_color() = bg_color;
        }

        atom_it = end_atom_it;
    }
}

void colorize_regex(DisplayBuffer& display_buffer,
                    const Regex& ex,
                    Color fg_color, Color bg_color = Color::Default)
{
    colorize_regex_range(display_buffer, display_buffer.front().begin(),
                         display_buffer.back().end(), ex, fg_color, bg_color);
}

Color parse_color(const String& color)
{
    if (color == "default") return Color::Default;
    if (color == "black")   return Color::Black;
    if (color == "red")     return Color::Red;
    if (color == "green")   return Color::Green;
    if (color == "yellow")  return Color::Yellow;
    if (color == "blue")    return Color::Blue;
    if (color == "magenta") return Color::Magenta;
    if (color == "cyan")    return Color::Cyan;
    if (color == "white")   return Color::White;
    return Color::Default;
}

HighlighterAndId colorize_regex_factory(Window& window,
                                        const HighlighterParameters params)
{
    if (params.size() != 3)
        throw runtime_error("wrong parameter count");

    Regex ex(params[0].begin(), params[0].end());

    Color fg_color = parse_color(params[1]);
    Color bg_color = parse_color(params[2]);

    String id = "colre'" + params[0] + "'";

    return HighlighterAndId(id, std::bind(colorize_regex, _1,
                                          ex, fg_color, bg_color));
}

void expand_tabulations(Window& window, DisplayBuffer& display_buffer)
{
    const int tabstop = window.option_manager()["tabstop"].as_int();
    for (auto atom_it = display_buffer.begin();
         atom_it != display_buffer.end(); ++atom_it)
    {
        for (BufferIterator it = atom_it->begin(); it != atom_it->end(); ++it)
        {
            if (*it == '\t')
            {
                if (it != atom_it->begin())
                    atom_it = ++display_buffer.split(atom_it, it);

                if (it+1 != atom_it->end())
                    atom_it = display_buffer.split(atom_it, it+1);

                BufferCoord pos = it.buffer().line_and_column_at(it);

                int column = 0;
                for (auto line_it = it.buffer().iterator_at({pos.line, 0});
                     line_it != it; ++line_it)
                {
                    assert(*line_it != '\n');
                    if (*line_it == '\t')
                        column += tabstop - (column % tabstop);
                    else
                       ++column;
                }

                int count = tabstop - (column % tabstop);
                String padding;
                for (int i = 0; i < count; ++i)
                    padding += ' ';
                display_buffer.replace_atom_content(atom_it, padding);
            }
        }
    }
}

void show_line_numbers(DisplayBuffer& display_buffer)
{
    const Buffer& buffer = display_buffer.front().begin().buffer();
    BufferCoord coord = buffer.line_and_column_at(display_buffer.begin()->begin());

    int last_line = buffer.line_count();
    int digit_count = 0;
    for (int c = last_line; c > 0; c /= 10)
        ++digit_count;

    char format[] = "%?d ";
    format[1] = '0' + digit_count;

    for (; coord.line <= last_line-1; ++coord.line)
    {
        BufferIterator line_start = buffer.iterator_at(coord);
        DisplayBuffer::iterator atom_it = display_buffer.atom_containing(line_start);
        if (atom_it != display_buffer.end())
        {
            if (atom_it->begin() != line_start)
            {
                if (not atom_it->splitable())
                    continue;

                atom_it = ++display_buffer.split(atom_it, line_start);
            }
            atom_it = display_buffer.insert_empty_atom_before(atom_it);
            atom_it->fg_color() = Color::Black;
            atom_it->bg_color() = Color::White;
            atom_it->attribute() = Attributes::Final;

            char buffer[10];
            snprintf(buffer, 10, format, coord.line + 1);
            display_buffer.replace_atom_content(atom_it, buffer);
        }
    }
}

void highlight_selections(Window& window, DisplayBuffer& display_buffer)
{
    typedef std::pair<BufferIterator, BufferIterator> BufferRange;

    std::vector<BufferRange> selections;
    for (auto& sel : window.selections())
        selections.push_back(BufferRange(sel.begin(), sel.end()));

    std::sort(selections.begin(), selections.end(),
              [](const BufferRange& lhs, const BufferRange& rhs)
              { return lhs.first < rhs.first; });

    auto atom_it = display_buffer.begin();
    auto sel_it = selections.begin();

    // underline each selections
    while (atom_it != display_buffer.end()
           and sel_it != selections.end())
    {
        BufferRange& sel = *sel_it;
        DisplayAtom& atom = *atom_it;

        if (atom.attribute() & Attributes::Final)
        {
            ++atom_it;
            continue;
        }
        // [###------]
        if (atom.begin() >= sel.first and atom.begin() < sel.second and
            atom.end() > sel.second)
        {
            atom_it = display_buffer.split(atom_it, sel.second);
            atom_it->attribute() |= Attributes::Underline;
            ++atom_it;
            ++sel_it;
        }
        // [---###---]
        else if (atom.begin() < sel.first and atom.end() > sel.second)
        {
            atom_it = display_buffer.split(atom_it, sel.first);
            atom_it = display_buffer.split(++atom_it, sel.second);
            atom_it->attribute() |= Attributes::Underline;
            ++atom_it;
            ++sel_it;
        }
        // [------###]
        else if (atom.begin() < sel.first and atom.end() > sel.first)
        {
            atom_it = ++display_buffer.split(atom_it, sel.first);
            atom_it->attribute() |= Attributes::Underline;
            ++atom_it;
        }
        // [#########]
        else if (atom.begin() >= sel.first and atom.end() <= sel.second)
        {
            atom_it->attribute() |= Attributes::Underline;
            ++atom_it;
        }
        // [---------]
        else if (atom.begin() >= sel.second)
            ++sel_it;
        // [---------]
        else if (atom.end() <= sel.first)
            ++atom_it;
        else
            assert(false);
    }

    // invert selection last char
    for (auto& sel : window.selections())
    {
        const BufferIterator& last = sel.last();

        DisplayBuffer::iterator atom_it = display_buffer.atom_containing(last);
        if (atom_it == display_buffer.end() or not atom_it->splitable())
            continue;

        if (atom_it->begin() < last)
            atom_it = ++display_buffer.split(atom_it, last);
        if (atom_it->end() > last + 1)
            atom_it = display_buffer.split(atom_it, last + 1);

        atom_it->attribute() |= Attributes::Reverse;
    }
}


template<void (*highlighter_func)(DisplayBuffer&)>
class SimpleHighlighterFactory
{
public:
    SimpleHighlighterFactory(const String& id) : m_id(id) {}

    HighlighterAndId operator()(Window& window,
                                const HighlighterParameters& params) const
    {
        return HighlighterAndId(m_id, HighlighterFunc(highlighter_func));
    }
private:
    String m_id;
};

template<void (*highlighter_func)(Window&, DisplayBuffer&)>
class WindowHighlighterFactory
{
public:
    WindowHighlighterFactory(const String& id) : m_id(id) {}

    HighlighterAndId operator()(Window& window,
                                const HighlighterParameters& params) const
    {
        return HighlighterAndId(m_id, std::bind(highlighter_func, std::ref(window), _1));
    }
private:
    String m_id;
};

HighlighterAndId highlighter_group_factory(Window& window,
                                           const HighlighterParameters& params)
{
    if (params.size() != 1)
        throw runtime_error("wrong parameter count");

    return HighlighterAndId(params[0], HighlighterGroup());
}

void register_highlighters()
{
    HighlighterRegistry& registry = HighlighterRegistry::instance();

    registry.register_factory("highlight_selections", WindowHighlighterFactory<highlight_selections>("highlight_selections"));
    registry.register_factory("expand_tabs", WindowHighlighterFactory<expand_tabulations>("expand_tabs"));
    registry.register_factory("number_lines", SimpleHighlighterFactory<show_line_numbers>("number_lines"));
    registry.register_factory("regex", colorize_regex_factory);
    registry.register_factory("group", highlighter_group_factory);
}

}