2011-11-29 23:37:20 +01:00
|
|
|
#include "highlighters.hh"
|
2013-04-09 19:39:03 +02:00
|
|
|
|
2011-11-14 15:23:02 +01:00
|
|
|
#include "assert.hh"
|
2014-05-09 14:50:12 +02:00
|
|
|
#include "buffer_utils.hh"
|
2012-12-31 14:28:32 +01:00
|
|
|
#include "context.hh"
|
2014-12-23 14:54:09 +01:00
|
|
|
#include "containers.hh"
|
2013-12-17 00:24:08 +01:00
|
|
|
#include "display_buffer.hh"
|
2014-07-11 01:27:04 +02:00
|
|
|
#include "face_registry.hh"
|
|
|
|
#include "highlighter_group.hh"
|
2014-05-26 22:01:45 +02:00
|
|
|
#include "line_modification.hh"
|
2013-04-09 19:39:03 +02:00
|
|
|
#include "option_types.hh"
|
2014-07-11 01:27:04 +02:00
|
|
|
#include "parameters_parser.hh"
|
2013-04-09 19:39:03 +02:00
|
|
|
#include "register_manager.hh"
|
2012-08-29 21:49:36 +02:00
|
|
|
#include "string.hh"
|
2012-10-08 14:27:43 +02:00
|
|
|
#include "utf8.hh"
|
2013-02-26 14:12:21 +01:00
|
|
|
#include "utf8_iterator.hh"
|
2013-03-26 00:14:38 +01:00
|
|
|
|
2013-02-26 14:12:21 +01:00
|
|
|
#include <sstream>
|
|
|
|
#include <locale>
|
2011-11-08 15:28:01 +01:00
|
|
|
|
2011-09-30 21:16:23 +02:00
|
|
|
namespace Kakoune
|
|
|
|
{
|
|
|
|
|
2012-04-03 15:39:20 +02:00
|
|
|
using namespace std::placeholders;
|
|
|
|
|
2012-07-12 23:19:10 +02:00
|
|
|
template<typename T>
|
|
|
|
void highlight_range(DisplayBuffer& display_buffer,
|
2014-05-07 20:51:01 +02:00
|
|
|
ByteCoord begin, ByteCoord end,
|
2012-07-12 23:19:10 +02:00
|
|
|
bool skip_replaced, T func)
|
2011-09-30 21:16:23 +02:00
|
|
|
{
|
2012-08-10 14:20:15 +02:00
|
|
|
if (begin == end or end <= display_buffer.range().first
|
|
|
|
or begin >= display_buffer.range().second)
|
2012-07-12 23:51:13 +02:00
|
|
|
return;
|
|
|
|
|
2012-07-12 23:19:10 +02:00
|
|
|
for (auto& line : display_buffer.lines())
|
2011-09-30 21:16:23 +02:00
|
|
|
{
|
2013-07-23 20:11:26 +02:00
|
|
|
auto& range = line.range();
|
|
|
|
if (range.second <= begin or end < range.first)
|
2012-12-12 19:33:29 +01:00
|
|
|
continue;
|
|
|
|
|
|
|
|
for (auto atom_it = line.begin(); atom_it != line.end(); ++atom_it)
|
2012-07-03 23:23:07 +02:00
|
|
|
{
|
2013-07-24 14:55:57 +02:00
|
|
|
bool is_replaced = atom_it->type() == DisplayAtom::ReplacedBufferRange;
|
2011-11-14 15:23:02 +01:00
|
|
|
|
2013-07-24 14:55:57 +02:00
|
|
|
if (not atom_it->has_buffer_range() or
|
2012-12-12 19:33:29 +01:00
|
|
|
(skip_replaced and is_replaced))
|
|
|
|
continue;
|
2011-09-30 21:16:23 +02:00
|
|
|
|
2013-07-24 14:55:57 +02:00
|
|
|
if (end <= atom_it->begin() or begin >= atom_it->end())
|
2012-12-12 19:33:29 +01:00
|
|
|
continue;
|
2012-02-22 22:48:14 +01:00
|
|
|
|
2013-07-24 14:55:57 +02:00
|
|
|
if (not is_replaced and begin > atom_it->begin())
|
2012-12-12 19:33:29 +01:00
|
|
|
atom_it = ++line.split(atom_it, begin);
|
2011-11-14 15:23:02 +01:00
|
|
|
|
2013-07-24 14:55:57 +02:00
|
|
|
if (not is_replaced and end < atom_it->end())
|
2012-12-12 19:33:29 +01:00
|
|
|
{
|
|
|
|
atom_it = line.split(atom_it, end);
|
|
|
|
func(*atom_it);
|
|
|
|
++atom_it;
|
2012-07-12 23:19:10 +02:00
|
|
|
}
|
2012-12-12 19:33:29 +01:00
|
|
|
else
|
|
|
|
func(*atom_it);
|
2012-07-12 23:19:10 +02:00
|
|
|
}
|
2011-09-30 21:16:23 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-12-17 00:24:08 +01:00
|
|
|
void apply_highlighter(const Context& context,
|
2014-01-18 02:56:51 +01:00
|
|
|
HighlightFlags flags,
|
2013-12-11 22:38:43 +01:00
|
|
|
DisplayBuffer& display_buffer,
|
2014-05-07 20:51:01 +02:00
|
|
|
ByteCoord begin, ByteCoord end,
|
2014-10-22 01:20:09 +02:00
|
|
|
Highlighter& highlighter)
|
2013-12-11 22:38:43 +01:00
|
|
|
{
|
|
|
|
using LineIterator = DisplayBuffer::LineList::iterator;
|
|
|
|
LineIterator first_line;
|
2015-01-12 14:24:30 +01:00
|
|
|
Vector<DisplayLine::iterator> insert_pos;
|
2013-12-11 22:38:43 +01:00
|
|
|
auto line_end = display_buffer.lines().end();
|
|
|
|
|
|
|
|
DisplayBuffer region_display;
|
|
|
|
auto& region_lines = region_display.lines();
|
|
|
|
for (auto line_it = display_buffer.lines().begin(); line_it != line_end; ++line_it)
|
|
|
|
{
|
|
|
|
auto& line = *line_it;
|
|
|
|
auto& range = line.range();
|
2014-06-16 20:41:07 +02:00
|
|
|
if (range.second <= begin or end <= range.first)
|
2013-12-11 22:38:43 +01:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (region_lines.empty())
|
|
|
|
first_line = line_it;
|
|
|
|
region_lines.emplace_back();
|
|
|
|
insert_pos.emplace_back();
|
|
|
|
|
|
|
|
if (range.first < begin or range.second > end)
|
|
|
|
{
|
|
|
|
size_t beg_idx = 0;
|
|
|
|
size_t end_idx = line.atoms().size();
|
|
|
|
|
|
|
|
for (auto atom_it = line.begin(); atom_it != line.end(); ++atom_it)
|
|
|
|
{
|
|
|
|
if (not atom_it->has_buffer_range() or end <= atom_it->begin() or begin >= atom_it->end())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
bool is_replaced = atom_it->type() == DisplayAtom::ReplacedBufferRange;
|
|
|
|
if (atom_it->begin() <= begin)
|
|
|
|
{
|
|
|
|
if (is_replaced or atom_it->begin() == begin)
|
|
|
|
beg_idx = atom_it - line.begin();
|
|
|
|
else
|
|
|
|
{
|
|
|
|
atom_it = ++line.split(atom_it, begin);
|
|
|
|
beg_idx = atom_it - line.begin();
|
|
|
|
++end_idx;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (atom_it->end() >= end)
|
|
|
|
{
|
|
|
|
if (is_replaced or atom_it->end() == end)
|
2014-07-14 22:41:29 +02:00
|
|
|
end_idx = atom_it - line.begin() + 1;
|
2013-12-11 22:38:43 +01:00
|
|
|
else
|
|
|
|
{
|
|
|
|
atom_it = ++line.split(atom_it, end);
|
|
|
|
end_idx = atom_it - line.begin();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
std::move(line.begin() + beg_idx, line.begin() + end_idx,
|
|
|
|
std::back_inserter(region_lines.back()));
|
|
|
|
insert_pos.back() = line.erase(line.begin() + beg_idx, line.begin() + end_idx);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
region_lines.back() = std::move(line);
|
|
|
|
insert_pos.back() = line.begin();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
region_display.compute_range();
|
2014-12-02 20:56:17 +01:00
|
|
|
highlighter.highlight(context, flags, region_display, {begin, end});
|
2013-12-11 22:38:43 +01:00
|
|
|
|
|
|
|
for (size_t i = 0; i < region_lines.size(); ++i)
|
|
|
|
{
|
|
|
|
auto& line = *(first_line + i);
|
|
|
|
auto pos = insert_pos[i];
|
|
|
|
for (auto& atom : region_lines[i])
|
|
|
|
pos = ++line.insert(pos, std::move(atom));
|
|
|
|
}
|
|
|
|
display_buffer.compute_range();
|
|
|
|
}
|
|
|
|
|
2014-07-11 01:27:04 +02:00
|
|
|
auto apply_face = [](const Face& face)
|
2014-06-18 21:31:49 +02:00
|
|
|
{
|
2014-07-11 01:27:04 +02:00
|
|
|
return [&face](DisplayAtom& atom) {
|
|
|
|
if (face.fg != Colors::Default)
|
|
|
|
atom.face.fg = face.fg;
|
|
|
|
if (face.bg != Colors::Default)
|
|
|
|
atom.face.bg = face.bg;
|
2014-07-15 21:11:47 +02:00
|
|
|
if (face.attributes != Attribute::Normal)
|
2014-07-11 01:27:04 +02:00
|
|
|
atom.face.attributes |= face.attributes;
|
2014-06-18 21:33:23 +02:00
|
|
|
};
|
2014-06-18 21:31:49 +02:00
|
|
|
};
|
|
|
|
|
2015-01-12 14:24:30 +01:00
|
|
|
using FacesSpec = Vector<String, MemoryDomain::Highlight>;
|
2012-08-15 17:08:48 +02:00
|
|
|
|
2014-10-22 01:20:09 +02:00
|
|
|
static HighlighterAndId create_fill_highlighter(HighlighterParameters params)
|
2014-06-10 22:46:16 +02:00
|
|
|
{
|
2014-09-19 14:45:11 +02:00
|
|
|
if (params.size() != 1)
|
|
|
|
throw runtime_error("wrong parameter count");
|
|
|
|
|
|
|
|
const String& facespec = params[0];
|
|
|
|
get_face(facespec); // validate param
|
2014-06-10 22:46:16 +02:00
|
|
|
|
2014-10-22 01:20:09 +02:00
|
|
|
auto func = [=](const Context& context, HighlightFlags flags,
|
2014-12-02 20:56:17 +01:00
|
|
|
DisplayBuffer& display_buffer, BufferRange range)
|
2014-06-10 22:46:16 +02:00
|
|
|
{
|
|
|
|
highlight_range(display_buffer, range.first, range.second, true,
|
2014-09-19 14:45:11 +02:00
|
|
|
apply_face(get_face(facespec)));
|
|
|
|
};
|
2014-10-22 01:20:09 +02:00
|
|
|
return {"fill_" + facespec, make_simple_highlighter(std::move(func))};
|
2014-06-10 22:46:16 +02:00
|
|
|
}
|
|
|
|
|
2014-01-09 23:51:23 +01:00
|
|
|
template<typename T>
|
|
|
|
struct BufferSideCache
|
|
|
|
{
|
|
|
|
BufferSideCache() : m_id{ValueId::get_free_id()} {}
|
|
|
|
|
|
|
|
T& get(const Buffer& buffer)
|
|
|
|
{
|
|
|
|
Value& cache_val = buffer.values()[m_id];
|
|
|
|
if (not cache_val)
|
2014-05-14 22:19:19 +02:00
|
|
|
cache_val = Value(T{});
|
2014-01-09 23:51:23 +01:00
|
|
|
return cache_val.as<T>();
|
|
|
|
}
|
|
|
|
private:
|
|
|
|
ValueId m_id;
|
|
|
|
};
|
|
|
|
|
2014-10-22 01:20:09 +02:00
|
|
|
class RegexHighlighter : public Highlighter
|
2011-11-24 20:11:58 +01:00
|
|
|
{
|
2012-08-15 17:08:48 +02:00
|
|
|
public:
|
2014-07-12 14:57:16 +02:00
|
|
|
RegexHighlighter(Regex regex, FacesSpec faces)
|
2014-07-11 01:27:04 +02:00
|
|
|
: m_regex{std::move(regex)}, m_faces{std::move(faces)}
|
2012-08-15 17:08:48 +02:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2014-12-02 20:56:17 +01:00
|
|
|
void highlight(const Context& context, HighlightFlags flags, DisplayBuffer& display_buffer, BufferRange) override
|
2012-07-12 23:19:10 +02:00
|
|
|
{
|
2014-01-18 02:56:51 +01:00
|
|
|
if (flags != HighlightFlags::Highlight)
|
|
|
|
return;
|
2014-07-12 12:19:35 +02:00
|
|
|
|
2015-01-12 14:58:41 +01:00
|
|
|
Vector<Optional<Face>> faces(m_faces.size());
|
2013-12-17 00:24:08 +01:00
|
|
|
auto& cache = update_cache_ifn(context.buffer(), display_buffer.range());
|
2013-12-04 19:52:16 +01:00
|
|
|
for (auto& match : cache.m_matches)
|
2012-08-07 00:13:54 +02:00
|
|
|
{
|
2012-08-15 17:08:48 +02:00
|
|
|
for (size_t n = 0; n < match.size(); ++n)
|
|
|
|
{
|
2014-07-12 12:19:35 +02:00
|
|
|
if (n >= m_faces.size() or m_faces[n].empty())
|
2012-08-15 17:08:48 +02:00
|
|
|
continue;
|
2014-07-12 12:19:35 +02:00
|
|
|
if (not faces[n])
|
|
|
|
faces[n] = get_face(m_faces[n]);
|
2012-08-15 17:08:48 +02:00
|
|
|
|
2013-11-19 00:17:06 +01:00
|
|
|
highlight_range(display_buffer, match[n].first, match[n].second, true,
|
2014-07-12 12:19:35 +02:00
|
|
|
apply_face(*faces[n]));
|
2012-08-15 17:08:48 +02:00
|
|
|
}
|
2012-08-07 00:13:54 +02:00
|
|
|
}
|
2012-07-12 23:19:10 +02:00
|
|
|
}
|
2012-08-15 17:08:48 +02:00
|
|
|
|
2014-10-22 01:20:09 +02:00
|
|
|
void reset(Regex regex, FacesSpec faces)
|
|
|
|
{
|
|
|
|
m_regex = std::move(regex);
|
|
|
|
m_faces = std::move(faces);
|
|
|
|
m_force_update = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static HighlighterAndId create(HighlighterParameters params)
|
|
|
|
{
|
|
|
|
if (params.size() < 2)
|
|
|
|
throw runtime_error("wrong parameter count");
|
|
|
|
|
|
|
|
try
|
|
|
|
{
|
|
|
|
static Regex face_spec_ex(R"((\d+):(.*))");
|
|
|
|
FacesSpec faces;
|
|
|
|
for (auto it = params.begin() + 1; it != params.end(); ++it)
|
|
|
|
{
|
|
|
|
MatchResults<String::const_iterator> res;
|
|
|
|
if (not regex_match(it->begin(), it->end(), res, face_spec_ex))
|
|
|
|
throw runtime_error("wrong face spec: '" + *it +
|
|
|
|
"' expected <capture>:<facespec>");
|
|
|
|
get_face(res[2].str()); // throw if wrong face spec
|
|
|
|
int capture = str_to_int(res[1].str());
|
|
|
|
if (capture >= faces.size())
|
|
|
|
faces.resize(capture+1);
|
|
|
|
faces[capture] = res[2].str();
|
|
|
|
}
|
|
|
|
|
|
|
|
String id = "hlregex'" + params[0] + "'";
|
|
|
|
|
|
|
|
Regex ex{params[0].begin(), params[0].end(), Regex::optimize};
|
|
|
|
|
|
|
|
return {id, make_unique<RegexHighlighter>(std::move(ex),
|
|
|
|
std::move(faces))};
|
|
|
|
}
|
|
|
|
catch (RegexError& err)
|
|
|
|
{
|
|
|
|
throw runtime_error(String("regex error: ") + err.what());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-15 17:08:48 +02:00
|
|
|
private:
|
2014-01-12 22:24:59 +01:00
|
|
|
struct Cache
|
2013-11-19 00:17:06 +01:00
|
|
|
{
|
2014-05-14 20:22:42 +02:00
|
|
|
std::pair<LineCount, LineCount> m_range;
|
|
|
|
size_t m_timestamp = 0;
|
2015-01-12 14:24:30 +01:00
|
|
|
Vector<Vector<BufferRange, MemoryDomain::Highlight>, MemoryDomain::Highlight> m_matches;
|
2013-11-19 00:17:06 +01:00
|
|
|
};
|
2014-01-12 22:24:59 +01:00
|
|
|
BufferSideCache<Cache> m_cache;
|
2012-08-15 17:08:48 +02:00
|
|
|
|
|
|
|
Regex m_regex;
|
2014-07-12 12:19:35 +02:00
|
|
|
FacesSpec m_faces;
|
2012-08-15 17:08:48 +02:00
|
|
|
|
2014-10-22 01:20:09 +02:00
|
|
|
bool m_force_update = false;
|
|
|
|
|
2014-01-12 22:24:59 +01:00
|
|
|
Cache& update_cache_ifn(const Buffer& buffer, const BufferRange& range)
|
2012-08-15 17:08:48 +02:00
|
|
|
{
|
2014-01-12 22:24:59 +01:00
|
|
|
Cache& cache = m_cache.get(buffer);
|
2013-11-19 00:17:06 +01:00
|
|
|
|
2014-05-14 20:22:42 +02:00
|
|
|
LineCount first_line = range.first.line;
|
|
|
|
LineCount last_line = std::min(buffer.line_count()-1, range.second.line);
|
|
|
|
|
2014-10-22 01:20:09 +02:00
|
|
|
if (not m_force_update and
|
|
|
|
buffer.timestamp() == cache.m_timestamp and
|
2014-05-14 20:22:42 +02:00
|
|
|
first_line >= cache.m_range.first and
|
|
|
|
last_line <= cache.m_range.second)
|
2013-12-04 19:52:16 +01:00
|
|
|
return cache;
|
2012-08-15 17:08:48 +02:00
|
|
|
|
2014-10-22 01:20:09 +02:00
|
|
|
m_force_update = false;
|
|
|
|
|
2014-05-14 20:22:42 +02:00
|
|
|
cache.m_range.first = std::max(0_line, first_line - 10);
|
|
|
|
cache.m_range.second = std::min(buffer.line_count()-1, last_line+10);
|
2013-11-19 00:17:06 +01:00
|
|
|
cache.m_timestamp = buffer.timestamp();
|
2012-08-15 17:08:48 +02:00
|
|
|
|
2013-11-19 00:17:06 +01:00
|
|
|
cache.m_matches.clear();
|
2014-10-13 14:12:33 +02:00
|
|
|
|
|
|
|
using RegexIt = RegexIterator<BufferIterator>;
|
|
|
|
RegexIt re_it{buffer.iterator_at(cache.m_range.first),
|
|
|
|
buffer.iterator_at(cache.m_range.second+1), m_regex};
|
|
|
|
RegexIt re_end;
|
2012-08-15 17:08:48 +02:00
|
|
|
for (; re_it != re_end; ++re_it)
|
2013-11-19 00:17:06 +01:00
|
|
|
{
|
|
|
|
cache.m_matches.emplace_back();
|
|
|
|
auto& match = cache.m_matches.back();
|
|
|
|
for (auto& sub : *re_it)
|
|
|
|
match.emplace_back(sub.first.coord(), sub.second.coord());
|
|
|
|
}
|
2013-12-04 19:52:16 +01:00
|
|
|
return cache;
|
2012-08-15 17:08:48 +02:00
|
|
|
}
|
|
|
|
};
|
2011-11-24 20:11:58 +01:00
|
|
|
|
2014-07-11 01:27:04 +02:00
|
|
|
template<typename RegexGetter, typename FaceGetter>
|
2014-10-22 01:20:09 +02:00
|
|
|
class DynamicRegexHighlighter : public Highlighter
|
2012-12-31 14:28:32 +01:00
|
|
|
{
|
|
|
|
public:
|
2014-07-11 01:27:04 +02:00
|
|
|
DynamicRegexHighlighter(RegexGetter regex_getter, FaceGetter face_getter)
|
2014-05-13 20:35:28 +02:00
|
|
|
: m_regex_getter(std::move(regex_getter)),
|
2014-07-11 01:27:04 +02:00
|
|
|
m_face_getter(std::move(face_getter)),
|
2014-07-12 14:57:16 +02:00
|
|
|
m_highlighter(Regex(), FacesSpec{}) {}
|
2012-12-31 14:28:32 +01:00
|
|
|
|
2014-12-02 20:56:17 +01:00
|
|
|
void highlight(const Context& context, HighlightFlags flags, DisplayBuffer& display_buffer, BufferRange range)
|
2012-12-31 14:28:32 +01:00
|
|
|
{
|
2014-01-18 02:56:51 +01:00
|
|
|
if (flags != HighlightFlags::Highlight)
|
|
|
|
return;
|
|
|
|
|
2013-12-17 00:24:08 +01:00
|
|
|
Regex regex = m_regex_getter(context);
|
2014-07-12 12:19:35 +02:00
|
|
|
FacesSpec face = m_face_getter(context);
|
2014-07-11 01:27:04 +02:00
|
|
|
if (regex != m_last_regex or face != m_last_face)
|
2012-12-31 14:28:32 +01:00
|
|
|
{
|
2013-03-26 14:26:59 +01:00
|
|
|
m_last_regex = regex;
|
2014-07-11 01:27:04 +02:00
|
|
|
m_last_face = face;
|
2013-03-26 14:26:59 +01:00
|
|
|
if (not m_last_regex.empty())
|
2014-10-22 01:20:09 +02:00
|
|
|
m_highlighter.reset(m_last_regex, m_last_face);
|
2012-12-31 14:28:32 +01:00
|
|
|
}
|
2014-07-11 01:27:04 +02:00
|
|
|
if (not m_last_regex.empty() and not m_last_face.empty())
|
2014-12-02 20:56:17 +01:00
|
|
|
m_highlighter.highlight(context, flags, display_buffer, range);
|
2012-12-31 14:28:32 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2014-07-11 01:27:04 +02:00
|
|
|
Regex m_last_regex;
|
|
|
|
RegexGetter m_regex_getter;
|
2014-05-13 20:35:28 +02:00
|
|
|
|
2014-07-12 12:19:35 +02:00
|
|
|
FacesSpec m_last_face;
|
2014-07-11 01:27:04 +02:00
|
|
|
FaceGetter m_face_getter;
|
2014-05-13 20:35:28 +02:00
|
|
|
|
2014-07-12 14:57:16 +02:00
|
|
|
RegexHighlighter m_highlighter;
|
2012-12-31 14:28:32 +01:00
|
|
|
};
|
|
|
|
|
2014-07-11 01:27:04 +02:00
|
|
|
template<typename RegexGetter, typename FaceGetter>
|
2014-10-22 01:20:09 +02:00
|
|
|
std::unique_ptr<DynamicRegexHighlighter<RegexGetter, FaceGetter>>
|
2014-07-11 01:27:04 +02:00
|
|
|
make_dynamic_regex_highlighter(RegexGetter regex_getter, FaceGetter face_getter)
|
2014-05-13 20:35:28 +02:00
|
|
|
{
|
2014-10-22 01:20:09 +02:00
|
|
|
return make_unique<DynamicRegexHighlighter<RegexGetter, FaceGetter>>(
|
2014-07-11 01:27:04 +02:00
|
|
|
std::move(regex_getter), std::move(face_getter));
|
2014-05-13 20:35:28 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-10-22 01:20:09 +02:00
|
|
|
HighlighterAndId create_search_highlighter(HighlighterParameters params)
|
2012-12-31 14:28:32 +01:00
|
|
|
{
|
2014-05-13 20:35:28 +02:00
|
|
|
if (params.size() != 0)
|
2012-12-31 14:28:32 +01:00
|
|
|
throw runtime_error("wrong parameter count");
|
2014-07-11 01:27:04 +02:00
|
|
|
auto get_face = [](const Context& context){
|
2014-07-12 12:19:35 +02:00
|
|
|
return FacesSpec{ { "Search" } };
|
2014-05-13 20:35:28 +02:00
|
|
|
};
|
2013-12-17 00:24:08 +01:00
|
|
|
auto get_regex = [](const Context&){
|
2014-06-21 12:31:08 +02:00
|
|
|
auto s = Context().main_sel_register_value("/");
|
2014-05-13 20:35:28 +02:00
|
|
|
try
|
|
|
|
{
|
2014-06-21 12:31:08 +02:00
|
|
|
return s.empty() ? Regex{} : Regex{s.begin(), s.end()};
|
2014-05-13 20:35:28 +02:00
|
|
|
}
|
2014-10-13 14:12:33 +02:00
|
|
|
catch (RegexError& err)
|
2014-05-13 20:35:28 +02:00
|
|
|
{
|
|
|
|
return Regex{};
|
|
|
|
}
|
2013-03-26 14:26:59 +01:00
|
|
|
};
|
2014-07-11 01:27:04 +02:00
|
|
|
return {"hlsearch", make_dynamic_regex_highlighter(get_regex, get_face)};
|
2013-04-03 19:20:38 +02:00
|
|
|
}
|
2012-12-31 14:28:32 +01:00
|
|
|
|
2014-10-22 01:20:09 +02:00
|
|
|
HighlighterAndId create_regex_option_highlighter(HighlighterParameters params)
|
2013-03-26 14:26:59 +01:00
|
|
|
{
|
|
|
|
if (params.size() != 2)
|
|
|
|
throw runtime_error("wrong parameter count");
|
|
|
|
|
2014-07-12 12:19:35 +02:00
|
|
|
String facespec = params[1];
|
|
|
|
auto get_face = [=](const Context&){
|
|
|
|
return FacesSpec{ { facespec } };
|
2014-05-13 20:35:28 +02:00
|
|
|
};
|
|
|
|
|
2013-03-26 14:26:59 +01:00
|
|
|
String option_name = params[0];
|
|
|
|
// verify option type now
|
2014-10-30 15:00:42 +01:00
|
|
|
GlobalScope::instance().options()[option_name].get<Regex>();
|
2013-03-26 14:26:59 +01:00
|
|
|
|
2014-05-13 20:35:28 +02:00
|
|
|
auto get_regex = [option_name](const Context& context){
|
|
|
|
return context.options()[option_name].get<Regex>();
|
|
|
|
};
|
2014-07-11 01:27:04 +02:00
|
|
|
return {"hloption_" + option_name, make_dynamic_regex_highlighter(get_regex, get_face)};
|
2013-04-03 19:20:38 +02:00
|
|
|
}
|
2013-03-26 14:26:59 +01:00
|
|
|
|
2014-10-22 01:20:09 +02:00
|
|
|
HighlighterAndId create_line_option_highlighter(HighlighterParameters params)
|
2014-06-18 21:50:39 +02:00
|
|
|
{
|
|
|
|
if (params.size() != 2)
|
|
|
|
throw runtime_error("wrong parameter count");
|
|
|
|
|
2014-07-13 17:52:51 +02:00
|
|
|
String facespec = params[1];
|
2014-06-18 21:50:39 +02:00
|
|
|
String option_name = params[0];
|
|
|
|
|
2014-10-22 01:20:09 +02:00
|
|
|
get_face(facespec); // validate facespec
|
2014-10-30 15:00:42 +01:00
|
|
|
GlobalScope::instance().options()[option_name].get<int>(); // verify option type now
|
2014-10-22 01:20:09 +02:00
|
|
|
|
|
|
|
auto func = [=](const Context& context, HighlightFlags flags,
|
2014-12-02 20:56:17 +01:00
|
|
|
DisplayBuffer& display_buffer, BufferRange)
|
2014-06-18 21:50:39 +02:00
|
|
|
{
|
|
|
|
int line = context.options()[option_name].get<int>();
|
|
|
|
highlight_range(display_buffer, {line-1, 0}, {line, 0}, false,
|
2014-07-13 17:52:51 +02:00
|
|
|
apply_face(get_face(facespec)));
|
2014-06-18 21:50:39 +02:00
|
|
|
};
|
|
|
|
|
2014-10-22 01:20:09 +02:00
|
|
|
return {"hlline_" + params[0], make_simple_highlighter(std::move(func))};
|
2014-06-18 21:50:39 +02:00
|
|
|
}
|
|
|
|
|
2014-12-02 20:56:17 +01:00
|
|
|
void expand_tabulations(const Context& context, HighlightFlags flags, DisplayBuffer& display_buffer, BufferRange)
|
2011-10-12 20:52:22 +02:00
|
|
|
{
|
2013-12-17 00:24:08 +01:00
|
|
|
const int tabstop = context.options()["tabstop"].get<int>();
|
|
|
|
auto& buffer = context.buffer();
|
2012-07-12 23:19:10 +02:00
|
|
|
for (auto& line : display_buffer.lines())
|
2011-10-12 20:52:22 +02:00
|
|
|
{
|
2012-07-12 23:19:10 +02:00
|
|
|
for (auto atom_it = line.begin(); atom_it != line.end(); ++atom_it)
|
2011-10-12 20:52:22 +02:00
|
|
|
{
|
2013-07-24 14:55:57 +02:00
|
|
|
if (atom_it->type() != DisplayAtom::BufferRange)
|
2012-07-12 23:19:10 +02:00
|
|
|
continue;
|
2011-10-17 21:01:36 +02:00
|
|
|
|
2013-07-24 14:55:57 +02:00
|
|
|
auto begin = buffer.iterator_at(atom_it->begin());
|
|
|
|
auto end = buffer.iterator_at(atom_it->end());
|
2012-07-12 23:19:10 +02:00
|
|
|
for (BufferIterator it = begin; it != end; ++it)
|
|
|
|
{
|
|
|
|
if (*it == '\t')
|
2011-10-15 06:45:49 +02:00
|
|
|
{
|
2012-07-12 23:19:10 +02:00
|
|
|
if (it != begin)
|
2013-05-23 13:59:33 +02:00
|
|
|
atom_it = ++line.split(atom_it, it.coord());
|
2012-07-12 23:19:10 +02:00
|
|
|
if (it+1 != end)
|
2013-05-23 13:59:33 +02:00
|
|
|
atom_it = line.split(atom_it, (it+1).coord());
|
2012-07-12 23:19:10 +02:00
|
|
|
|
2014-05-09 14:50:12 +02:00
|
|
|
int column = (int)get_column(buffer, tabstop, it.coord());
|
2012-07-12 23:19:10 +02:00
|
|
|
int count = tabstop - (column % tabstop);
|
|
|
|
String padding;
|
|
|
|
for (int i = 0; i < count; ++i)
|
|
|
|
padding += ' ';
|
2013-07-24 14:55:57 +02:00
|
|
|
atom_it->replace(padding);
|
2012-07-12 23:19:10 +02:00
|
|
|
break;
|
2011-10-15 06:45:49 +02:00
|
|
|
}
|
2011-10-12 20:52:22 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-02 20:56:17 +01:00
|
|
|
void show_whitespaces(const Context& context, HighlightFlags flags, DisplayBuffer& display_buffer, BufferRange)
|
2014-05-09 14:50:12 +02:00
|
|
|
{
|
|
|
|
const int tabstop = context.options()["tabstop"].get<int>();
|
|
|
|
auto& buffer = context.buffer();
|
|
|
|
for (auto& line : display_buffer.lines())
|
|
|
|
{
|
|
|
|
for (auto atom_it = line.begin(); atom_it != line.end(); ++atom_it)
|
|
|
|
{
|
|
|
|
if (atom_it->type() != DisplayAtom::BufferRange)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
auto begin = buffer.iterator_at(atom_it->begin());
|
|
|
|
auto end = buffer.iterator_at(atom_it->end());
|
|
|
|
for (BufferIterator it = begin; it != end; ++it)
|
|
|
|
{
|
|
|
|
auto c = *it;
|
|
|
|
if (c == '\t' or c == ' ' or c == '\n')
|
|
|
|
{
|
|
|
|
if (it != begin)
|
|
|
|
atom_it = ++line.split(atom_it, it.coord());
|
|
|
|
if (it+1 != end)
|
|
|
|
atom_it = line.split(atom_it, (it+1).coord());
|
|
|
|
|
|
|
|
if (c == '\t')
|
|
|
|
{
|
|
|
|
int column = (int)get_column(buffer, tabstop, it.coord());
|
|
|
|
int count = tabstop - (column % tabstop);
|
|
|
|
String padding = "→";
|
|
|
|
for (int i = 0; i < count-1; ++i)
|
|
|
|
padding += ' ';
|
|
|
|
atom_it->replace(padding);
|
|
|
|
}
|
|
|
|
else if (c == ' ')
|
|
|
|
atom_it->replace("·");
|
|
|
|
else if (c == '\n')
|
|
|
|
atom_it->replace("¬");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-02 20:56:17 +01:00
|
|
|
void show_line_numbers(const Context& context, HighlightFlags flags, DisplayBuffer& display_buffer, BufferRange)
|
2011-10-17 21:01:36 +02:00
|
|
|
{
|
2013-12-17 00:24:08 +01:00
|
|
|
LineCount last_line = context.buffer().line_count();
|
2012-02-22 21:43:59 +01:00
|
|
|
int digit_count = 0;
|
2012-08-22 23:33:52 +02:00
|
|
|
for (LineCount c = last_line; c > 0; c /= 10)
|
2012-02-22 21:43:59 +01:00
|
|
|
++digit_count;
|
|
|
|
|
2013-05-24 18:39:03 +02:00
|
|
|
char format[] = "%?d│";
|
2012-02-22 21:43:59 +01:00
|
|
|
format[1] = '0' + digit_count;
|
2014-07-12 12:19:35 +02:00
|
|
|
const Face face = get_face("LineNumbers");
|
2012-07-12 23:19:10 +02:00
|
|
|
for (auto& line : display_buffer.lines())
|
2011-10-17 21:01:36 +02:00
|
|
|
{
|
2012-07-12 23:19:10 +02:00
|
|
|
char buffer[10];
|
2013-07-23 20:11:26 +02:00
|
|
|
snprintf(buffer, 10, format, (int)line.range().first.line + 1);
|
2013-07-24 14:55:57 +02:00
|
|
|
DisplayAtom atom{buffer};
|
2014-07-11 01:27:04 +02:00
|
|
|
atom.face = face;
|
2012-07-12 23:19:10 +02:00
|
|
|
line.insert(line.begin(), std::move(atom));
|
2011-10-17 21:01:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-02 20:56:17 +01:00
|
|
|
void show_matching_char(const Context& context, HighlightFlags flags, DisplayBuffer& display_buffer, BufferRange)
|
2014-01-20 22:01:26 +01:00
|
|
|
{
|
2014-07-12 12:19:35 +02:00
|
|
|
const Face face = get_face("MatchingChar");
|
2014-01-20 22:01:26 +01:00
|
|
|
using CodepointPair = std::pair<Codepoint, Codepoint>;
|
2014-04-02 23:52:00 +02:00
|
|
|
static const CodepointPair matching_chars[] = { { '(', ')' }, { '{', '}' }, { '[', ']' }, { '<', '>' } };
|
2014-01-20 22:01:26 +01:00
|
|
|
const auto range = display_buffer.range();
|
|
|
|
const auto& buffer = context.buffer();
|
|
|
|
for (auto& sel : context.selections())
|
|
|
|
{
|
2014-01-28 20:05:49 +01:00
|
|
|
auto pos = sel.cursor();
|
2014-01-20 22:01:26 +01:00
|
|
|
if (pos < range.first or pos >= range.second)
|
|
|
|
continue;
|
|
|
|
auto c = buffer.byte_at(pos);
|
|
|
|
for (auto& pair : matching_chars)
|
|
|
|
{
|
|
|
|
int level = 1;
|
|
|
|
if (c == pair.first)
|
|
|
|
{
|
|
|
|
auto it = buffer.iterator_at(pos)+1;
|
|
|
|
auto end = buffer.iterator_at(range.second);
|
|
|
|
skip_while(it, end, [&](char c) {
|
|
|
|
if (c == pair.first)
|
|
|
|
++level;
|
|
|
|
else if (c == pair.second and --level == 0)
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
});
|
|
|
|
if (it != end)
|
|
|
|
highlight_range(display_buffer, it.coord(), (it+1).coord(), false,
|
2014-07-11 01:27:04 +02:00
|
|
|
apply_face(face));
|
2014-01-20 22:01:26 +01:00
|
|
|
break;
|
|
|
|
}
|
2014-06-27 22:09:44 +02:00
|
|
|
else if (c == pair.second and pos > range.first)
|
2014-01-20 22:01:26 +01:00
|
|
|
{
|
|
|
|
auto it = buffer.iterator_at(pos)-1;
|
|
|
|
auto end = buffer.iterator_at(range.first);
|
|
|
|
skip_while_reverse(it, end, [&](char c) {
|
|
|
|
if (c == pair.second)
|
|
|
|
++level;
|
|
|
|
else if (c == pair.first and --level == 0)
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
});
|
2014-05-13 20:45:32 +02:00
|
|
|
if (it != end or (*end == pair.first and level == 1))
|
2014-01-20 22:01:26 +01:00
|
|
|
highlight_range(display_buffer, it.coord(), (it+1).coord(), false,
|
2014-07-11 01:27:04 +02:00
|
|
|
apply_face(face));
|
2014-01-20 22:01:26 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-02 20:56:17 +01:00
|
|
|
void highlight_selections(const Context& context, HighlightFlags flags, DisplayBuffer& display_buffer, BufferRange)
|
2012-04-03 15:22:07 +02:00
|
|
|
{
|
2014-01-18 02:56:51 +01:00
|
|
|
if (flags != HighlightFlags::Highlight)
|
|
|
|
return;
|
2013-12-17 00:24:08 +01:00
|
|
|
const auto& buffer = context.buffer();
|
|
|
|
for (size_t i = 0; i < context.selections().size(); ++i)
|
2012-04-03 15:22:07 +02:00
|
|
|
{
|
2013-12-17 00:24:08 +01:00
|
|
|
auto& sel = context.selections()[i];
|
2014-01-28 20:05:49 +01:00
|
|
|
const bool forward = sel.anchor() <= sel.cursor();
|
2014-05-07 20:51:01 +02:00
|
|
|
ByteCoord begin = forward ? sel.anchor() : buffer.char_next(sel.cursor());
|
2014-09-09 20:35:54 +02:00
|
|
|
ByteCoord end = forward ? (ByteCoord)sel.cursor() : buffer.char_next(sel.anchor());
|
2013-03-01 19:21:06 +01:00
|
|
|
|
2013-12-17 00:24:08 +01:00
|
|
|
const bool primary = (i == context.selections().main_index());
|
2014-07-11 01:27:04 +02:00
|
|
|
Face sel_face = get_face(primary ? "PrimarySelection" : "SecondarySelection");
|
2013-12-15 15:57:55 +01:00
|
|
|
highlight_range(display_buffer, begin, end, false,
|
2014-07-11 01:27:04 +02:00
|
|
|
apply_face(sel_face));
|
2014-06-16 01:59:05 +02:00
|
|
|
}
|
|
|
|
for (size_t i = 0; i < context.selections().size(); ++i)
|
|
|
|
{
|
|
|
|
auto& sel = context.selections()[i];
|
|
|
|
const bool primary = (i == context.selections().main_index());
|
2014-07-11 01:27:04 +02:00
|
|
|
Face cur_face = get_face(primary ? "PrimaryCursor" : "SecondaryCursor");
|
2014-01-28 20:05:49 +01:00
|
|
|
highlight_range(display_buffer, sel.cursor(), buffer.char_next(sel.cursor()), false,
|
2014-07-11 01:27:04 +02:00
|
|
|
apply_face(cur_face));
|
2012-04-03 15:22:07 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-02 20:56:17 +01:00
|
|
|
void expand_unprintable(const Context& context, HighlightFlags flags, DisplayBuffer& display_buffer, BufferRange)
|
2013-02-26 14:12:21 +01:00
|
|
|
{
|
2013-12-17 00:24:08 +01:00
|
|
|
auto& buffer = context.buffer();
|
2013-02-26 14:12:21 +01:00
|
|
|
for (auto& line : display_buffer.lines())
|
|
|
|
{
|
2013-03-18 23:35:23 +01:00
|
|
|
for (auto atom_it = line.begin(); atom_it != line.end(); ++atom_it)
|
2013-02-26 14:12:21 +01:00
|
|
|
{
|
2013-07-24 14:55:57 +02:00
|
|
|
if (atom_it->type() == DisplayAtom::BufferRange)
|
2013-02-26 14:12:21 +01:00
|
|
|
{
|
2014-05-21 01:24:58 +02:00
|
|
|
for (auto it = buffer.iterator_at(atom_it->begin()),
|
|
|
|
end = buffer.iterator_at(atom_it->end()); it < end;)
|
2013-02-26 14:12:21 +01:00
|
|
|
{
|
2014-07-02 22:14:01 +02:00
|
|
|
Codepoint cp = utf8::codepoint<utf8::InvalidPolicy::Pass>(it, end);
|
|
|
|
auto next = utf8::next(it, end);
|
2014-01-05 16:14:58 +01:00
|
|
|
if (cp != '\n' and not iswprint(cp))
|
2013-02-26 14:12:21 +01:00
|
|
|
{
|
|
|
|
std::ostringstream oss;
|
|
|
|
oss << "U+" << std::hex << cp;
|
|
|
|
String str = oss.str();
|
2014-05-21 01:24:58 +02:00
|
|
|
if (it.coord() != atom_it->begin())
|
|
|
|
atom_it = ++line.split(atom_it, it.coord());
|
|
|
|
if (next.coord() < atom_it->end())
|
|
|
|
atom_it = line.split(atom_it, next.coord());
|
2013-07-24 14:55:57 +02:00
|
|
|
atom_it->replace(str);
|
2014-07-11 01:27:04 +02:00
|
|
|
atom_it->face = { Colors::Red, Colors::Black };
|
2013-03-18 23:35:23 +01:00
|
|
|
break;
|
2013-02-26 14:12:21 +01:00
|
|
|
}
|
2014-05-21 01:24:58 +02:00
|
|
|
it = next;
|
2013-02-26 14:12:21 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-22 01:20:09 +02:00
|
|
|
HighlighterAndId create_flag_lines_highlighter(HighlighterParameters params)
|
2013-03-06 14:24:47 +01:00
|
|
|
{
|
|
|
|
if (params.size() != 2)
|
|
|
|
throw runtime_error("wrong parameter count");
|
|
|
|
|
2013-11-18 23:44:01 +01:00
|
|
|
const String& option_name = params[1];
|
|
|
|
Color bg = str_to_color(params[0]);
|
|
|
|
|
|
|
|
// throw if wrong option type
|
2015-01-12 20:35:31 +01:00
|
|
|
GlobalScope::instance().options()[option_name].get<Vector<LineAndFlag, MemoryDomain::Options>>();
|
2013-11-18 23:44:01 +01:00
|
|
|
|
2014-10-22 01:20:09 +02:00
|
|
|
auto func = [=](const Context& context, HighlightFlags flags,
|
2014-12-02 20:56:17 +01:00
|
|
|
DisplayBuffer& display_buffer, BufferRange)
|
2011-11-08 15:28:01 +01:00
|
|
|
{
|
2014-10-22 01:20:09 +02:00
|
|
|
auto& lines_opt = context.options()[option_name];
|
2015-01-12 20:35:31 +01:00
|
|
|
auto& lines = lines_opt.get<Vector<LineAndFlag, MemoryDomain::Options>>();
|
2014-10-22 01:20:09 +02:00
|
|
|
|
|
|
|
CharCount width = 0;
|
|
|
|
for (auto& l : lines)
|
|
|
|
width = std::max(width, std::get<2>(l).char_length());
|
|
|
|
const String empty{' ', width};
|
|
|
|
for (auto& line : display_buffer.lines())
|
|
|
|
{
|
|
|
|
int line_num = (int)line.range().first.line + 1;
|
|
|
|
auto it = find_if(lines,
|
|
|
|
[&](const LineAndFlag& l)
|
|
|
|
{ return std::get<0>(l) == line_num; });
|
|
|
|
String content = it != lines.end() ? std::get<2>(*it) : empty;
|
|
|
|
content += String(' ', width - content.char_length());
|
|
|
|
DisplayAtom atom{std::move(content)};
|
|
|
|
atom.face = { it != lines.end() ? std::get<1>(*it) : Colors::Default , bg };
|
|
|
|
line.insert(line.begin(), std::move(atom));
|
|
|
|
}
|
|
|
|
};
|
2011-11-08 15:28:01 +01:00
|
|
|
|
2014-10-22 01:20:09 +02:00
|
|
|
return {"hlflags_" + params[1], make_simple_highlighter(func) };
|
|
|
|
}
|
|
|
|
|
|
|
|
HighlighterAndId create_highlighter_group(HighlighterParameters params)
|
2012-01-15 14:45:18 +01:00
|
|
|
{
|
|
|
|
if (params.size() != 1)
|
|
|
|
throw runtime_error("wrong parameter count");
|
|
|
|
|
2014-10-22 01:20:09 +02:00
|
|
|
return HighlighterAndId(params[0], make_unique<HighlighterGroup>());
|
2012-01-15 14:45:18 +01:00
|
|
|
}
|
|
|
|
|
2014-10-22 01:20:09 +02:00
|
|
|
HighlighterAndId create_reference_highlighter(HighlighterParameters params)
|
2013-12-03 23:03:10 +01:00
|
|
|
{
|
|
|
|
if (params.size() != 1)
|
|
|
|
throw runtime_error("wrong parameter count");
|
|
|
|
|
|
|
|
const String& name = params[0];
|
|
|
|
|
|
|
|
// throw if not found
|
2014-06-10 23:02:08 +02:00
|
|
|
//DefinedHighlighters::instance().get_group(name, '/');
|
2013-12-03 23:03:10 +01:00
|
|
|
|
2014-10-22 01:20:09 +02:00
|
|
|
auto func = [=](const Context& context, HighlightFlags flags,
|
2014-12-02 20:56:17 +01:00
|
|
|
DisplayBuffer& display_buffer, BufferRange range)
|
2014-10-22 01:20:09 +02:00
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
2014-12-02 20:56:17 +01:00
|
|
|
DefinedHighlighters::instance().get_child(name).highlight(context, flags, display_buffer, range);
|
2014-10-22 01:20:09 +02:00
|
|
|
}
|
|
|
|
catch (child_not_found&)
|
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
|
|
|
return {name, make_simple_highlighter(func)};
|
2013-12-03 23:03:10 +01:00
|
|
|
}
|
|
|
|
|
2014-07-14 22:42:19 +02:00
|
|
|
struct RegexMatch
|
2014-06-11 22:26:01 +02:00
|
|
|
{
|
|
|
|
size_t timestamp;
|
|
|
|
LineCount line;
|
|
|
|
ByteCount begin;
|
|
|
|
ByteCount end;
|
|
|
|
|
|
|
|
ByteCoord begin_coord() const { return { line, begin }; }
|
|
|
|
ByteCoord end_coord() const { return { line, end }; }
|
|
|
|
};
|
2015-01-12 14:24:30 +01:00
|
|
|
using RegexMatchList = Vector<RegexMatch, MemoryDomain::Highlight>;
|
2014-06-11 22:26:01 +02:00
|
|
|
|
2014-07-14 22:42:19 +02:00
|
|
|
void find_matches(const Buffer& buffer, RegexMatchList& matches, const Regex& regex)
|
2014-06-11 22:26:01 +02:00
|
|
|
{
|
|
|
|
const size_t buf_timestamp = buffer.timestamp();
|
|
|
|
for (auto line = 0_line, end = buffer.line_count(); line < end; ++line)
|
|
|
|
{
|
2014-10-03 14:39:13 +02:00
|
|
|
auto l = buffer[line];
|
2014-10-13 14:12:33 +02:00
|
|
|
for (RegexIterator<const char*> it{l.begin(), l.end(), regex}, end{}; it != end; ++it)
|
2014-06-11 22:26:01 +02:00
|
|
|
{
|
|
|
|
ByteCount b = (int)((*it)[0].first - l.begin());
|
|
|
|
ByteCount e = (int)((*it)[0].second - l.begin());
|
|
|
|
matches.push_back({ buf_timestamp, line, b, e });
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-01-06 14:40:56 +01:00
|
|
|
void update_matches(const Buffer& buffer, ArrayView<LineModification> modifs,
|
2014-07-14 22:42:19 +02:00
|
|
|
RegexMatchList& matches, const Regex& regex)
|
2014-06-11 22:26:01 +02:00
|
|
|
{
|
|
|
|
const size_t buf_timestamp = buffer.timestamp();
|
|
|
|
// remove out of date matches and update line for others
|
|
|
|
auto ins_pos = matches.begin();
|
|
|
|
for (auto it = ins_pos; it != matches.end(); ++it)
|
|
|
|
{
|
2015-02-02 00:19:07 +01:00
|
|
|
auto modif_it = std::upper_bound(modifs.begin(), modifs.end(), it->line,
|
|
|
|
[](const LineCount& l, const LineModification& c)
|
|
|
|
{ return l < c.old_line; });
|
2014-06-11 22:26:01 +02:00
|
|
|
|
2015-02-02 00:19:07 +01:00
|
|
|
if (modif_it != modifs.begin())
|
2014-06-11 22:26:01 +02:00
|
|
|
{
|
|
|
|
auto& prev = *(modif_it-1);
|
2015-02-02 00:30:58 +01:00
|
|
|
if (it->line < prev.old_line + prev.num_removed)
|
|
|
|
continue; // match removed
|
|
|
|
|
2014-06-11 22:26:01 +02:00
|
|
|
it->line += prev.diff();
|
|
|
|
}
|
|
|
|
|
2015-02-02 00:30:58 +01:00
|
|
|
it->timestamp = buf_timestamp;
|
|
|
|
kak_assert(buffer.is_valid(it->begin_coord()) or
|
|
|
|
buffer[it->line].length() == it->begin);
|
|
|
|
kak_assert(buffer.is_valid(it->end_coord()) or
|
|
|
|
buffer[it->line].length() == it->end);
|
|
|
|
|
|
|
|
if (ins_pos != it)
|
|
|
|
*ins_pos = std::move(*it);
|
|
|
|
++ins_pos;
|
2014-06-11 22:26:01 +02:00
|
|
|
}
|
|
|
|
matches.erase(ins_pos, matches.end());
|
|
|
|
size_t pivot = matches.size();
|
|
|
|
|
|
|
|
// try to find new matches in each updated lines
|
|
|
|
for (auto& modif : modifs)
|
|
|
|
{
|
2015-02-02 00:19:07 +01:00
|
|
|
for (auto line = modif.new_line; line < modif.new_line + modif.num_added; ++line)
|
2014-06-11 22:26:01 +02:00
|
|
|
{
|
2014-10-03 14:39:13 +02:00
|
|
|
auto l = buffer[line];
|
2014-10-13 14:12:33 +02:00
|
|
|
for (RegexIterator<const char*> it{l.begin(), l.end(), regex}, end{}; it != end; ++it)
|
2014-06-11 22:26:01 +02:00
|
|
|
{
|
|
|
|
ByteCount b = (int)((*it)[0].first - l.begin());
|
|
|
|
ByteCount e = (int)((*it)[0].second - l.begin());
|
|
|
|
matches.push_back({ buf_timestamp, line, b, e });
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
std::inplace_merge(matches.begin(), matches.begin() + pivot, matches.end(),
|
2014-07-14 22:42:19 +02:00
|
|
|
[](const RegexMatch& lhs, const RegexMatch& rhs) {
|
2014-06-11 22:26:01 +02:00
|
|
|
return lhs.begin_coord() < rhs.begin_coord();
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
struct RegionMatches
|
|
|
|
{
|
2014-07-14 22:42:19 +02:00
|
|
|
RegexMatchList begin_matches;
|
|
|
|
RegexMatchList end_matches;
|
|
|
|
RegexMatchList recurse_matches;
|
2014-06-11 22:26:01 +02:00
|
|
|
|
2014-07-14 22:42:19 +02:00
|
|
|
static bool compare_to_begin(const RegexMatch& lhs, ByteCoord rhs)
|
2014-06-11 22:26:01 +02:00
|
|
|
{
|
2014-06-16 20:41:07 +02:00
|
|
|
return lhs.begin_coord() < rhs;
|
2014-06-11 22:26:01 +02:00
|
|
|
}
|
|
|
|
|
2014-07-14 22:42:19 +02:00
|
|
|
RegexMatchList::const_iterator find_next_begin(ByteCoord pos) const
|
2014-06-11 22:26:01 +02:00
|
|
|
{
|
2014-06-16 20:41:07 +02:00
|
|
|
return std::lower_bound(begin_matches.begin(), begin_matches.end(),
|
|
|
|
pos, compare_to_begin);
|
2014-06-11 22:26:01 +02:00
|
|
|
}
|
|
|
|
|
2014-07-14 22:42:19 +02:00
|
|
|
RegexMatchList::const_iterator find_matching_end(ByteCoord beg_pos) const
|
2014-06-11 22:26:01 +02:00
|
|
|
{
|
|
|
|
auto end_it = end_matches.begin();
|
|
|
|
auto rec_it = recurse_matches.begin();
|
|
|
|
int recurse_level = 0;
|
|
|
|
while (true)
|
|
|
|
{
|
2014-06-16 20:41:07 +02:00
|
|
|
end_it = std::lower_bound(end_it, end_matches.end(),
|
|
|
|
beg_pos, compare_to_begin);
|
|
|
|
rec_it = std::lower_bound(rec_it, recurse_matches.end(),
|
|
|
|
beg_pos, compare_to_begin);
|
2014-06-11 22:26:01 +02:00
|
|
|
|
|
|
|
if (end_it == end_matches.end())
|
|
|
|
return end_it;
|
|
|
|
|
|
|
|
while (rec_it != recurse_matches.end() and
|
|
|
|
rec_it->end_coord() < end_it->begin_coord())
|
|
|
|
{
|
|
|
|
++recurse_level;
|
|
|
|
++rec_it;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (recurse_level == 0)
|
|
|
|
return end_it;
|
|
|
|
|
|
|
|
--recurse_level;
|
2014-06-16 20:41:07 +02:00
|
|
|
beg_pos = end_it->end_coord();
|
2014-06-11 22:26:01 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
struct RegionDesc
|
|
|
|
{
|
|
|
|
Regex m_begin;
|
|
|
|
Regex m_end;
|
|
|
|
Regex m_recurse;
|
|
|
|
|
|
|
|
RegionMatches find_matches(const Buffer& buffer) const
|
|
|
|
{
|
|
|
|
RegionMatches res;
|
2014-07-14 22:42:19 +02:00
|
|
|
Kakoune::find_matches(buffer, res.begin_matches, m_begin);
|
|
|
|
Kakoune::find_matches(buffer, res.end_matches, m_end);
|
2014-06-11 22:26:01 +02:00
|
|
|
if (not m_recurse.empty())
|
2014-07-14 22:42:19 +02:00
|
|
|
Kakoune::find_matches(buffer, res.recurse_matches, m_recurse);
|
2014-06-11 22:26:01 +02:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
void update_matches(const Buffer& buffer,
|
2015-01-06 14:40:56 +01:00
|
|
|
ArrayView<LineModification> modifs,
|
2014-06-11 22:26:01 +02:00
|
|
|
RegionMatches& matches) const
|
|
|
|
{
|
2014-07-14 22:42:19 +02:00
|
|
|
Kakoune::update_matches(buffer, modifs, matches.begin_matches, m_begin);
|
|
|
|
Kakoune::update_matches(buffer, modifs, matches.end_matches, m_end);
|
2014-06-11 22:26:01 +02:00
|
|
|
if (not m_recurse.empty())
|
2014-07-14 22:42:19 +02:00
|
|
|
Kakoune::update_matches(buffer, modifs, matches.recurse_matches, m_recurse);
|
2014-01-06 22:04:55 +01:00
|
|
|
}
|
2013-12-04 01:48:46 +01:00
|
|
|
};
|
|
|
|
|
2014-10-22 01:20:09 +02:00
|
|
|
struct RegionsHighlighter : public Highlighter
|
2014-06-12 00:29:23 +02:00
|
|
|
{
|
|
|
|
public:
|
2015-01-12 14:24:30 +01:00
|
|
|
using NamedRegionDescList = Vector<std::pair<String, RegionDesc>, MemoryDomain::Highlight>;
|
2014-06-12 00:29:23 +02:00
|
|
|
|
2014-07-14 22:42:19 +02:00
|
|
|
RegionsHighlighter(NamedRegionDescList regions, String default_group)
|
2014-06-12 00:29:23 +02:00
|
|
|
: m_regions{std::move(regions)}, m_default_group{std::move(default_group)}
|
|
|
|
{
|
|
|
|
if (m_regions.empty())
|
|
|
|
throw runtime_error("at least one region must be defined");
|
|
|
|
|
|
|
|
for (auto& region : m_regions)
|
2014-10-22 01:20:09 +02:00
|
|
|
{
|
|
|
|
m_groups.append({region.first, HighlighterGroup{}});
|
2014-06-12 00:29:23 +02:00
|
|
|
if (region.second.m_begin.empty() or region.second.m_end.empty())
|
|
|
|
throw runtime_error("invalid regex for region highlighter");
|
2014-10-22 01:20:09 +02:00
|
|
|
}
|
|
|
|
if (not m_default_group.empty())
|
|
|
|
m_groups.append({m_default_group, HighlighterGroup{}});
|
2014-06-12 00:29:23 +02:00
|
|
|
}
|
|
|
|
|
2014-12-02 20:56:17 +01:00
|
|
|
void highlight(const Context& context, HighlightFlags flags, DisplayBuffer& display_buffer, BufferRange range)
|
2014-06-12 00:29:23 +02:00
|
|
|
{
|
|
|
|
if (flags != HighlightFlags::Highlight)
|
|
|
|
return;
|
|
|
|
|
2014-12-02 20:56:17 +01:00
|
|
|
auto display_range = display_buffer.range();
|
2014-06-12 00:29:23 +02:00
|
|
|
const auto& buffer = context.buffer();
|
2014-12-02 20:56:17 +01:00
|
|
|
auto& regions = get_regions_for_range(buffer, range);
|
2014-06-12 00:29:23 +02:00
|
|
|
|
2014-12-02 20:56:17 +01:00
|
|
|
auto begin = std::lower_bound(regions.begin(), regions.end(), display_range.first,
|
2014-06-12 00:29:23 +02:00
|
|
|
[](const Region& r, ByteCoord c) { return r.end < c; });
|
2014-12-02 20:56:17 +01:00
|
|
|
auto end = std::lower_bound(begin, regions.end(), display_range.second,
|
2014-06-12 00:29:23 +02:00
|
|
|
[](const Region& r, ByteCoord c) { return r.begin < c; });
|
|
|
|
auto correct = [&](ByteCoord c) -> ByteCoord {
|
|
|
|
if (buffer[c.line].length() == c.column)
|
|
|
|
return {c.line+1, 0};
|
|
|
|
return c;
|
|
|
|
};
|
|
|
|
|
2014-10-22 01:20:09 +02:00
|
|
|
auto default_group_it = m_groups.find(m_default_group);
|
|
|
|
const bool apply_default = default_group_it != m_groups.end();
|
2014-06-12 00:29:23 +02:00
|
|
|
|
2014-12-02 20:56:17 +01:00
|
|
|
auto last_begin = display_range.first;
|
2014-06-12 00:29:23 +02:00
|
|
|
for (; begin != end; ++begin)
|
|
|
|
{
|
|
|
|
if (apply_default and last_begin < begin->begin)
|
|
|
|
apply_highlighter(context, flags, display_buffer,
|
|
|
|
correct(last_begin), correct(begin->begin),
|
|
|
|
default_group_it->second);
|
|
|
|
|
2014-10-22 01:20:09 +02:00
|
|
|
auto it = m_groups.find(begin->group);
|
|
|
|
if (it == m_groups.end())
|
2014-06-12 00:29:23 +02:00
|
|
|
continue;
|
|
|
|
apply_highlighter(context, flags, display_buffer,
|
|
|
|
correct(begin->begin), correct(begin->end),
|
|
|
|
it->second);
|
|
|
|
last_begin = begin->end;
|
|
|
|
}
|
2014-12-02 20:56:17 +01:00
|
|
|
if (apply_default and last_begin < display_range.second)
|
2014-06-12 00:29:23 +02:00
|
|
|
apply_highlighter(context, flags, display_buffer,
|
|
|
|
correct(last_begin), range.second,
|
|
|
|
default_group_it->second);
|
|
|
|
|
|
|
|
}
|
2014-10-22 01:20:09 +02:00
|
|
|
|
|
|
|
bool has_children() const override { return true; }
|
|
|
|
|
|
|
|
Highlighter& get_child(StringView path) override
|
|
|
|
{
|
|
|
|
auto sep_it = find(path, '/');
|
|
|
|
StringView id(path.begin(), sep_it);
|
|
|
|
auto it = m_groups.find(id);
|
|
|
|
if (it == m_groups.end())
|
|
|
|
throw child_not_found("no such id: "_str + id);
|
|
|
|
if (sep_it == path.end())
|
|
|
|
return it->second;
|
|
|
|
else
|
|
|
|
return it->second.get_child({sep_it+1, path.end()});
|
|
|
|
}
|
|
|
|
|
|
|
|
Completions complete_child(StringView path, ByteCount cursor_pos, bool group) const override
|
|
|
|
{
|
|
|
|
auto sep_it = find(path, '/');
|
|
|
|
if (sep_it != path.end())
|
|
|
|
{
|
|
|
|
ByteCount offset = sep_it+1 - path.begin();
|
|
|
|
Highlighter& hl = const_cast<RegionsHighlighter*>(this)->get_child({path.begin(), sep_it});
|
|
|
|
return offset_pos(hl.complete_child(path.substr(offset), cursor_pos - offset, group), offset);
|
|
|
|
}
|
|
|
|
|
2014-12-23 23:51:00 +01:00
|
|
|
auto container = transformed(m_groups, IdMap<HighlighterGroup>::get_id);
|
2014-12-23 14:54:09 +01:00
|
|
|
return { 0, 0, complete(path, cursor_pos, container) };
|
2014-10-22 01:20:09 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static HighlighterAndId create(HighlighterParameters params)
|
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
|
|
|
static const ParameterDesc param_desc{
|
|
|
|
SwitchMap{ { "default", { true, "" } } },
|
|
|
|
ParameterDesc::Flags::SwitchesOnlyAtStart,
|
|
|
|
5};
|
|
|
|
|
|
|
|
ParametersParser parser{params, param_desc};
|
|
|
|
if ((parser.positional_count() % 4) != 1)
|
|
|
|
throw runtime_error("wrong parameter count, expect <id> (<group name> <begin> <end> <recurse>)+");
|
|
|
|
|
|
|
|
RegionsHighlighter::NamedRegionDescList regions;
|
|
|
|
for (size_t i = 1; i < parser.positional_count(); i += 4)
|
|
|
|
{
|
|
|
|
if (parser[i].empty() or parser[i+1].empty() or parser[i+2].empty())
|
|
|
|
throw runtime_error("group id, begin and end must not be empty");
|
|
|
|
|
|
|
|
Regex begin{parser[i+1], Regex::nosubs | Regex::optimize };
|
|
|
|
Regex end{parser[i+2], Regex::nosubs | Regex::optimize };
|
|
|
|
Regex recurse;
|
|
|
|
if (not parser[i+3].empty())
|
|
|
|
recurse = Regex{parser[i+3], Regex::nosubs | Regex::optimize };
|
|
|
|
|
|
|
|
regions.push_back({ parser[i], {std::move(begin), std::move(end), std::move(recurse)} });
|
|
|
|
}
|
|
|
|
String default_group;
|
|
|
|
if (parser.has_option("default"))
|
|
|
|
default_group = parser.option_value("default");
|
|
|
|
|
|
|
|
return {parser[0], make_unique<RegionsHighlighter>(std::move(regions),
|
|
|
|
std::move(default_group))};
|
|
|
|
}
|
|
|
|
catch (RegexError& err)
|
|
|
|
{
|
|
|
|
throw runtime_error(String("regex error: ") + err.what());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-12 00:29:23 +02:00
|
|
|
private:
|
|
|
|
const NamedRegionDescList m_regions;
|
|
|
|
const String m_default_group;
|
2015-01-12 14:24:30 +01:00
|
|
|
IdMap<HighlighterGroup, MemoryDomain::Highlight> m_groups;
|
2014-06-12 00:29:23 +02:00
|
|
|
|
|
|
|
struct Region
|
|
|
|
{
|
|
|
|
ByteCoord begin;
|
|
|
|
ByteCoord end;
|
|
|
|
StringView group;
|
|
|
|
};
|
2015-01-12 14:24:30 +01:00
|
|
|
using RegionList = Vector<Region, MemoryDomain::Highlight>;
|
2014-06-12 00:29:23 +02:00
|
|
|
|
|
|
|
struct Cache
|
|
|
|
{
|
|
|
|
size_t timestamp = 0;
|
2015-01-12 14:24:30 +01:00
|
|
|
Vector<RegionMatches, MemoryDomain::Highlight> matches;
|
|
|
|
UnorderedMap<BufferRange, RegionList, MemoryDomain::Highlight> regions;
|
2014-06-12 00:29:23 +02:00
|
|
|
};
|
|
|
|
BufferSideCache<Cache> m_cache;
|
|
|
|
|
2014-07-14 22:42:19 +02:00
|
|
|
using RegionAndMatch = std::pair<size_t, RegexMatchList::const_iterator>;
|
2014-06-12 00:29:23 +02:00
|
|
|
|
|
|
|
// find the begin closest to pos in all matches
|
|
|
|
RegionAndMatch find_next_begin(const Cache& cache, ByteCoord pos) const
|
|
|
|
{
|
|
|
|
RegionAndMatch res{0, cache.matches[0].find_next_begin(pos)};
|
|
|
|
for (size_t i = 1; i < cache.matches.size(); ++i)
|
|
|
|
{
|
|
|
|
const auto& matches = cache.matches[i];
|
|
|
|
auto it = matches.find_next_begin(pos);
|
|
|
|
if (it != matches.begin_matches.end() and
|
|
|
|
(res.second == cache.matches[res.first].begin_matches.end() or
|
|
|
|
it->begin_coord() < res.second->begin_coord()))
|
|
|
|
res = RegionAndMatch{i, it};
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2014-12-02 20:56:17 +01:00
|
|
|
const RegionList& get_regions_for_range(const Buffer& buffer, BufferRange range)
|
2014-06-12 00:29:23 +02:00
|
|
|
{
|
|
|
|
Cache& cache = m_cache.get(buffer);
|
|
|
|
const size_t buf_timestamp = buffer.timestamp();
|
2014-12-02 20:56:17 +01:00
|
|
|
if (cache.timestamp != buf_timestamp)
|
2014-06-12 00:29:23 +02:00
|
|
|
{
|
2014-12-02 20:56:17 +01:00
|
|
|
if (cache.timestamp == 0)
|
|
|
|
{
|
|
|
|
cache.matches.resize(m_regions.size());
|
|
|
|
for (size_t i = 0; i < m_regions.size(); ++i)
|
|
|
|
cache.matches[i] = m_regions[i].second.find_matches(buffer);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
auto modifs = compute_line_modifications(buffer, cache.timestamp);
|
|
|
|
for (size_t i = 0; i < m_regions.size(); ++i)
|
|
|
|
m_regions[i].second.update_matches(buffer, modifs, cache.matches[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
cache.regions.clear();
|
2014-06-12 00:29:23 +02:00
|
|
|
}
|
|
|
|
|
2014-12-02 20:56:17 +01:00
|
|
|
auto it = cache.regions.find(range);
|
|
|
|
if (it != cache.regions.end())
|
|
|
|
return it->second;
|
|
|
|
|
|
|
|
RegionList& regions = cache.regions[range];
|
2014-06-12 00:29:23 +02:00
|
|
|
|
2014-12-02 20:56:17 +01:00
|
|
|
for (auto begin = find_next_begin(cache, range.first),
|
2014-06-12 00:29:23 +02:00
|
|
|
end = RegionAndMatch{ 0, cache.matches[0].begin_matches.end() };
|
|
|
|
begin != end; )
|
|
|
|
{
|
|
|
|
const RegionMatches& matches = cache.matches[begin.first];
|
|
|
|
auto& named_region = m_regions[begin.first];
|
|
|
|
auto beg_it = begin.second;
|
2014-06-16 20:41:07 +02:00
|
|
|
auto end_it = matches.find_matching_end(beg_it->end_coord());
|
2014-06-12 00:29:23 +02:00
|
|
|
|
2014-12-02 20:56:17 +01:00
|
|
|
if (end_it == matches.end_matches.end() or end_it->end_coord() >= range.second)
|
2014-06-12 00:29:23 +02:00
|
|
|
{
|
2014-12-02 20:56:17 +01:00
|
|
|
regions.push_back({ {beg_it->line, beg_it->begin},
|
|
|
|
range.second,
|
|
|
|
named_region.first });
|
2014-06-12 00:29:23 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-12-02 20:56:17 +01:00
|
|
|
regions.push_back({ beg_it->begin_coord(),
|
|
|
|
end_it->end_coord(),
|
|
|
|
named_region.first });
|
2014-07-14 21:46:46 +02:00
|
|
|
auto end_coord = end_it->end_coord();
|
|
|
|
|
|
|
|
// With empty begin and end matches (for example if the regexes
|
|
|
|
// are /"\K/ and /(?=")/), that case can happen, and would
|
|
|
|
// result in an infinite loop.
|
|
|
|
if (end_coord == beg_it->begin_coord())
|
|
|
|
{
|
|
|
|
kak_assert(beg_it->begin_coord() == beg_it->end_coord() and
|
|
|
|
end_it->begin_coord() == end_it->end_coord());
|
|
|
|
++end_coord.column;
|
|
|
|
}
|
|
|
|
begin = find_next_begin(cache, end_coord);
|
2014-06-12 00:29:23 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
cache.timestamp = buf_timestamp;
|
2014-12-02 20:56:17 +01:00
|
|
|
return regions;
|
2014-06-12 00:29:23 +02:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2014-10-22 01:20:09 +02:00
|
|
|
template<typename Func>
|
|
|
|
HighlighterFactory simple_factory(const String id, Func func)
|
2014-06-12 00:29:23 +02:00
|
|
|
{
|
2014-10-22 01:20:09 +02:00
|
|
|
return [=](HighlighterParameters params)
|
2014-06-12 00:29:23 +02:00
|
|
|
{
|
2014-10-22 01:20:09 +02:00
|
|
|
return HighlighterAndId(id, make_simple_highlighter(func));
|
|
|
|
};
|
2014-06-12 00:29:23 +02:00
|
|
|
}
|
|
|
|
|
2011-11-29 23:37:20 +01:00
|
|
|
void register_highlighters()
|
2011-11-08 15:28:01 +01:00
|
|
|
{
|
2011-11-29 23:37:20 +01:00
|
|
|
HighlighterRegistry& registry = HighlighterRegistry::instance();
|
2011-11-15 15:28:03 +01:00
|
|
|
|
2014-12-23 23:15:53 +01:00
|
|
|
registry.append({ "number_lines", simple_factory("number_lines", show_line_numbers) });
|
|
|
|
registry.append({ "show_matching", simple_factory("show_matching", show_matching_char) });
|
|
|
|
registry.append({ "show_whitespaces", simple_factory("show_whitespaces", show_whitespaces) });
|
|
|
|
registry.append({ "fill", create_fill_highlighter });
|
|
|
|
registry.append({ "regex", RegexHighlighter::create });
|
|
|
|
registry.append({ "regex_option", create_regex_option_highlighter });
|
|
|
|
registry.append({ "search", create_search_highlighter });
|
|
|
|
registry.append({ "group", create_highlighter_group });
|
|
|
|
registry.append({ "flag_lines", create_flag_lines_highlighter });
|
|
|
|
registry.append({ "line_option", create_line_option_highlighter });
|
|
|
|
registry.append({ "ref", create_reference_highlighter });
|
|
|
|
registry.append({ "regions", RegionsHighlighter::create });
|
2011-11-08 15:28:01 +01:00
|
|
|
}
|
|
|
|
|
2011-09-30 21:16:23 +02:00
|
|
|
}
|