kakoune/src/selectors.hh

287 lines
9.8 KiB
C++
Raw Normal View History

#ifndef selectors_hh_INCLUDED
#define selectors_hh_INCLUDED
#include "flags.hh"
#include "selection.hh"
#include "buffer_utils.hh"
#include "unicode.hh"
2013-12-14 15:49:10 +01:00
#include "utf8_iterator.hh"
#include "regex.hh"
namespace Kakoune
{
inline Selection keep_direction(Selection res, const Selection& ref)
{
if ((res.cursor() < res.anchor()) != (ref.cursor() < ref.anchor()))
std::swap<BufferCoord>(res.cursor(), res.anchor());
return res;
}
inline Selection target_eol(Selection sel)
{
sel.cursor().target = INT_MAX;
return sel;
}
using Utf8Iterator = utf8::iterator<BufferIterator>;
2013-12-14 15:49:10 +01:00
inline Selection utf8_range(const BufferIterator& first, const BufferIterator& last)
{
return {first.coord(), last.coord()};
}
inline Selection utf8_range(const Utf8Iterator& first, const Utf8Iterator& last)
2013-12-14 15:49:10 +01:00
{
return {first.base().coord(), last.base().coord()};
}
template<WordType word_type>
2013-12-14 15:49:10 +01:00
Selection select_to_next_word(const Buffer& buffer, const Selection& selection)
{
Utf8Iterator begin{buffer.iterator_at(selection.cursor()), buffer};
2013-12-14 15:49:10 +01:00
if (begin+1 == buffer.end())
return selection;
if (categorize<word_type>(*begin) != categorize<word_type>(*(begin+1)))
++begin;
if (not skip_while(begin, buffer.end(),
[](Codepoint c) { return is_eol(c); }))
2013-12-14 15:49:10 +01:00
return selection;
Utf8Iterator end = begin+1;
if (word_type == Word and is_punctuation(*begin))
skip_while(end, buffer.end(), is_punctuation);
else if (is_word<word_type>(*begin))
skip_while(end, buffer.end(), is_word<word_type>);
skip_while(end, buffer.end(), is_horizontal_blank);
2013-12-14 15:49:10 +01:00
return utf8_range(begin, end-1);
}
template<WordType word_type>
2013-12-14 15:49:10 +01:00
Selection select_to_next_word_end(const Buffer& buffer, const Selection& selection)
{
Utf8Iterator begin{buffer.iterator_at(selection.cursor()), buffer};
2013-12-14 15:49:10 +01:00
if (begin+1 == buffer.end())
return selection;
if (categorize<word_type>(*begin) != categorize<word_type>(*(begin+1)))
++begin;
if (not skip_while(begin, buffer.end(),
[](Codepoint c) { return is_eol(c); }))
2013-12-14 15:49:10 +01:00
return selection;
Utf8Iterator end = begin;
skip_while(end, buffer.end(), is_horizontal_blank);
2013-12-14 15:49:10 +01:00
if (word_type == Word and is_punctuation(*end))
skip_while(end, buffer.end(), is_punctuation);
else if (is_word<word_type>(*end))
skip_while(end, buffer.end(), is_word<word_type>);
return utf8_range(begin, end-1);
}
template<WordType word_type>
2013-12-14 15:49:10 +01:00
Selection select_to_previous_word(const Buffer& buffer, const Selection& selection)
{
Utf8Iterator begin{buffer.iterator_at(selection.cursor()), buffer};
2013-12-14 15:49:10 +01:00
if (begin == buffer.begin())
return selection;
if (categorize<word_type>(*begin) != categorize<word_type>(*(begin-1)))
--begin;
skip_while_reverse(begin, buffer.begin(), [](Codepoint c){ return is_eol(c); });
2013-12-14 15:49:10 +01:00
Utf8Iterator end = begin;
skip_while_reverse(end, buffer.begin(), is_horizontal_blank);
2013-12-14 15:49:10 +01:00
bool with_end = false;
if (word_type == Word and is_punctuation(*end))
with_end = skip_while_reverse(end, buffer.begin(), is_punctuation);
2013-12-14 15:49:10 +01:00
else if (is_word<word_type>(*end))
with_end = skip_while_reverse(end, buffer.begin(), is_word<word_type>);
2013-12-14 15:49:10 +01:00
return utf8_range(begin, with_end ? end : end+1);
}
2012-10-08 19:12:09 +02:00
Selection select_line(const Buffer& buffer, const Selection& selection);
Selection select_matching(const Buffer& buffer, const Selection& selection);
2012-10-08 19:12:09 +02:00
2013-06-01 14:22:57 +02:00
Selection select_to(const Buffer& buffer, const Selection& selection,
Codepoint c, int count, bool inclusive);
2013-06-01 14:22:57 +02:00
Selection select_to_reverse(const Buffer& buffer, const Selection& selection,
Codepoint c, int count, bool inclusive);
template<bool only_move>
Selection select_to_line_end(const Buffer& buffer, const Selection& selection)
{
BufferCoord begin = selection.cursor();
LineCount line = begin.line;
BufferCoord end = utf8::previous(buffer.iterator_at({line, buffer[line].length() - 1}),
buffer.iterator_at(line)).coord();
if (end < begin) // Do not go backward when cursor is on eol
end = begin;
return target_eol({only_move ? end : begin, end});
}
template<bool only_move>
Selection select_to_line_begin(const Buffer& buffer, const Selection& selection)
{
BufferCoord begin = selection.cursor();
BufferCoord end = begin.line;
return {only_move ? end : begin, end};
}
enum class ObjectFlags
{
ToBegin = 1,
ToEnd = 2,
Inner = 4
};
template<> struct WithBitOps<ObjectFlags> : std::true_type {};
template<WordType word_type>
2016-09-27 00:32:07 +02:00
Selection select_word(const Buffer& buffer, const Selection& selection,
int count, ObjectFlags flags)
2013-12-14 15:49:10 +01:00
{
Utf8Iterator first{buffer.iterator_at(selection.cursor()), buffer};
if (not is_word<word_type>(*first) and
not skip_while(first, buffer.end(), [](Codepoint c)
{ return not is_word<word_type>(c); }))
return selection;
2013-12-14 15:49:10 +01:00
Utf8Iterator last = first;
if (flags & ObjectFlags::ToBegin)
2013-12-14 15:49:10 +01:00
{
skip_while_reverse(first, buffer.begin(), is_word<word_type>);
if (not is_word<word_type>(*first))
++first;
2013-12-14 15:49:10 +01:00
}
if (flags & ObjectFlags::ToEnd)
2013-12-14 15:49:10 +01:00
{
skip_while(last, buffer.end(), is_word<word_type>);
if (not (flags & ObjectFlags::Inner))
skip_while(last, buffer.end(), is_horizontal_blank);
--last;
2013-12-14 15:49:10 +01:00
}
return (flags & ObjectFlags::ToEnd) ? utf8_range(first, last)
: utf8_range(last, first);
}
2016-09-27 00:32:07 +02:00
Selection select_number(const Buffer& buffer, const Selection& selection,
int count, ObjectFlags flags);
2016-09-27 00:32:07 +02:00
Selection select_sentence(const Buffer& buffer, const Selection& selection,
int count, ObjectFlags flags);
2016-09-27 00:32:07 +02:00
Selection select_paragraph(const Buffer& buffer, const Selection& selection,
int count, ObjectFlags flags);
2016-09-27 00:32:07 +02:00
Selection select_whitespaces(const Buffer& buffer, const Selection& selection,
int count, ObjectFlags flags);
2014-06-11 15:00:45 +02:00
2016-09-27 00:32:07 +02:00
Selection select_indent(const Buffer& buffer, const Selection& selection,
int count, ObjectFlags flags);
2016-09-27 00:32:07 +02:00
Selection select_argument(const Buffer& buffer, const Selection& selection,
2015-06-25 15:44:43 +02:00
int level, ObjectFlags flags);
Selection select_lines(const Buffer& buffer, const Selection& selection);
2013-06-01 14:22:57 +02:00
Selection trim_partial_lines(const Buffer& buffer, const Selection& selection);
void select_buffer(SelectionList& selections);
enum Direction { Forward, Backward };
inline bool find_last_match(const Buffer& buffer, const BufferIterator& pos,
MatchResults<BufferIterator>& res,
const Regex& regex)
{
MatchResults<BufferIterator> matches;
const bool is_pos_eol = is_eol(buffer, pos.coord());
const bool is_pos_eow = is_eow(buffer, pos.coord());
auto begin = buffer.begin();
while (begin != pos and regex_search(begin, pos, matches, regex,
match_flags(is_bol(begin.coord()), is_pos_eol,
is_bow(buffer, begin.coord()), is_pos_eow)))
{
begin = utf8::next(matches[0].first, pos);
if (res.empty() or matches[0].second > res[0].second)
res.swap(matches);
}
return not res.empty();
}
template<Direction direction>
bool find_match_in_buffer(const Buffer& buffer, const BufferIterator pos,
MatchResults<BufferIterator>& matches,
const Regex& ex, bool& wrapped)
{
wrapped = false;
if (direction == Forward)
{
if (regex_search(pos, buffer.end(), matches, ex,
match_flags(is_bol(pos.coord()), true,
is_bow(buffer, pos.coord()), true)))
return true;
wrapped = true;
return regex_search(buffer.begin(), buffer.end(), matches, ex);
}
else
{
if (find_last_match(buffer, pos, matches, ex))
return true;
wrapped = true;
return find_last_match(buffer, buffer.end(), matches, ex);
}
}
inline BufferIterator ensure_char_start(const Buffer& buffer, const BufferIterator& it)
{
return it != buffer.end() ?
utf8::character_start(it, buffer.iterator_at(it.coord().line)) : it;
}
2013-12-14 19:39:03 +01:00
template<Direction direction>
Selection find_next_match(const Buffer& buffer, const Selection& sel, const Regex& regex, bool& wrapped)
{
auto begin = buffer.iterator_at(direction == Backward ? sel.min() : sel.max());
auto end = begin;
2013-12-14 19:39:03 +01:00
CaptureList captures;
MatchResults<BufferIterator> matches;
bool found = false;
auto pos = direction == Forward ? utf8::next(begin, buffer.end()) : begin;
if ((found = find_match_in_buffer<direction>(buffer, pos, matches, regex, wrapped)))
{
begin = matches[0].first;
end = matches[0].second;
for (const auto& match : matches)
2016-02-05 00:52:06 +01:00
captures.push_back(buffer.string(match.first.coord(),
match.second.coord()));
}
if (not found or begin == buffer.end())
throw runtime_error(format("'{}': no matches found", regex.str()));
end = (begin == end) ? end : utf8::previous(end, begin);
if (direction == Backward)
std::swap(begin, end);
2014-09-25 14:29:53 +02:00
return {begin.coord(), end.coord(), std::move(captures)};
2013-12-14 19:39:03 +01:00
}
void select_all_matches(SelectionList& selections, const Regex& regex, unsigned capture = 0);
void split_selections(SelectionList& selections, const Regex& separator_regex, unsigned capture = 0);
2013-06-01 14:22:57 +02:00
Selection select_surrounding(const Buffer& buffer, const Selection& selection,
2016-01-27 09:28:25 +01:00
StringView opening, StringView closing, int level,
ObjectFlags flags);
}
#endif // selectors_hh_INCLUDED