* Licence details can be found in the file COPYING.
*
* \author Matthias Ettrich
- * \author Lars Gullik Bjønnes
+ * \author Lars Gullik Bjønnes
* \author John Levon
+ * \author Guillaume Munch
*
* Full author contact details are available in file CREDITS.
*/
#include <config.h>
+#include "Buffer.h"
+#include "Cursor.h"
+#include "FuncRequest.h"
+#include "Paragraph.h"
#include "TexRow.h"
-#include "debug.h"
+
+#include "mathed/InsetMath.h"
+
+#include "support/convert.h"
+#include "support/debug.h"
+#include "support/docstring_list.h"
+#include "support/lassert.h"
#include <algorithm>
+#include <iterator>
+#include <sstream>
+
+using namespace std;
namespace lyx {
+TexString::TexString(docstring s)
+ : str(move(s)), texrow(TexRow())
+{
+ texrow.setRows(1 + count(str.begin(), str.end(), '\n'));
+}
+
+
+TexString::TexString(docstring s, TexRow t)
+ : str(move(s)), texrow(move(t))
+{
+ validate();
+}
+
+
+void TexString::validate()
+{
+ size_t lines = 1 + count(str.begin(), str.end(), '\n');
+ size_t rows = texrow.rows();
+ bool valid = lines == rows;
+ if (!valid)
+ LYXERR0("TexString has " << lines << " lines but " << rows << " rows." );
+ // Assert in devel mode. This is important to catch bugs early, otherwise
+ // they might be hard to notice and find. Recover gracefully in release
+ // mode.
+ LASSERT(valid, texrow.setRows(lines));
+}
+
+
+bool TexRow::RowEntryList::addEntry(RowEntry entry)
+{
+ switch (entry.type) {
+ case text_entry:
+ if (isNone(text_entry_))
+ text_entry_ = entry.text;
+ else if (!v_.empty() && TexRow::sameParOrInsetMath(v_.back(), entry))
+ return false;
+ break;
+ default:
+ break;
+ }
+ forceAddEntry(entry);
+ return true;
+}
+
+
+void TexRow::RowEntryList::forceAddEntry(RowEntry entry)
+{
+ if (v_.empty() || !(v_.back() == entry))
+ v_.push_back(entry);
+}
+
+
+TexRow::TextEntry TexRow::RowEntryList::getTextEntry() const
+{
+ if (!isNone(text_entry_))
+ return text_entry_;
+ return TexRow::text_none;
+}
+
+
+void TexRow::RowEntryList::append(RowEntryList row)
+{
+ if (isNone(text_entry_))
+ text_entry_ = row.text_entry_;
+ move(row.begin(), row.end(), back_inserter(v_));
+}
+
+
+TexRow::TexRow()
+{
+ reset();
+}
+
+
+TexRow::TextEntry const TexRow::text_none = { -1, 0 };
+TexRow::RowEntry const TexRow::row_none = TexRow::textEntry(-1, 0);
+
+
+//static
+bool TexRow::isNone(TextEntry t)
+{
+ return t.id < 0;
+}
+
+
+//static
+bool TexRow::isNone(RowEntry r)
+{
+ return r.type == text_entry && isNone(r.text);
+}
+
+
void TexRow::reset()
{
- rowlist.clear();
- lastid = -1;
- lastpos = -1;
+ rowlist_.clear();
+ newline();
+}
+
+
+TexRow::RowEntryList & TexRow::currentRow()
+{
+ return rowlist_.back();
}
-void TexRow::start(int id, int pos)
+//static
+TexRow::RowEntry TexRow::textEntry(int id, pos_type pos)
{
- lastid = id;
- lastpos = pos;
+ RowEntry entry;
+ entry.type = text_entry;
+ entry.text.pos = pos;
+ entry.text.id = id;
+ return entry;
+}
+
+
+//static
+TexRow::RowEntry TexRow::mathEntry(uid_type id, idx_type cell)
+{
+ RowEntry entry;
+ entry.type = math_entry;
+ entry.math.cell = cell;
+ entry.math.id = id;
+ return entry;
+}
+
+
+//static
+TexRow::RowEntry TexRow::beginDocument()
+{
+ RowEntry entry;
+ entry.type = begin_document;
+ entry.begindocument = {};
+ return entry;
+}
+
+
+bool operator==(TexRow::RowEntry entry1, TexRow::RowEntry entry2)
+{
+ if (entry1.type != entry2.type)
+ return false;
+ switch (entry1.type) {
+ case TexRow::text_entry:
+ return entry1.text.id == entry2.text.id
+ && entry1.text.pos == entry2.text.pos;
+ case TexRow::math_entry:
+ return entry1.math.id == entry2.math.id
+ && entry1.math.cell == entry2.math.cell;
+ case TexRow::begin_document:
+ return true;
+ default:
+ return false;
+ }
+}
+
+
+bool TexRow::start(RowEntry entry)
+{
+ return currentRow().addEntry(entry);
+}
+
+
+bool TexRow::start(int id, pos_type pos)
+{
+ return start(textEntry(id,pos));
+}
+
+
+void TexRow::forceStart(int id, pos_type pos)
+{
+ return currentRow().forceAddEntry(textEntry(id,pos));
+}
+
+
+void TexRow::startMath(uid_type id, idx_type cell)
+{
+ start(mathEntry(id,cell));
}
void TexRow::newline()
{
- int const id = lastid;
- RowList::value_type tmp(id, lastpos);
- rowlist.push_back(tmp);
+ rowlist_.push_back(RowEntryList());
+}
+
+
+void TexRow::newlines(size_t num_lines)
+{
+ while (num_lines--)
+ newline();
+}
+
+
+void TexRow::append(TexRow other)
+{
+ RowList::iterator it = other.rowlist_.begin();
+ RowList::iterator const end = other.rowlist_.end();
+ LASSERT(it != end, return);
+ currentRow().append(move(*it++));
+ move(it, end, back_inserter(rowlist_));
}
-bool TexRow::getIdFromRow(int row, int & id, int & pos) const
+pair<TexRow::TextEntry, TexRow::TextEntry>
+TexRow::getEntriesFromRow(int const row) const
{
- if (row <= 0 || row > int(rowlist.size())) {
- id = -1;
- pos = 0;
+ // FIXME: Take math entries into account, take table cells into account and
+ // get rid of the ad hoc special text entry for each row.
+ //
+ // FIXME: A yellow note alone on its paragraph makes the reverse-search on
+ // the subsequent line inaccurate. Get rid of text entries that
+ // correspond to no output by delaying their addition, at the level
+ // of otexrowstream, until a character is actually output.
+ //
+ LYXERR(Debug::LATEX, "getEntriesFromRow: row " << row << " requested");
+
+ // check bounds for row - 1, our target index
+ if (row <= 0)
+ return {text_none, text_none};
+ size_t const i = static_cast<size_t>(row - 1);
+ if (i >= rowlist_.size())
+ return {text_none, text_none};
+
+ // find the start entry
+ TextEntry const start = [&]() {
+ for (size_t j = i; j > 0; --j) {
+ if (!isNone(rowlist_[j].getTextEntry()))
+ return rowlist_[j].getTextEntry();
+ // Check the absence of begin_document at row j. The begin_document row
+ // entry is used to prevent mixing of body and preamble.
+ for (RowEntry entry : rowlist_[j])
+ if (entry.type == begin_document)
+ return text_none;
+ }
+ return text_none;
+ } ();
+
+ // find the end entry
+ TextEntry end = [&]() {
+ if (isNone(start))
+ return text_none;
+ // select up to the last position of the starting paragraph as a
+ // fallback
+ TextEntry last_pos = {start.id, -1};
+ // find the next occurence of paragraph start.id
+ for (size_t j = i + 1; j < rowlist_.size(); ++j) {
+ for (RowEntry entry : rowlist_[j]) {
+ if (entry.type == begin_document)
+ // what happens in the preamble remains in the preamble
+ return last_pos;
+ if (entry.type == text_entry && entry.text.id == start.id)
+ return entry.text;
+ }
+ }
+ return last_pos;
+ } ();
+
+ // The following occurs for a displayed math inset for instance (for good
+ // reasons involving subtleties of the algorithm in getRowFromDocIterator).
+ // We want this inset selected.
+ if (start.id == end.id && start.pos == end.pos)
+ ++end.pos;
+
+ return {start, end};
+}
+
+
+pair<DocIterator, DocIterator> TexRow::getDocIteratorsFromRow(
+ int const row,
+ Buffer const & buf) const
+{
+ TextEntry start, end;
+ tie(start,end) = getEntriesFromRow(row);
+ return getDocIteratorsFromEntries(start, end, buf);
+}
+
+
+//static
+pair<DocIterator, DocIterator> TexRow::getDocIteratorsFromEntries(
+ TextEntry start,
+ TextEntry end,
+ Buffer const & buf)
+{
+ auto set_pos = [](DocIterator & dit, pos_type pos) {
+ dit.pos() = (pos >= 0) ? min(pos, dit.lastpos())
+ // negative pos values are counted from the end
+ : max(dit.lastpos() + pos + 1, pos_type(0));
+ };
+ // Finding start
+ DocIterator dit_start = buf.getParFromID(start.id);
+ if (dit_start)
+ set_pos(dit_start, start.pos);
+ // Finding end
+ DocIterator dit_end = buf.getParFromID(end.id);
+ if (dit_end) {
+ set_pos(dit_end, end.pos);
+ // Step backwards to prevent selecting the beginning of another
+ // paragraph.
+ if (dit_end.pos() == 0 && !dit_end.top().at_cell_begin()) {
+ CursorSlice end_top = dit_end.top();
+ end_top.backwardPos();
+ if (dit_start && end_top != dit_start.top())
+ dit_end.top() = end_top;
+ }
+ dit_end.boundary(true);
+ }
+ return {dit_start, dit_end};
+}
+
+
+//static
+FuncRequest TexRow::goToFunc(TextEntry start, TextEntry end)
+{
+ return {LFUN_PARAGRAPH_GOTO,
+ convert<string>(start.id) + " " + convert<string>(start.pos) + " " +
+ convert<string>(end.id) + " " + convert<string>(end.pos)};
+}
+
+
+FuncRequest TexRow::goToFuncFromRow(int const row) const
+{
+ TextEntry start, end;
+ tie(start,end) = getEntriesFromRow(row);
+ LYXERR(Debug::LATEX,
+ "goToFuncFromRow: for row " << row << ", TexRow has found "
+ "start (id=" << start.id << ",pos=" << start.pos << "), "
+ "end (id=" << end.id << ",pos=" << end.pos << ")");
+ return goToFunc(start, end);
+}
+
+
+//static
+TexRow::RowEntry TexRow::rowEntryFromCursorSlice(CursorSlice const & slice)
+{
+ RowEntry entry;
+ InsetMath * insetMath = slice.asInsetMath();
+ if (insetMath) {
+ entry.type = math_entry;
+ entry.math.id = insetMath->id();
+ entry.math.cell = slice.idx();
+ } else if (slice.text()) {
+ entry.type = text_entry;
+ entry.text.id = slice.paragraph().id();
+ entry.text.pos = slice.pos();
+ } else
+ LASSERT(false, return row_none);
+ return entry;
+}
+
+
+//static
+bool TexRow::sameParOrInsetMath(RowEntry entry1, RowEntry entry2)
+{
+ if (entry1.type != entry2.type)
+ return false;
+ switch (entry1.type) {
+ case TexRow::text_entry:
+ return entry1.text.id == entry2.text.id;
+ case TexRow::math_entry:
+ return entry1.math.id == entry2.math.id;
+ case TexRow::begin_document:
+ return true;
+ default:
return false;
}
+}
- id = rowlist[row - 1].id();
- pos = rowlist[row - 1].pos();
- return true;
+
+//static
+int TexRow::comparePos(RowEntry entry1, RowEntry entry2)
+{
+ // assume it is sameParOrInsetMath
+ switch (entry1.type /* equal to entry2.type */) {
+ case TexRow::text_entry:
+ return entry2.text.pos - entry1.text.pos;
+ case TexRow::math_entry:
+ return entry2.math.cell - entry1.math.cell;
+ case TexRow::begin_document:
+ return 0;
+ default:
+ return 0;
+ }
+}
+
+
+// An iterator on RowList that goes top-down, left-right
+//
+// We assume that the end of RowList does not change, which makes things simpler
+//
+// Records a pair of iterators on the RowEntryList (row_it_, row_end_) and a
+// pair of iterators on the current row (it_, it_end_).
+//
+// it_ always points to a valid position unless row_it_ == row_end_.
+//
+// We could turn this into a proper bidirectional iterator, but we don't need as
+// much.
+//
+class TexRow::RowListIterator
+{
+public:
+ RowListIterator(RowList::const_iterator r,
+ RowList::const_iterator r_end)
+ : row_it_(r), row_end_(r_end),
+ it_(r == r_end ? RowEntryList::const_iterator() : r->begin()),
+ it_end_(r == r_end ? RowEntryList::const_iterator() : r->end())
+ {
+ normalize();
+ }
+
+
+ RowListIterator() :
+ row_it_(RowList::const_iterator()),
+ row_end_(RowList::const_iterator()),
+ it_(RowEntryList::const_iterator()),
+ it_end_(RowEntryList::const_iterator()) { }
+
+
+ RowEntry const & operator*()
+ {
+ return *it_;
+ }
+
+
+ RowListIterator & operator++()
+ {
+ ++it_;
+ normalize();
+ return *this;
+ }
+
+
+ bool atEnd() const
+ {
+ return row_it_ == row_end_;
+ }
+
+
+ bool operator==(RowListIterator const & a) const
+ {
+ return row_it_ == a.row_it_ && ((atEnd() && a.atEnd()) || it_ == a.it_);
+ }
+
+
+ bool operator!=(RowListIterator const & a) const { return !operator==(a); }
+
+
+ // Current row.
+ RowList::const_iterator const & row() const
+ {
+ return row_it_;
+ }
+private:
+ // ensures that it_ points to a valid value unless row_it_ == row_end_
+ void normalize()
+ {
+ if (row_it_ == row_end_)
+ return;
+ while (it_ == it_end_) {
+ ++row_it_;
+ if (row_it_ != row_end_) {
+ it_ = row_it_->begin();
+ it_end_ = row_it_->end();
+ } else
+ return;
+ }
+ }
+ //
+ RowList::const_iterator row_it_;
+ //
+ RowList::const_iterator row_end_;
+ //
+ RowEntryList::const_iterator it_;
+ //
+ RowEntryList::const_iterator it_end_;
+};
+
+
+TexRow::RowListIterator TexRow::begin() const
+{
+ return RowListIterator(rowlist_.begin(), rowlist_.end());
}
-int TexRow::getRowFromIdPos(int id, int pos) const
+TexRow::RowListIterator TexRow::end() const
{
- int bestrow = 0;
- bool foundid = false;
+ return RowListIterator(rowlist_.end(), rowlist_.end());
+}
+
- // this loop finds the last *nonempty* row whith the same id
- // and position <= pos
- for (unsigned r = 0, n = rowlist.size(); r != n; ++r) {
- if (rowlist[r].id() == id && rowlist[r].pos() <= pos) {
- foundid = true;
- if (rowlist[bestrow].id() != id || rowlist[r].pos() > rowlist[bestrow].pos())
- bestrow = r;
- } else if (foundid)
- break;
+pair<int,int> TexRow::rowFromDocIterator(DocIterator const & dit) const
+{
+ // Do not change anything in this algorithm if unsure.
+ bool beg_found = false;
+ bool end_is_next = true;
+ int end_offset = 1;
+ size_t best_slice = 0;
+ RowEntry best_entry = row_none;
+ size_t const n = dit.depth();
+ // this loop finds a pair (best_beg_row,best_end_row) where best_beg_row is
+ // the first row of the topmost possible CursorSlice, and best_end_row is
+ // the one just before the first row matching the next CursorSlice.
+ RowListIterator const begin = this->begin();//necessary disambiguation
+ RowListIterator const end = this->end();
+ RowListIterator best_beg_entry;
+ //best last entry with same pos as the beg_entry, or first entry with pos
+ //immediately following the beg_entry
+ RowListIterator best_end_entry;
+ RowListIterator it = begin;
+ for (; it != end; ++it) {
+ // Compute the best end row.
+ if (beg_found
+ && (!sameParOrInsetMath(*it, *best_end_entry)
+ || comparePos(*it, *best_end_entry) <= 0)
+ && sameParOrInsetMath(*it, best_entry)) {
+ switch (comparePos(*it, best_entry)) {
+ case 0:
+ // Either it is the last one that matches pos...
+ best_end_entry = it;
+ end_is_next = false;
+ end_offset = 1;
+ break;
+ case -1: {
+ // ...or it is the row preceding the first that matches pos+1
+ if (!end_is_next) {
+ end_is_next = true;
+ if (it.row() != best_end_entry.row())
+ end_offset = 0;
+ best_end_entry = it;
+ }
+ break;
+ }
+ }
+ }
+ // Compute the best begin row. It is better than the previous one if it
+ // matches either at a deeper level, or at the same level but not
+ // before.
+ for (size_t i = best_slice; i < n; ++i) {
+ RowEntry entry_i = rowEntryFromCursorSlice(dit[i]);
+ if (sameParOrInsetMath(*it, entry_i)) {
+ if (comparePos(*it, entry_i) >= 0
+ && (i > best_slice
+ || !beg_found
+ || !sameParOrInsetMath(*it, *best_beg_entry)
+ || (comparePos(*it, *best_beg_entry) <= 0
+ && comparePos(entry_i, *best_beg_entry) != 0)
+ )
+ ) {
+ beg_found = true;
+ end_is_next = false;
+ end_offset = 1;
+ best_slice = i;
+ best_entry = entry_i;
+ best_beg_entry = best_end_entry = it;
+ }
+ //found CursorSlice
+ break;
+ }
+ }
+ }
+ if (!beg_found)
+ return make_pair(-1,-1);
+ int const best_beg_row = distance(rowlist_.begin(),
+ best_beg_entry.row()) + 1;
+ int const best_end_row = distance(rowlist_.begin(),
+ best_end_entry.row()) + end_offset;
+ return make_pair(best_beg_row, best_end_row);
+}
+
+
+pair<int,int> TexRow::rowFromCursor(Cursor const & cur) const
+{
+ DocIterator beg = cur.selectionBegin();
+ pair<int,int> beg_rows = rowFromDocIterator(beg);
+ if (cur.selection()) {
+ DocIterator end = cur.selectionEnd();
+ if (!cur.selIsMultiCell() && !end.top().at_cell_begin())
+ end.top().backwardPos();
+ pair<int,int> end_rows = rowFromDocIterator(end);
+ return make_pair(min(beg_rows.first, end_rows.first),
+ max(beg_rows.second, end_rows.second));
+ } else
+ return make_pair(beg_rows.first, beg_rows.second);
+}
+
+
+size_t TexRow::rows() const
+{
+ return rowlist_.size();
+}
+
+
+void TexRow::setRows(size_t r)
+{
+ rowlist_.resize(r, RowEntryList());
+}
+
+
+// debugging functions
+
+///
+docstring TexRow::asString(RowEntry entry)
+{
+ odocstringstream os;
+ switch (entry.type) {
+ case TexRow::text_entry:
+ os << "(par " << entry.text.id << "," << entry.text.pos << ")";
+ break;
+ case TexRow::math_entry:
+ os << "(" << entry.math.id << "," << entry.math.cell << ")";
+ break;
+ case TexRow::begin_document:
+ os << "(begin_document)";
+ break;
+ default:
+ break;
+ }
+ return os.str();
+}
+
+
+///prepends the texrow to the source given by tex, for debugging purpose
+void TexRow::prepend(docstring_list & tex) const
+{
+ size_type const prefix_length = 25;
+ if (tex.size() < rowlist_.size())
+ tex.resize(rowlist_.size());
+ auto it = rowlist_.cbegin();
+ auto const beg = rowlist_.cbegin();
+ auto const end = rowlist_.cend();
+ for (; it < end; ++it) {
+ docstring entry;
+ for (RowEntry const & e : *it)
+ entry += asString(e);
+ if (entry.length() < prefix_length)
+ entry = entry + docstring(prefix_length - entry.length(), ' ');
+ ptrdiff_t i = it - beg;
+ tex[i] = entry + " " + tex[i];
}
- if (!foundid)
- return rowlist.size();
- return bestrow;
}
projects / lyx.git / blobdiff