kakoune/src/buffer.cc

759 lines
22 KiB
C++
Raw Normal View History

2011-09-02 18:51:20 +02:00
#include "buffer.hh"
2011-09-09 21:24:18 +02:00
#include "assert.hh"
2013-04-09 20:05:40 +02:00
#include "buffer_manager.hh"
#include "context.hh"
#include "file.hh"
2013-04-09 20:05:40 +02:00
#include "utils.hh"
#include "window.hh"
#include <algorithm>
2011-09-02 18:51:20 +02:00
namespace Kakoune
{
Buffer::Buffer(String name, Flags flags, std::vector<String> lines,
time_t fs_timestamp)
: m_name(std::move(name)), m_flags(flags | Flags::NoUndo),
2012-11-21 13:37:36 +01:00
m_history(), m_history_cursor(m_history.begin()),
m_last_save_undo_index(0),
2012-08-15 17:07:53 +02:00
m_timestamp(0),
m_fs_timestamp(fs_timestamp),
m_hooks(GlobalHooks::instance()),
m_options(GlobalOptions::instance())
2011-09-02 18:51:20 +02:00
{
2012-08-08 19:36:40 +02:00
BufferManager::instance().register_buffer(*this);
if (flags & Flags::File)
m_name = real_path(m_name);
2012-11-27 13:39:35 +01:00
if (lines.empty())
lines.emplace_back("\n");
ByteCount pos = 0;
m_lines.reserve(lines.size());
for (auto& line : lines)
{
kak_assert(not line.empty() and line.back() == '\n');
m_lines.emplace_back(Line{ pos, std::move(line) });
pos += m_lines.back().length();
}
Editor editor_for_hooks(*this);
Context context(editor_for_hooks);
if (flags & Flags::File)
{
if (flags & Flags::New)
m_hooks.run_hook("BufNew", m_name, context);
else
{
kak_assert(m_fs_timestamp != InvalidTime);
m_hooks.run_hook("BufOpen", m_name, context);
}
}
m_hooks.run_hook("BufCreate", m_name, context);
// now we may begin to record undo data
m_flags = flags;
2011-09-02 18:51:20 +02:00
}
2011-10-24 16:23:13 +02:00
Buffer::~Buffer()
{
2013-01-17 13:44:14 +01:00
{
Editor hook_editor{*this};
Context hook_context{hook_editor};
m_hooks.run_hook("BufClose", m_name, hook_context);
}
2012-08-08 19:36:40 +02:00
BufferManager::instance().unregister_buffer(*this);
kak_assert(m_change_listeners.empty());
2011-10-24 16:23:13 +02:00
}
void Buffer::reload(std::vector<String> lines, time_t fs_timestamp)
{
for (auto listener : m_change_listeners)
listener->on_erase(*this, {0,0}, end_coord());
m_history.clear();
m_current_undo_group.clear();
m_history_cursor = m_history.begin();
m_last_save_undo_index = 0;
m_lines.clear();
++m_timestamp;
if (lines.empty())
lines.emplace_back("\n");
ByteCount pos = 0;
m_lines.reserve(lines.size());
for (auto& line : lines)
{
kak_assert(not line.empty() and line.back() == '\n');
m_lines.emplace_back(Line{ pos, std::move(line) });
pos += m_lines.back().length();
}
m_fs_timestamp = fs_timestamp;
for (auto listener : m_change_listeners)
listener->on_insert(*this, {0,0}, end_coord());
}
String Buffer::display_name() const
{
if (m_flags & Flags::File)
return compact_path(m_name);
return m_name;
}
bool Buffer::set_name(String name)
{
Buffer* other = BufferManager::instance().get_buffer_ifp(name);
if (other == nullptr or other == this)
{
if (m_flags & Flags::File)
m_name = real_path(name);
else
m_name = std::move(name);
return true;
}
return false;
}
2013-07-26 00:44:00 +02:00
BufferIterator Buffer::iterator_at(BufferCoord coord) const
2011-09-02 18:51:20 +02:00
{
return is_end(coord) ? end() : BufferIterator(*this, clamp(coord));
2011-09-02 18:51:20 +02:00
}
BufferCoord Buffer::clamp(BufferCoord coord) const
2011-09-02 18:51:20 +02:00
{
if (m_lines.empty())
return BufferCoord{};
2011-09-02 18:51:20 +02:00
coord.line = Kakoune::clamp(coord.line, 0_line, line_count() - 1);
ByteCount max_col = std::max(0_byte, m_lines[coord.line].length() - 1);
coord.column = Kakoune::clamp(coord.column, 0_byte, max_col);
return coord;
2011-09-02 18:51:20 +02:00
}
BufferIterator Buffer::begin() const
{
return BufferIterator(*this, { 0_line, 0 });
2011-09-02 18:51:20 +02:00
}
BufferIterator Buffer::end() const
{
if (m_lines.empty())
return BufferIterator(*this, { 0_line, 0 });
return BufferIterator(*this, { line_count()-1, m_lines.back().length() });
2011-09-02 18:51:20 +02:00
}
ByteCount Buffer::byte_count() const
2011-09-02 18:51:20 +02:00
{
if (m_lines.empty())
return 0;
2012-03-30 14:00:40 +02:00
return m_lines.back().start + m_lines.back().length();
2011-09-02 18:51:20 +02:00
}
LineCount Buffer::line_count() const
2011-09-22 15:58:35 +02:00
{
return LineCount(m_lines.size());
2011-09-22 15:58:35 +02:00
}
2013-07-26 00:44:00 +02:00
String Buffer::string(BufferCoord begin, BufferCoord end) const
2011-09-02 18:51:20 +02:00
{
String res;
2013-06-27 23:49:34 +02:00
for (auto line = begin.line; line <= end.line and line < line_count(); ++line)
{
2013-06-27 23:49:34 +02:00
ByteCount start = 0;
if (line == begin.line)
start = begin.column;
ByteCount count = -1;
if (line == end.line)
count = end.column - start;
res += m_lines[line].content.substr(start, count);
}
return res;
2011-09-02 18:51:20 +02:00
}
// A Modification holds a single atomic modification to Buffer
struct Buffer::Modification
{
enum Type { Insert, Erase };
Type type;
BufferCoord coord;
String content;
Modification(Type type, BufferCoord coord, String content)
: type(type), coord(coord), content(std::move(content)) {}
Modification inverse() const
{
2013-02-28 18:51:24 +01:00
Type inverse_type = Insert;
switch (type)
{
case Insert: inverse_type = Erase; break;
case Erase: inverse_type = Insert; break;
default: kak_assert(false);
}
return {inverse_type, coord, content};
}
};
class UndoGroupOptimizer
{
static constexpr auto Insert = Buffer::Modification::Type::Insert;
static constexpr auto Erase = Buffer::Modification::Type::Erase;
static BufferCoord advance(BufferCoord coord, const String& str)
{
for (auto c : str)
{
if (c == '\n')
{
++coord.line;
coord.column = 0;
}
else
++coord.column;
}
return coord;
}
2013-07-26 00:44:00 +02:00
static ByteCount count_byte_to(BufferCoord pos, BufferCoord endpos, const String& str)
{
ByteCount count = 0;
for (auto it = str.begin(); it != str.end() and pos != endpos; ++it)
{
if (*it == '\n')
{
++pos.line;
pos.column = 0;
}
else
++pos.column;
++count;
}
2013-06-12 00:14:05 +02:00
kak_assert(pos == endpos);
return count;
}
static const ByteCount overlaps(const String& lhs, const String& rhs)
{
if (lhs.empty() or rhs.empty())
return -1;
char c = rhs.front();
ByteCount pos = 0;
while ((pos = (int)lhs.find_first_of(c, (int)pos)) != -1)
{
ByteCount i = pos, j = 0;
while (i != lhs.length() and j != rhs.length() and lhs[i] == rhs[j])
++i, ++j;
if (i == lhs.length())
break;
++pos;
}
return pos;
}
static bool merge_contiguous(Buffer::UndoGroup& undo_group)
{
bool progress = false;
auto it = undo_group.begin();
auto it_next = it+1;
while (it_next != undo_group.end())
{
ByteCount pos;
auto& coord = it->coord;
auto& next_coord = it_next->coord;
// reorders modification doing a kind of custom bubble sort
// so we have a O(n²) worst case complexity of the undo group optimization
if (next_coord < coord)
{
BufferCoord next_end = advance(next_coord, it_next->content);
if (it_next->type == Insert)
{
2013-06-12 00:14:05 +02:00
if (coord.line == next_coord.line)
coord.column += next_end.column - next_coord.column;
coord.line += next_end.line - next_coord.line;
}
2013-06-12 00:14:05 +02:00
else if (it->type == Insert and next_end > coord)
{
2013-06-12 00:14:05 +02:00
ByteCount start = count_byte_to(next_coord, coord, it_next->content);
ByteCount len = std::min(it->content.length(), it_next->content.length() - start);
kak_assert(it_next->content.substr(start, len) == it->content.substr(0, len));
it->coord = it_next->coord;
it->content = it->content.substr(len);
it_next->content = it_next->content.substr(0,start) + it_next->content.substr(start + len);
}
2013-04-29 14:25:38 +02:00
else if (it->type == Erase and next_end >= coord)
{
ByteCount start = count_byte_to(next_coord, coord, it_next->content);
it_next->content = it_next->content.substr(0, start) + it->content + it_next->content.substr(start);
it->coord = it_next->coord;
it->content.clear();
}
2013-06-12 00:14:05 +02:00
else
{
if (next_end.line == coord.line)
{
coord.line = next_coord.line;
coord.column = next_coord.column + coord.column - next_end.column;
}
else
coord.line -= next_end.line - next_coord.line;
}
std::swap(*it, *it_next);
progress = true;
}
2013-06-12 00:14:05 +02:00
kak_assert(coord <= next_coord);
if (it->type == Erase and it_next->type == Erase and coord == next_coord)
{
it->content += it_next->content;
it_next = undo_group.erase(it_next);
progress = true;
}
else if (it->type == Insert and it_next->type == Insert and
is_in_range(next_coord, coord, advance(coord, it->content)))
{
ByteCount prefix_len = count_byte_to(coord, next_coord, it->content);
it->content = it->content.substr(0, prefix_len) + it_next->content
+ it->content.substr(prefix_len);
it_next = undo_group.erase(it_next);
progress = true;
}
else if (it->type == Insert and it_next->type == Erase and
2013-06-12 00:14:05 +02:00
next_coord < advance(coord, it->content))
{
ByteCount insert_len = it->content.length();
ByteCount erase_len = it_next->content.length();
ByteCount prefix_len = count_byte_to(coord, next_coord, it->content);
2013-06-12 00:14:05 +02:00
ByteCount suffix_len = insert_len - prefix_len;
if (suffix_len >= erase_len)
{
it->content = it->content.substr(0, prefix_len) + it->content.substr(prefix_len + erase_len);
it_next = undo_group.erase(it_next);
}
else
{
it->content = it->content.substr(0, prefix_len);
it_next->content = it_next->content.substr(suffix_len);
++it, ++it_next;
}
progress = true;
}
else if (it->type == Erase and it_next->type == Insert and coord == next_coord and
(pos = overlaps(it->content, it_next->content)) != -1)
{
ByteCount overlaps_len = it->content.length() - pos;
it->content = it->content.substr(0, pos);
2013-04-30 19:01:10 +02:00
it_next->coord = advance(it_next->coord, it_next->content.substr(0, overlaps_len));
it_next->content = it_next->content.substr(overlaps_len);
++it, ++it_next;
progress = true;
}
else
++it, ++it_next;
}
return progress;
}
static bool erase_empty(Buffer::UndoGroup& undo_group)
{
auto it = std::remove_if(begin(undo_group), end(undo_group),
[](Buffer::Modification& m) { return m.content.empty(); });
if (it != end(undo_group))
{
undo_group.erase(it, end(undo_group));
return true;
}
return false;
}
public:
static void optimize(Buffer::UndoGroup& undo_group)
{
while (undo_group.size() > 1)
{
bool progress = false;
progress |= merge_contiguous(undo_group);
progress |= erase_empty(undo_group);
if (not progress)
break;
}
}
};
void Buffer::commit_undo_group()
{
if (m_flags & Flags::NoUndo)
return;
UndoGroupOptimizer::optimize(m_current_undo_group);
if (m_current_undo_group.empty())
return;
m_history.erase(m_history_cursor, m_history.end());
m_history.push_back(std::move(m_current_undo_group));
m_current_undo_group.clear();
m_history_cursor = m_history.end();
if (m_history.size() < m_last_save_undo_index)
m_last_save_undo_index = -1;
}
bool Buffer::undo()
{
commit_undo_group();
if (m_history_cursor == m_history.begin())
return false;
--m_history_cursor;
for (const Modification& modification : reversed(*m_history_cursor))
apply_modification(modification.inverse());
2012-06-05 15:33:02 +02:00
return true;
}
bool Buffer::redo()
{
if (m_history_cursor == m_history.end())
return false;
kak_assert(m_current_undo_group.empty());
for (const Modification& modification : *m_history_cursor)
apply_modification(modification);
++m_history_cursor;
2012-06-05 15:33:02 +02:00
return true;
}
void Buffer::check_invariant() const
{
#ifdef KAK_DEBUG
ByteCount start = 0;
kak_assert(not m_lines.empty());
for (auto& line : m_lines)
{
kak_assert(line.start == start);
kak_assert(line.length() > 0);
kak_assert(line.content.back() == '\n');
2012-03-30 14:00:40 +02:00
start += line.length();
}
#endif
}
2013-07-26 00:44:00 +02:00
BufferCoord Buffer::do_insert(BufferCoord pos, const String& content)
{
kak_assert(is_valid(pos));
if (content.empty())
return pos;
2012-08-15 17:07:53 +02:00
++m_timestamp;
ByteCount offset = this->offset(pos);
// all following lines advanced by length
for (LineCount i = pos.line+1; i < line_count(); ++i)
m_lines[i].start += content.length();
BufferCoord begin;
BufferCoord end;
// if we inserted at the end of the buffer, we have created a new
// line without inserting a '\n'
if (is_end(pos))
{
ByteCount start = 0;
for (ByteCount i = 0; i < content.length(); ++i)
{
if (content[i] == '\n')
{
m_lines.push_back({ offset + start, content.substr(start, i + 1 - start) });
start = i + 1;
}
}
if (start != content.length())
m_lines.push_back({ offset + start, content.substr(start) });
begin = pos.column == 0 ? pos : BufferCoord{ pos.line + 1, 0 };
2013-06-03 19:01:07 +02:00
end = BufferCoord{ line_count()-1, m_lines.back().length() };
}
else
{
String prefix = m_lines[pos.line].content.substr(0, pos.column);
String suffix = m_lines[pos.line].content.substr(pos.column);
std::vector<Line> new_lines;
ByteCount start = 0;
for (ByteCount i = 0; i < content.length(); ++i)
{
if (content[i] == '\n')
{
String line_content = content.substr(start, i + 1 - start);
if (start == 0)
{
line_content = prefix + line_content;
new_lines.push_back({ offset + start - prefix.length(),
std::move(line_content) });
}
else
new_lines.push_back({ offset + start, std::move(line_content) });
start = i + 1;
}
}
if (start == 0)
new_lines.push_back({ offset + start - prefix.length(), prefix + content + suffix });
2012-08-10 14:22:57 +02:00
else if (start != content.length() or not suffix.empty())
new_lines.push_back({ offset + start, content.substr(start) + suffix });
LineCount last_line = pos.line + new_lines.size() - 1;
auto line_it = m_lines.begin() + (int)pos.line;
*line_it = std::move(*new_lines.begin());
m_lines.insert(line_it+1, std::make_move_iterator(new_lines.begin() + 1),
std::make_move_iterator(new_lines.end()));
begin = pos;
end = BufferCoord{ last_line, m_lines[last_line].length() - suffix.length() };
}
for (auto listener : m_change_listeners)
listener->on_insert(*this, begin, end);
return begin;
}
2013-07-26 00:44:00 +02:00
BufferCoord Buffer::do_erase(BufferCoord begin, BufferCoord end)
{
kak_assert(is_valid(begin));
kak_assert(is_valid(end));
2012-08-15 17:07:53 +02:00
++m_timestamp;
const ByteCount length = distance(begin, end);
String prefix = m_lines[begin.line].content.substr(0, begin.column);
String suffix = m_lines[end.line].content.substr(end.column);
Line new_line = { m_lines[begin.line].start, prefix + suffix };
BufferCoord next;
if (new_line.length() != 0)
{
m_lines.erase(m_lines.begin() + (int)begin.line, m_lines.begin() + (int)end.line);
m_lines[begin.line] = std::move(new_line);
next = begin;
}
else
{
m_lines.erase(m_lines.begin() + (int)begin.line, m_lines.begin() + (int)end.line + 1);
next = is_end(begin) ? end_coord() : BufferCoord{begin.line, 0};
}
for (LineCount i = begin.line+1; i < line_count(); ++i)
m_lines[i].start -= length;
for (auto listener : m_change_listeners)
listener->on_erase(*this, begin, end);
return next;
}
void Buffer::apply_modification(const Modification& modification)
{
const String& content = modification.content;
2013-07-26 00:44:00 +02:00
BufferCoord coord = modification.coord;
kak_assert(is_valid(coord));
// in modifications, end coords should be {line_count(), 0}
kak_assert(coord != BufferCoord(line_count()-1, m_lines.back().length()));
switch (modification.type)
{
case Modification::Insert:
{
do_insert(coord, content);
break;
}
case Modification::Erase:
{
2012-10-11 01:17:29 +02:00
ByteCount count = content.length();
BufferCoord end = advance(coord, count);
kak_assert(string(coord, end) == content);
do_erase(coord, end);
break;
}
default:
kak_assert(false);
}
}
BufferIterator Buffer::insert(const BufferIterator& pos, String content)
{
kak_assert(is_valid(pos.coord()));
if (content.empty())
return pos;
if (pos == end() and content.back() != '\n')
content += '\n';
// for undo and redo purpose it is better to use one past last line rather
// than one past last char coord.
auto coord = pos == end() ? BufferCoord{line_count()} : pos.coord();
if (not (m_flags & Flags::NoUndo))
m_current_undo_group.emplace_back(Modification::Insert, coord, content);
return {*this, do_insert(pos.coord(), content)};
}
BufferIterator Buffer::erase(BufferIterator begin, BufferIterator end)
{
// do not erase last \n except if we erase from the start of a line
if (end == this->end() and (begin.coord().column != 0 or begin == this->begin()))
--end;
if (begin == end)
return begin;
2012-03-12 22:31:27 +01:00
if (not (m_flags & Flags::NoUndo))
m_current_undo_group.emplace_back(Modification::Erase, begin.coord(),
string(begin.coord(), end.coord()));
return {*this, do_erase(begin.coord(), end.coord())};
}
2011-10-05 16:21:24 +02:00
bool Buffer::is_modified() const
{
2011-11-03 14:44:02 +01:00
size_t history_cursor_index = m_history_cursor - m_history.begin();
return m_last_save_undo_index != history_cursor_index
2011-10-05 16:21:24 +02:00
or not m_current_undo_group.empty();
}
void Buffer::notify_saved()
{
2012-12-19 18:56:20 +01:00
if (not m_current_undo_group.empty())
commit_undo_group();
2012-12-19 18:56:20 +01:00
m_flags &= ~Flags::New;
2011-11-03 14:44:02 +01:00
size_t history_cursor_index = m_history_cursor - m_history.begin();
if (m_last_save_undo_index != history_cursor_index)
{
++m_timestamp;
m_last_save_undo_index = history_cursor_index;
}
m_fs_timestamp = get_fs_timestamp(m_name);
2011-10-05 16:21:24 +02:00
}
BufferCoord Buffer::advance(BufferCoord coord, ByteCount count) const
{
ByteCount off = Kakoune::clamp(offset(coord) + count, 0_byte, byte_count());
auto it = std::upper_bound(m_lines.begin(), m_lines.end(), off,
[](ByteCount s, const Line& l) { return s < l.start; }) - 1;
return { LineCount{ (int)(it - m_lines.begin()) }, off - it->start };
}
BufferCoord Buffer::next(BufferCoord coord) const
{
if (coord.column < m_lines[coord.line].length() - 1)
++coord.column;
else if (coord.line == m_lines.size() - 1)
coord.column = m_lines.back().length();
else
{
++coord.line;
coord.column = 0;
}
return coord;
}
BufferCoord Buffer::char_next(BufferCoord coord) const
{
if (coord.column < m_lines[coord.line].length() - 1)
{
auto& line = m_lines[coord.line].content;
coord.column += utf8::codepoint_size(line.begin() + (int)coord.column);
}
else if (coord.line == m_lines.size() - 1)
coord.column = m_lines.back().length();
else
{
++coord.line;
coord.column = 0;
}
return coord;
}
BufferCoord Buffer::prev(BufferCoord coord) const
{
if (coord.column == 0)
{
if (coord.line > 0)
2013-06-04 14:11:55 +02:00
coord.column = m_lines[--coord.line].length() - 1;
}
else
--coord.column;
return coord;
}
BufferCoord Buffer::char_prev(BufferCoord coord) const
{
kak_assert(is_valid(coord));
if (is_end(coord))
return coord = {(int)m_lines.size()-1, m_lines.back().length() - 1};
else if (coord.column == 0)
{
if (coord.line > 0)
2013-06-04 14:11:55 +02:00
coord.column = m_lines[--coord.line].length() - 1;
}
else
{
auto& line = m_lines[coord.line].content;
coord.column = (int)(utf8::character_start(line.begin() + (int)coord.column - 1) - line.begin());
}
return coord;
}
2013-07-26 00:44:00 +02:00
ByteCount Buffer::distance(BufferCoord begin, BufferCoord end) const
{
return offset(end) - offset(begin);
}
2013-07-26 00:44:00 +02:00
ByteCount Buffer::offset(BufferCoord c) const
{
if (c.line == line_count())
return m_lines.back().start + m_lines.back().length();
return m_lines[c.line].start + c.column;
}
2013-07-26 00:44:00 +02:00
bool Buffer::is_valid(BufferCoord c) const
{
return (c.line < line_count() and c.column < m_lines[c.line].length()) or
(c.line == line_count() - 1 and c.column == m_lines.back().length()) or
(c.line == line_count() and c.column == 0);
}
2013-07-26 00:44:00 +02:00
bool Buffer::is_end(BufferCoord c) const
{
return c >= BufferCoord{line_count() - 1, m_lines.back().length()};
}
2013-07-26 00:44:00 +02:00
char Buffer::byte_at(BufferCoord c) const
{
kak_assert(c.line < line_count() and c.column < m_lines[c.line].length());
return m_lines[c.line].content[c.column];
}
time_t Buffer::fs_timestamp() const
{
kak_assert(m_flags & Flags::File);
return m_fs_timestamp;
}
void Buffer::set_fs_timestamp(time_t ts)
{
kak_assert(m_flags & Flags::File);
m_fs_timestamp = ts;
}
2011-09-02 18:51:20 +02:00
}