X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyxfind.cpp;h=f3b3eef4846bf7c7a2778cdcc07636a6c9ed23ff;hb=0bdfca2c6edbcfc87c648fdfd3de46f2662561fa;hp=74b045c4bba0cb2729916a640d5a1d7b2857da63;hpb=43f6b1672b5ef442b4e9b7e4f7ea76dc14ac4fc8;p=lyx.git

diff --git a/src/lyxfind.cpp b/src/lyxfind.cpp
index 74b045c4bb..f3b3eef484 100644
--- a/src/lyxfind.cpp
+++ b/src/lyxfind.cpp
@@ -45,6 +45,7 @@
 #include "support/convert.h"
 #include "support/debug.h"
 #include "support/docstream.h"
+#include "support/FileName.h"
 #include "support/gettext.h"
 #include "support/lassert.h"
 #include "support/lstrings.h"
@@ -121,23 +122,6 @@ int findBackwards(DocIterator & cur, MatchString const & match,
 }
 
 
-bool findChange(DocIterator & cur, bool next)
-{
-	if (!next)
-		cur.backwardPos();
-	for (; cur; next ? cur.forwardPos() : cur.backwardPos())
-		if (cur.inTexted() && cur.paragraph().isChanged(cur.pos())) {
-			if (!next)
-				// if we search backwards, take a step forward
-				// to correctly set the anchor
-				cur.forwardPos();
-			return true;
-		}
-
-	return false;
-}
-
-
 bool searchAllowed(docstring const & str)
 {
 	if (str.empty()) {
@@ -154,7 +138,9 @@ bool findOne(BufferView * bv, docstring const & searchstr,
 	if (!searchAllowed(searchstr))
 		return false;
 
-	DocIterator cur = bv->cursor();
+	DocIterator cur = forward 
+		? bv->cursor().selectionEnd() 
+		: bv->cursor().selectionBegin();
 
 	MatchString const match(searchstr, case_sens, whole);
 
@@ -196,9 +182,9 @@ int replaceAll(BufferView * bv,
 		cur.recordUndo();
 		int striked = ssize -
 			cur.paragraph().eraseChars(pos, pos + match_len,
-						   buf.params().trackChanges);
+						   buf.params().track_changes);
 		cur.paragraph().insert(pos, replacestr, font,
-				       Change(buf.params().trackChanges
+				       Change(buf.params().track_changes
 					      ? Change::INSERTED
 					      : Change::UNCHANGED));
 		for (int i = 0; i < rsize + striked; ++i)
@@ -246,7 +232,9 @@ pair<bool, int> replaceOne(BufferView * bv, docstring searchstr,
 		if (!cur.inTexted())
 			// bail in math
 			return make_pair(false, 0);
-		// select current word and treat it as the search string
+		// select current word and treat it as the search string.
+		// This causes a minor bug as undo will restore this selection,
+		// which the user did not create (#8986).
 		cur.innerText()->selectWord(cur, WHOLE_WORD);
 		searchstr = cur.selectionAsString(false);
 	}
@@ -278,7 +266,8 @@ pair<bool, int> replaceOne(BufferView * bv, docstring searchstr,
 	cap::replaceSelectionWithString(cur, replacestr);
 	if (forward) {
 		cur.pos() += replacestr.length();
-		LASSERT(cur.pos() <= cur.lastpos(), /* */);
+		LASSERT(cur.pos() <= cur.lastpos(),
+		        cur.pos() = cur.lastpos());
 	}
 	if (findnext)
 		findOne(bv, searchstr, case_sens, whole, forward, false);
@@ -377,7 +366,7 @@ bool lyxreplace(BufferView * bv,
 		Buffer const & buf = bv->buffer();
 		if (!update) {
 			// emit message signal.
-			buf.message(_("String not found!"));
+			buf.message(_("String not found."));
 		} else {
 			if (replace_count == 0) {
 				buf.message(_("String found."));
@@ -395,98 +384,90 @@ bool lyxreplace(BufferView * bv,
 		if (findOne(bv, search, casesensitive, matchword, forward))
 			update = true;
 		else
-			bv->message(_("String not found!"));
+			bv->message(_("String not found."));
 	}
 	return update;
 }
 
 
-bool findNextChange(BufferView * bv)
+bool findNextChange(DocIterator & cur)
 {
-	return findChange(bv, true);
+	for (; cur; cur.forwardPos())
+		if (cur.inTexted() && cur.paragraph().isChanged(cur.pos()))
+			return true;
+	return false;
 }
 
 
-bool findPreviousChange(BufferView * bv)
+bool findPreviousChange(DocIterator & cur)
 {
-	return findChange(bv, false);
+	for (cur.backwardPos(); cur; cur.backwardPos()) {
+		if (cur.inTexted() && cur.paragraph().isChanged(cur.pos()))
+			return true;
+	}
+	return false;
 }
 
 
-bool findChange(BufferView * bv, bool next)
+bool selectChange(Cursor & cur, bool forward)
 {
-	if (bv->cursor().selection()) {
-		// set the cursor at the beginning or at the end of the selection
-		// before searching. Otherwise, the current change will be found.
-		if (next != (bv->cursor().top() > bv->cursor().normalAnchor()))
-			bv->cursor().setCursorToAnchor();
-	}
+	if (!cur.inTexted() || !cur.paragraph().isChanged(cur.pos()))
+		return false;
+	Change ch = cur.paragraph().lookupChange(cur.pos());
 
-	DocIterator cur = bv->cursor();
-
-	// Are we within a change ? Then first search forward (backward),
-	// clear the selection and search the other way around (see the end
-	// of this function). This will avoid changes to be selected half.
-	bool search_both_sides = false;
-	DocIterator tmpcur = cur;
-	// Leave math first
-	while (tmpcur.inMathed())
-		tmpcur.pop_back();
-	Change change_next_pos
-		= tmpcur.paragraph().lookupChange(tmpcur.pos());
-	if (change_next_pos.changed() && cur.inMathed()) {
-		cur = tmpcur;
-		search_both_sides = true;
-	} else if (tmpcur.pos() > 0 && tmpcur.inTexted()) {
-		Change change_prev_pos
-			= tmpcur.paragraph().lookupChange(tmpcur.pos() - 1);
-		if (change_next_pos.isSimilarTo(change_prev_pos))
-			search_both_sides = true;
+	CursorSlice tip1 = cur.top();
+	for (; tip1.pit() < tip1.lastpit() || tip1.pos() < tip1.lastpos(); tip1.forwardPos()) {
+		Change ch2 = tip1.paragraph().lookupChange(tip1.pos());
+		if (!ch2.isSimilarTo(ch))
+			break;
+	}
+	CursorSlice tip2 = cur.top();
+	for (; tip2.pit() > 0 || tip2.pos() > 0;) {
+		tip2.backwardPos();
+		Change ch2 = tip2.paragraph().lookupChange(tip2.pos());
+		if (!ch2.isSimilarTo(ch)) {
+			// take a step forward to correctly set the selection
+			tip2.forwardPos();
+			break;
+		}
 	}
+	if (forward)
+		swap(tip1, tip2);
+	cur.top() = tip1;
+	cur.bv().mouseSetCursor(cur, false);
+	cur.top() = tip2;
+	cur.bv().mouseSetCursor(cur, true);
+	return true;
+}
 
-	if (!findChange(cur, next))
-		return false;
 
-	bv->cursor().setCursor(cur);
-	bv->cursor().resetAnchor();
+namespace {
 
-	if (!next)
-		// take a step into the change
-		cur.backwardPos();
 
-	Change orig_change = cur.paragraph().lookupChange(cur.pos());
+bool findChange(BufferView * bv, bool forward)
+{
+	Cursor cur(*bv);
+	cur.setCursor(forward ? bv->cursor().selectionEnd()
+		      : bv->cursor().selectionBegin());
+	forward ? findNextChange(cur) : findPreviousChange(cur);
+	return selectChange(cur, forward);
+}
 
-	CursorSlice & tip = cur.top();
-	if (next) {
-		for (; !tip.at_end(); tip.forwardPos()) {
-			Change change = tip.paragraph().lookupChange(tip.pos());
-			if (!change.isSimilarTo(orig_change))
-				break;
-		}
-	} else {
-		for (; !tip.at_begin();) {
-			tip.backwardPos();
-			Change change = tip.paragraph().lookupChange(tip.pos());
-			if (!change.isSimilarTo(orig_change)) {
-				// take a step forward to correctly set the selection
-				tip.forwardPos();
-				break;
-			}
-		}
-	}
+}
 
-	// Now put cursor to end of selection:
-	bv->cursor().setCursor(cur);
-	bv->cursor().setSelection();
+bool findNextChange(BufferView * bv)
+{
+	return findChange(bv, true);
+}
 
-	if (search_both_sides) {
-		bv->cursor().setSelection(false);
-		findChange(bv, !next);
-	}
 
-	return true;
+bool findPreviousChange(BufferView * bv)
+{
+	return findChange(bv, false);
 }
 
+
+
 namespace {
 
 typedef vector<pair<string, string> > Escapes;
@@ -623,6 +604,7 @@ string escape_for_regex(string s, bool match_latex)
 	return s;
 }
 
+
 /// Wrapper for lyx::regex_replace with simpler interface
 bool regex_replace(string const & s, string & t, string const & searchstr,
 		   string const & replacestr)
@@ -637,6 +619,7 @@ bool regex_replace(string const & s, string & t, string const & searchstr,
 	return rv;
 }
 
+
 /** Checks if supplied string segment is well-formed from the standpoint of matching open-closed braces.
  **
  ** Verify that closed braces exactly match open braces. This avoids that, for example,
@@ -678,6 +661,7 @@ bool braces_match(string::const_iterator const & beg,
 	return true;
 }
 
+
 /** The class performing a match between a position in the document and the FindAdvOptions.
  **/
 class MatchStringAdv {
@@ -762,7 +746,8 @@ static docstring buffer_to_latex(Buffer & buffer)
 }
 
 
-static docstring stringifySearchBuffer(Buffer & buffer, FindAndReplaceOptions const & opt) {
+static docstring stringifySearchBuffer(Buffer & buffer, FindAndReplaceOptions const & opt)
+{
 	docstring str;
 	if (!opt.ignoreformat) {
 		str = buffer_to_latex(buffer);
@@ -772,14 +757,17 @@ static docstring stringifySearchBuffer(Buffer & buffer, FindAndReplaceOptions co
 		runparams.flavor = OutputParams::LATEX;
 		runparams.linelen = 100000; //lyxrc.plaintext_linelen;
 		runparams.dryrun = true;
+		runparams.for_search = true;
 		for (pos_type pit = pos_type(0); pit < (pos_type)buffer.paragraphs().size(); ++pit) {
 			Paragraph const & par = buffer.paragraphs().at(pit);
 			LYXERR(Debug::FIND, "Adding to search string: '"
-			       << par.stringify(pos_type(0), par.size(),
-						AS_STR_INSETS, runparams)
+			       << par.asString(pos_type(0), par.size(),
+					       AS_STR_INSETS | AS_STR_SKIPDELETE | AS_STR_PLAINTEXT,
+					       &runparams)
 			       << "'");
-			str += par.stringify(pos_type(0), par.size(),
-					     AS_STR_INSETS, runparams);
+			str += par.asString(pos_type(0), par.size(),
+					    AS_STR_INSETS | AS_STR_SKIPDELETE | AS_STR_PLAINTEXT,
+					    &runparams);
 		}
 	}
 	return str;
@@ -787,7 +775,8 @@ static docstring stringifySearchBuffer(Buffer & buffer, FindAndReplaceOptions co
 
 
 /// Return separation pos between the leading material and the rest
-static size_t identifyLeading(string const & s)  {
+static size_t identifyLeading(string const & s)
+{
 	string t = s;
 	// @TODO Support \item[text]
 	while (regex_replace(t, t, "^\\\\(emph|textbf|subsubsection|subsection|section|subparagraph|paragraph|part)\\*?\\{", "")
@@ -801,7 +790,8 @@ static size_t identifyLeading(string const & s)  {
 
 
 // Remove trailing closure of math, macros and environments, so to catch parts of them.
-static int identifyClosing(string & t) {
+static int identifyClosing(string & t)
+{
 	int open_braces = 0;
 	do {
 		LYXERR(Debug::FIND, "identifyClosing(): t now is '" << t << "'");
@@ -833,7 +823,16 @@ MatchStringAdv::MatchStringAdv(lyx::Buffer & buf, FindAndReplaceOptions const &
 	close_wildcards = 0;
 
 	size_t lead_size = 0;
-	if (!opt.ignoreformat) {
+	if (opt.ignoreformat) {
+                if (!use_regexp) {
+                        // if par_as_string_nolead were emty, 
+                        // the following call to findAux will always *find* the string
+                        // in the checked data, and thus always using the slow
+                        // examining of the current text part.
+                        par_as_string_nolead = par_as_string;
+                }
+        }
+        else {
 		lead_size = identifyLeading(par_as_string);
 		lead_as_string = par_as_string.substr(0, lead_size);
 		par_as_string_nolead = par_as_string.substr(lead_size, par_as_string.size() - lead_size);
@@ -888,6 +887,9 @@ MatchStringAdv::MatchStringAdv(lyx::Buffer & buf, FindAndReplaceOptions const &
 
 int MatchStringAdv::findAux(DocIterator const & cur, int len, bool at_begin) const
 {
+	if (at_begin &&
+		(opt.restr == FindAndReplaceOptions::R_ONLY_MATHS && !cur.inMathed()) )
+		return 0;
 	docstring docstr = stringifyFromForSearch(opt, cur, len);
 	LYXERR(Debug::FIND, "Matching against     '" << lyx::to_utf8(docstr) << "'");
 	string str = normalize(docstr, true);
@@ -1016,7 +1018,9 @@ docstring stringifyFromCursor(DocIterator const & cur, int len)
 		runparams.dryrun = true;
 		LYXERR(Debug::FIND, "Stringifying with cur: "
 		       << cur << ", from pos: " << cur.pos() << ", end: " << end);
-		return par.stringify(cur.pos(), end, AS_STR_INSETS, runparams);
+		return par.asString(cur.pos(), end,
+			AS_STR_INSETS | AS_STR_SKIPDELETE | AS_STR_PLAINTEXT,
+			&runparams);
 	} else if (cur.inMathed()) {
 		docstring s;
 		CursorSlice cs = cur.top();
@@ -1046,7 +1050,7 @@ docstring latexifyFromCursor(DocIterator const & cur, int len)
 	LYXERR(Debug::FIND, "  with cur.lastpost=" << cur.lastpos() << ", cur.lastrow="
 	       << cur.lastrow() << ", cur.lastcol=" << cur.lastcol());
 	Buffer const & buf = *cur.buffer();
-	LASSERT(buf.params().isLatex(), /* */);
+	LBUFERR(buf.params().isLatex());
 
 	TexRow texrow;
 	odocstringstream ods;
@@ -1123,7 +1127,7 @@ int findAdvFinalize(DocIterator & cur, MatchStringAdv const & match)
 		cur.forwardPos();
 	} while (cur && cur.depth() > d && match(cur) > 0);
 	cur = old_cur;
-	LASSERT(match(cur) > 0, /* */);
+	LASSERT(match(cur) > 0, return 0);
 	LYXERR(Debug::FIND, "Ok");
 
 	// Compute the match length
@@ -1211,7 +1215,8 @@ int findMostBackwards(DocIterator & cur, MatchStringAdv const & match)
 
 
 /// Finds backwards
-int findBackwardsAdv(DocIterator & cur, MatchStringAdv & match) {
+int findBackwardsAdv(DocIterator & cur, MatchStringAdv & match)
+{
 	if (! cur)
 		return 0;
 	// Backup of original position
@@ -1266,7 +1271,8 @@ int findBackwardsAdv(DocIterator & cur, MatchStringAdv & match) {
 docstring stringifyFromForSearch(FindAndReplaceOptions const & opt,
 				 DocIterator const & cur, int len)
 {
-	LASSERT(cur.pos() >= 0 && cur.pos() <= cur.lastpos(), /* */);
+	LASSERT(cur.pos() >= 0 && cur.pos() <= cur.lastpos(),
+	        return docstring());
 	if (!opt.ignoreformat)
 		return latexifyFromCursor(cur, len);
 	else
@@ -1278,10 +1284,10 @@ FindAndReplaceOptions::FindAndReplaceOptions(
 	docstring const & find_buf_name, bool casesensitive,
 	bool matchword, bool forward, bool expandmacros, bool ignoreformat,
 	docstring const & repl_buf_name, bool keep_case,
-	SearchScope scope)
+	SearchScope scope, SearchRestriction restr)
 	: find_buf_name(find_buf_name), casesensitive(casesensitive), matchword(matchword),
 	  forward(forward), expandmacros(expandmacros), ignoreformat(ignoreformat),
-	  repl_buf_name(repl_buf_name), keep_case(keep_case), scope(scope)
+	  repl_buf_name(repl_buf_name), keep_case(keep_case), scope(scope), restr(restr)
 {
 }
 
@@ -1290,9 +1296,15 @@ namespace {
 
 
 /** Check if 'len' letters following cursor are all non-lowercase */
-static bool allNonLowercase(DocIterator const & cur, int len) {
-	pos_type end_pos = cur.pos() + len;
-	for (pos_type pos = cur.pos(); pos != end_pos; ++pos)
+static bool allNonLowercase(Cursor const & cur, int len)
+{
+	pos_type beg_pos = cur.selectionBegin().pos();
+	pos_type end_pos = cur.selectionBegin().pos() + len;
+	if (len > cur.lastpos() + 1 - beg_pos) {
+		LYXERR(Debug::FIND, "This should not happen, more debug needed");
+		len = cur.lastpos() + 1 - beg_pos;
+	}
+	for (pos_type pos = beg_pos; pos != end_pos; ++pos)
 		if (isLowerCase(cur.paragraph().getChar(pos)))
 			return false;
 	return true;
@@ -1300,14 +1312,16 @@ static bool allNonLowercase(DocIterator const & cur, int len) {
 
 
 /** Check if first letter is upper case and second one is lower case */
-static bool firstUppercase(DocIterator const & cur) {
+static bool firstUppercase(Cursor const & cur)
+{
 	char_type ch1, ch2;
-	if (cur.pos() >= cur.lastpos() - 1) {
+	pos_type pos = cur.selectionBegin().pos();
+	if (pos >= cur.lastpos() - 1) {
 		LYXERR(Debug::FIND, "No upper-case at cur: " << cur);
 		return false;
 	}
-	ch1 = cur.paragraph().getChar(cur.pos());
-	ch2 = cur.paragraph().getChar(cur.pos()+1);
+	ch1 = cur.paragraph().getChar(pos);
+	ch2 = cur.paragraph().getChar(pos + 1);
 	bool result = isUpperCase(ch1) && isLowerCase(ch2);
 	LYXERR(Debug::FIND, "firstUppercase(): "
 	       << "ch1=" << ch1 << "(" << char(ch1) << "), ch2=" 
@@ -1321,13 +1335,16 @@ static bool firstUppercase(DocIterator const & cur) {
  **
  ** \fixme What to do with possible further paragraphs in replace buffer ?
  **/
-static void changeFirstCase(Buffer & buffer, TextCase first_case, TextCase others_case) {
+static void changeFirstCase(Buffer & buffer, TextCase first_case, TextCase others_case)
+{
 	ParagraphList::iterator pit = buffer.paragraphs().begin();
+	LASSERT(pit->size() >= 1, /**/);
 	pos_type right = pos_type(1);
 	pit->changeCase(buffer.params(), pos_type(0), right, first_case);
-	right = pit->size() + 1;
-	pit->changeCase(buffer.params(), right, right, others_case);
+	right = pit->size();
+	pit->changeCase(buffer.params(), pos_type(1), right, others_case);
 }
+
 } // anon namespace
 
 ///
@@ -1340,14 +1357,15 @@ static void findAdvReplace(BufferView * bv, FindAndReplaceOptions const & opt, M
 	DocIterator sel_beg = cur.selectionBegin();
 	DocIterator sel_end = cur.selectionEnd();
 	if (&sel_beg.inset() != &sel_end.inset()
-	    || sel_beg.pit() != sel_end.pit())
+	    || sel_beg.pit() != sel_end.pit()
+	    || sel_beg.idx() != sel_end.idx())
 		return;
 	int sel_len = sel_end.pos() - sel_beg.pos();
 	LYXERR(Debug::FIND, "sel_beg: " << sel_beg << ", sel_end: " << sel_end
 	       << ", sel_len: " << sel_len << endl);
 	if (sel_len == 0)
 		return;
-	LASSERT(sel_len > 0, /**/);
+	LASSERT(sel_len > 0, return);
 
 	if (!matchAdv(sel_beg, sel_len))
 		return;
@@ -1359,8 +1377,9 @@ static void findAdvReplace(BufferView * bv, FindAndReplaceOptions const & opt, M
 	string lyx = oss.str();
 	Buffer repl_buffer("", false);
 	repl_buffer.setUnnamed(true);
-	LASSERT(repl_buffer.readString(lyx), /**/);
+	LASSERT(repl_buffer.readString(lyx), return);
 	if (opt.keep_case && sel_len >= 2) {
+		LYXERR(Debug::FIND, "keep_case true: cur.pos()=" << cur.pos() << ", sel_len=" << sel_len);
 		if (cur.inTexted()) {
 			if (firstUppercase(cur))
 				changeFirstCase(repl_buffer, text_uppercase, text_lowercase);
@@ -1423,6 +1442,9 @@ bool findAdv(BufferView * bv, FindAndReplaceOptions const & opt)
 
 	try {
 		MatchStringAdv matchAdv(bv->buffer(), opt);
+		int length = bv->cursor().selectionEnd().pos() - bv->cursor().selectionBegin().pos();
+		if (length > 0)
+			bv->putSelectionAt(bv->cursor().selectionBegin(), length, !opt.forward);
 		findAdvReplace(bv, opt, matchAdv);
 		cur = bv->cursor();
 		if (opt.forward)
@@ -1459,7 +1481,8 @@ ostringstream & operator<<(ostringstream & os, FindAndReplaceOptions const & opt
 	   << opt.ignoreformat << ' '
 	   << to_utf8(opt.repl_buf_name) << "\nEOSS\n"
 	   << opt.keep_case << ' '
-	   << int(opt.scope);
+	   << int(opt.scope) << ' '
+	   << int(opt.restr);
 
 	LYXERR(Debug::FIND, "built: " << os.str());
 
@@ -1501,8 +1524,12 @@ istringstream & operator>>(istringstream & is, FindAndReplaceOptions & opt)
 	int i;
 	is >> i;
 	opt.scope = FindAndReplaceOptions::SearchScope(i);
+	is >> i;
+	opt.restr = FindAndReplaceOptions::SearchRestriction(i);
+
 	LYXERR(Debug::FIND, "parsed: " << opt.casesensitive << ' ' << opt.matchword << ' ' << opt.forward << ' '
-	       << opt.expandmacros << ' ' << opt.ignoreformat << ' ' << opt.keep_case);
+	       << opt.expandmacros << ' ' << opt.ignoreformat << ' ' << opt.keep_case << ' '
+	       << opt.scope << ' ' << opt.restr);
 	return is;
 }