X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyxfind.cpp;h=409a2e2cf7f2a1bf8d24fbf5725d111dd2311a0a;hb=d866717ef7503a1373dd1cb3925e1ac97b079192;hp=c5adc57dd030b2d431b450b6685756f969b22455;hpb=97b82d285d5e9e007c075f15894b86fd13586714;p=lyx.git diff --git a/src/lyxfind.cpp b/src/lyxfind.cpp index c5adc57dd0..409a2e2cf7 100644 --- a/src/lyxfind.cpp +++ b/src/lyxfind.cpp @@ -33,6 +33,7 @@ #include "TexRow.h" #include "Text.h" +#include "frontends/Application.h" #include "frontends/alert.h" #include "mathed/InsetMath.h" @@ -67,7 +68,7 @@ bool parse_bool(docstring & howto) } -class MatchString : public binary_function +class MatchString : public binary_function { public: MatchString(docstring const & str, bool cs, bool mw) @@ -76,7 +77,7 @@ public: // returns true if the specified string is at the specified position // del specifies whether deleted strings in ct mode will be considered - bool operator()(Paragraph const & par, pos_type pos, bool del = true) const + int operator()(Paragraph const & par, pos_type pos, bool del = true) const { return par.find(str, case_sens, whole_words, pos, del); } @@ -91,27 +92,31 @@ private: }; -bool findForward(DocIterator & cur, MatchString const & match, +int findForward(DocIterator & cur, MatchString const & match, bool find_del = true) { for (; cur; cur.forwardChar()) - if (cur.inTexted() && - match(cur.paragraph(), cur.pos(), find_del)) - return true; - return false; + if (cur.inTexted()) { + int len = match(cur.paragraph(), cur.pos(), find_del); + if (len > 0) + return len; + } + return 0; } -bool findBackwards(DocIterator & cur, MatchString const & match, +int findBackwards(DocIterator & cur, MatchString const & match, bool find_del = true) { while (cur) { cur.backwardChar(); - if (cur.inTexted() && - match(cur.paragraph(), cur.pos(), find_del)) - return true; + if (cur.inTexted()) { + int len = match(cur.paragraph(), cur.pos(), find_del); + if (len > 0) + return len; + } } - return false; + return 0; } @@ -152,13 +157,13 @@ bool findOne(BufferView * bv, docstring const & searchstr, MatchString const match(searchstr, case_sens, whole); - bool found = forward ? findForward(cur, match, find_del) : + int match_len = forward ? findForward(cur, match, find_del) : findBackwards(cur, match, find_del); - if (found) - bv->putSelectionAt(cur, searchstr.length(), !forward); + if (match_len > 0) + bv->putSelectionAt(cur, match_len, !forward); - return found; + return match_len > 0; } @@ -181,12 +186,13 @@ int replaceAll(BufferView * bv, Cursor cur(*bv); cur.setCursor(doc_iterator_begin(&buf)); - while (findForward(cur, match, false)) { + int match_len = findForward(cur, match, false); + while (match_len > 0) { // Backup current cursor position and font. pos_type const pos = cur.pos(); Font const font = cur.paragraph().getFontSettings(buf.params(), pos); cur.recordUndo(); - int striked = ssize - cur.paragraph().eraseChars(pos, pos + ssize, + int striked = ssize - cur.paragraph().eraseChars(pos, pos + match_len, buf.params().trackChanges); cur.paragraph().insert(pos, replacestr, font, Change(buf.params().trackChanges ? @@ -194,11 +200,10 @@ int replaceAll(BufferView * bv, for (int i = 0; i < rsize + striked; ++i) cur.forwardChar(); ++num; + match_len = findForward(cur, match, false); } bv->putSelectionAt(doc_iterator_begin(&buf), 0, false); - if (num) - buf.markDirty(); cur_orig.fixIfBroken(); bv->setCursor(cur_orig); @@ -236,7 +241,7 @@ pair replaceOne(BufferView * bv, docstring searchstr, // empty search string if (!cur.inTexted()) // bail in math - return pair(0, false); + return pair(false, 0); // select current word and treat it as the search string cur.innerText()->selectWord(cur, WHOLE_WORD); searchstr = cur.selectionAsString(false); @@ -266,7 +271,13 @@ pair replaceOne(BufferView * bv, docstring searchstr, return pair(false, 0); cap::replaceSelectionWithString(cur, replacestr, forward); - bv->buffer().markDirty(); + if (forward) { + cur.pos() += replacestr.length(); + LASSERT(cur.pos() <= cur.lastpos(), /* */); + } else { + cur.pos() -= replacestr.length(); + LASSERT(cur.pos() >= 0, /* */); + } findOne(bv, searchstr, case_sens, whole, forward, false); return pair(true, 1); @@ -699,17 +710,81 @@ private: // number of (.*?) subexpressions added at end of search regexp for closing // environments, math mode, styles, etc... int close_wildcards; + // Are we searching with regular expressions ? + bool use_regexp; }; +static docstring buffer_to_latex(Buffer & buffer) +{ + OutputParams runparams(&buffer.params().encoding()); + TexRow texrow; + odocstringstream ods; + otexstream os(ods, texrow); + runparams.nice = true; + runparams.flavor = OutputParams::LATEX; + runparams.linelen = 80; //lyxrc.plaintext_linelen; + // No side effect of file copying and image conversion + runparams.dryrun = true; + pit_type const endpit = buffer.paragraphs().size(); + for (pit_type pit = 0; pit != endpit; ++pit) { + TeXOnePar(buffer, buffer.text(), pit, os, runparams); + LYXERR(Debug::FIND, "searchString up to here: " << ods.str()); + } + return ods.str(); +} + + +static docstring stringifySearchBuffer(Buffer & buffer, FindAndReplaceOptions const & opt) { + docstring str; + if (!opt.ignoreformat) { + str = buffer_to_latex(buffer); + } else { + ParIterator it = buffer.par_iterator_begin(); + ParIterator end = buffer.par_iterator_end(); + OutputParams runparams(&buffer.params().encoding()); + odocstringstream os; + runparams.nice = true; + runparams.flavor = OutputParams::LATEX; + runparams.linelen = 100000; //lyxrc.plaintext_linelen; + runparams.dryrun = true; + for (; it != end; ++it) { + LYXERR(Debug::FIND, "Adding to search string: '" + << it->asString(false) + << "'"); + str += + it->stringify(pos_type(0), it->size(), + AS_STR_INSETS, runparams); + } + } + return str; +} + + +/// Return separation pos between the leading material and the rest +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)\\{", "") + || regex_replace(t, t, "^\\$", "") + || regex_replace(t, t, "^\\\\\\[ ", "") + || regex_replace(t, t, "^\\\\item ", "")) + LYXERR(Debug::FIND, " after removing leading $, \\[ , \\emph{, \\textbf{, etc.: " << t); + return s.find(t); +} + + MatchStringAdv::MatchStringAdv(lyx::Buffer & buf, FindAndReplaceOptions const & opt) : p_buf(&buf), p_first_buf(&buf), opt(opt) { - par_as_string = normalize(opt.search); + Buffer & find_buf = *theBufferList().getBuffer(FileName(to_utf8(opt.find_buf_name)), true); + par_as_string = normalize(stringifySearchBuffer(find_buf, opt)); open_braces = 0; close_wildcards = 0; - if (! opt.regexp) { + use_regexp = !opt.ignoreformat || par_as_string.find("\\regexp") != std::string::npos; + + if (!use_regexp) { // Remove trailing closure of math, macros and environments, so to catch parts of them. do { LYXERR(Debug::FIND, "par_as_string now is '" << par_as_string << "'"); @@ -731,6 +806,14 @@ MatchStringAdv::MatchStringAdv(lyx::Buffer & buf, FindAndReplaceOptions const & LYXERR(Debug::FIND, "Open braces: " << open_braces); LYXERR(Debug::FIND, "Built MatchStringAdv object: par_as_string = '" << par_as_string << "'"); } else { + size_t lead_size = identifyLeading(par_as_string); + string lead_as_regexp; + if (lead_size > 0) { + lead_as_regexp = escape_for_regex(par_as_string.substr(0, lead_size)); + par_as_string = par_as_string.substr(lead_size, par_as_string.size() - lead_size); + LYXERR(Debug::FIND, "lead_as_regexp is '" << lead_as_regexp << "'"); + LYXERR(Debug::FIND, "par_as_string now is '" << par_as_string << "'"); + } par_as_string = escape_for_regex(par_as_string); // Insert (.*?) before trailing closure of math, macros and environments, so to catch parts of them. LYXERR(Debug::FIND, "par_as_string now is '" << par_as_string << "'"); @@ -752,9 +835,14 @@ MatchStringAdv::MatchStringAdv(lyx::Buffer & buf, FindAndReplaceOptions const & LYXERR(Debug::FIND, "Close .*? : " << close_wildcards); LYXERR(Debug::FIND, "Replaced text (to be used as regex): " << par_as_string); // If entered regexp must match at begin of searched string buffer - regexp = lyx::regex(string("\\`") + par_as_string); + string regexp_str = string("\\`") + lead_as_regexp + par_as_string; + LYXERR(Debug::FIND, "Setting regexp to : " << regexp_str << endl); + regexp = lyx::regex(regexp_str); + // If entered regexp may match wherever in searched string buffer - regexp2 = lyx::regex(string("\\`.*") + par_as_string); + string regexp2_str = string("\\`.*") + lead_as_regexp + ".*" + par_as_string; + LYXERR(Debug::FIND, "Setting regexp2 to: " << regexp2_str << endl); + regexp2 = lyx::regex(regexp2_str); } } @@ -765,16 +853,24 @@ int MatchStringAdv::findAux(DocIterator const & cur, int len, bool at_begin) con LYXERR(Debug::FIND, "Matching against '" << lyx::to_utf8(docstr) << "'"); string str = normalize(docstr); LYXERR(Debug::FIND, "After normalization: '" << str << "'"); - if (! opt.regexp) { + if (! use_regexp) { + LYXERR(Debug::FIND, "Searching in normal mode: par_as_string='" << par_as_string << "', str='" << str << "'"); if (at_begin) { + LYXERR(Debug::FIND, "size=" << par_as_string.size() << ", substr='" << str.substr(0, par_as_string.size()) << "'"); if (str.substr(0, par_as_string.size()) == par_as_string) return par_as_string.size(); } else { - size_t pos = str.find(par_as_string); + string t = par_as_string; + while (regex_replace(t, t, "\\\\(emph|textbf|subsubsection|subsection|section|subparagraph|paragraph|part)\\{", "") + || regex_replace(t, t, "^\\$", "") + || regex_replace(t, t, "^\\\\\\[ ", "")) + LYXERR(Debug::FIND, " after removing leading $, \\[ , \\emph{, \\textbf{, etc.: " << t); + size_t pos = str.find(t); if (pos != string::npos) return par_as_string.size(); } } else { + LYXERR(Debug::FIND, "Searching in regexp mode: at_begin=" << at_begin); // Try all possible regexp matches, //until one that verifies the braces match test is found regex const *p_regexp = at_begin ? ®exp : ®exp2; @@ -784,11 +880,11 @@ int MatchStringAdv::findAux(DocIterator const & cur, int len, bool at_begin) con match_results const & m = *re_it; // Check braces on the segment that matched the entire regexp expression, // plus the last subexpression, if a (.*?) was inserted in the constructor. - if (! braces_match(m[0].first, m[0].second, open_braces)) + if (!braces_match(m[0].first, m[0].second, open_braces)) return 0; // Check braces on segments that matched all (.*?) subexpressions. for (size_t i = 1; i < m.size(); ++i) - if (! braces_match(m[i].first, m[i].second)) + if (!braces_match(m[i].first, m[i].second)) return false; // Exclude from the returned match length any length // due to close wildcards added at end of regexp @@ -805,6 +901,8 @@ int MatchStringAdv::findAux(DocIterator const & cur, int len, bool at_begin) con int MatchStringAdv::operator()(DocIterator const & cur, int len, bool at_begin) const { int res = findAux(cur, len, at_begin); + LYXERR(Debug::FIND, + "res=" << res << ", at_begin=" << at_begin << ", matchword=" << opt.matchword << ", inTexted=" << cur.inTexted()); if (res == 0 || !at_begin || !opt.matchword || !cur.inTexted()) return res; Paragraph const & par = cur.paragraph(); @@ -841,7 +939,7 @@ string MatchStringAdv::normalize(docstring const & s) const t.replace(pos, 1, " "); // Remove stale empty \emph{}, \textbf{} and similar blocks from latexify LYXERR(Debug::FIND, "Removing stale empty \\emph{}, \\textbf{}, \\*section{} macros from: " << t); - while (regex_replace(t, t, "\\\\(emph|textbf|subsubsection|subsection|section|subparagraph|paragraph)(\\{\\})+", "")) + while (regex_replace(t, t, "\\\\(emph|textbf|subsubsection|subsection|section|subparagraph|paragraph|part)(\\{\\})+", "")) LYXERR(Debug::FIND, " further removing stale empty \\emph{}, \\textbf{} macros from: " << t); return t; } @@ -896,6 +994,7 @@ docstring latexifyFromCursor(DocIterator const & cur, int len) TexRow texrow; odocstringstream ods; + otexstream os(ods, texrow); OutputParams runparams(&buf.params().encoding()); runparams.nice = false; runparams.flavor = OutputParams::LATEX; @@ -904,14 +1003,12 @@ docstring latexifyFromCursor(DocIterator const & cur, int len) runparams.dryrun = true; if (cur.inTexted()) { - // @TODO what about searching beyond/across paragraph breaks ? - ParagraphList::const_iterator pit = cur.innerText()->paragraphs().begin(); - for (int i = 0; i < cur.pit(); ++i) - ++pit; - pos_type const endpos = (len == -1 || cur.pos() + len > int(pit->size())) - ? pit->size() : cur.pos() + len; - TeXOnePar(buf, *cur.innerText(), pit, ods, texrow, runparams, string(), - cur.pos(), endpos); + // @TODO what about searching beyond/across paragraph breaks ? + pos_type endpos = cur.paragraph().size(); + if (len != -1 && endpos > cur.pos() + len) + endpos = cur.pos() + len; + TeXOnePar(buf, *cur.innerText(), cur.pit(), os, runparams, + string(), cur.pos(), endpos); LYXERR(Debug::FIND, "Latexified text: '" << lyx::to_utf8(ods.str()) << "'"); } else if (cur.inMathed()) { // Retrieve the math environment type, and add '$' or '$[' or others (\begin{equation}) accordingly @@ -997,17 +1094,32 @@ int findForwardAdv(DocIterator & cur, MatchStringAdv & match) { if (!cur) return 0; - while (cur && !match(cur, -1, false)) { - if (cur.pit() < cur.lastpit()) + while (cur) { + LYXERR(Debug::FIND, "findForwardAdv() cur: " << cur); + if (match(cur, -1, false)) { + for (; cur; cur.forwardPos()) { + LYXERR(Debug::FIND, "Advancing cur: " << cur); + if (match(cur)) { + // Sometimes in finalize we understand it wasn't a match + // and we need to continue the outest loop + int len = findAdvFinalize(cur, match); + if (len > 0) + return len; + } + } + if (!cur) + return 0; + } + if (cur.pit() < cur.lastpit()) { + LYXERR(Debug::FIND, "Advancing par: cur=" << cur); cur.forwardPar(); - else { + } else { + // This should exit nested insets, if any, or otherwise undefine the currsor. + cur.pos() = cur.lastpos(); + LYXERR(Debug::FIND, "Advancing pos: cur=" << cur); cur.forwardPos(); } } - for (; cur; cur.forwardPos()) { - if (match(cur)) - return findAdvFinalize(cur, match); - } return 0; } @@ -1091,6 +1203,7 @@ int findBackwardsAdv(DocIterator & cur, MatchStringAdv & match) { docstring stringifyFromForSearch(FindAndReplaceOptions const & opt, DocIterator const & cur, int len) { + LASSERT(cur.pos() >= 0 && cur.pos() <= cur.lastpos(), /* */); if (!opt.ignoreformat) return latexifyFromCursor(cur, len); else @@ -1098,13 +1211,13 @@ docstring stringifyFromForSearch(FindAndReplaceOptions const & opt, } -FindAndReplaceOptions::FindAndReplaceOptions(docstring const & search, bool casesensitive, +FindAndReplaceOptions::FindAndReplaceOptions(docstring const & find_buf_name, bool casesensitive, bool matchword, bool forward, bool expandmacros, bool ignoreformat, - bool regexp, docstring const & replace, bool keep_case, + docstring const & repl_buf_name, bool keep_case, SearchScope scope) - : search(search), casesensitive(casesensitive), matchword(matchword), + : find_buf_name(find_buf_name), casesensitive(casesensitive), matchword(matchword), forward(forward), expandmacros(expandmacros), ignoreformat(ignoreformat), - regexp(regexp), replace(replace), keep_case(keep_case), scope(scope) + repl_buf_name(repl_buf_name), keep_case(keep_case), scope(scope) { } @@ -1157,8 +1270,9 @@ static void changeFirstCase(Buffer & buffer, TextCase first_case, TextCase other static void findAdvReplace(BufferView * bv, FindAndReplaceOptions const & opt, MatchStringAdv & matchAdv) { Cursor & cur = bv->cursor(); - if (opt.replace == docstring(from_utf8(LYX_FR_NULL_STRING))) + if (opt.repl_buf_name == docstring()) return; + DocIterator sel_beg = cur.selectionBegin(); DocIterator sel_end = cur.selectionEnd(); if (&sel_beg.inset() != &sel_end.inset() @@ -1174,15 +1288,14 @@ static void findAdvReplace(BufferView * bv, FindAndReplaceOptions const & opt, M if (!matchAdv(sel_beg, sel_len)) return; - string lyx = to_utf8(opt.replace); - // FIXME: Seems so stupid to me to rebuild a buffer here, - // when we already have one (replace_work_area_.buffer()) + // Build a copy of the replace buffer, adapted to the KeepCase option + Buffer & repl_buffer_orig = *theBufferList().getBuffer(FileName(to_utf8(opt.repl_buf_name)), true); + ostringstream oss; + repl_buffer_orig.write(oss); + string lyx = oss.str(); Buffer repl_buffer("", false); repl_buffer.setUnnamed(true); LASSERT(repl_buffer.readString(lyx), /**/); - repl_buffer.changeLanguage( - repl_buffer.language(), - cur.getFont().language()); if (opt.keep_case && sel_len >= 2) { if (cur.inTexted()) { if (firstUppercase(cur)) @@ -1193,20 +1306,26 @@ static void findAdvReplace(BufferView * bv, FindAndReplaceOptions const & opt, M } cap::cutSelection(cur, false, false); if (!cur.inMathed()) { + repl_buffer.changeLanguage( + repl_buffer.language(), + cur.getFont().language()); LYXERR(Debug::FIND, "Replacing by pasteParagraphList()ing repl_buffer"); + LYXERR(Debug::FIND, "Before pasteParagraphList() cur=" << cur << endl); cap::pasteParagraphList(cur, repl_buffer.paragraphs(), repl_buffer.params().documentClassPtr(), bv->buffer().errorList("Paste")); + LYXERR(Debug::FIND, "After pasteParagraphList() cur=" << cur << endl); + sel_len = repl_buffer.paragraphs().begin()->size(); } else { + TexRow texrow; odocstringstream ods; + otexstream os(ods, texrow); OutputParams runparams(&repl_buffer.params().encoding()); runparams.nice = false; runparams.flavor = OutputParams::LATEX; runparams.linelen = 8000; //lyxrc.plaintext_linelen; runparams.dryrun = true; - TexRow texrow; - TeXOnePar(repl_buffer, repl_buffer.text(), - repl_buffer.paragraphs().begin(), ods, texrow, runparams); + TeXOnePar(repl_buffer, repl_buffer.text(), 0, os, runparams); //repl_buffer.getSourceCode(ods, 0, repl_buffer.paragraphs().size(), false); docstring repl_latex = ods.str(); LYXERR(Debug::FIND, "Latexified replace_buffer: '" << repl_latex << "'"); @@ -1215,11 +1334,14 @@ static void findAdvReplace(BufferView * bv, FindAndReplaceOptions const & opt, M regex_replace(s, s, "\\\\\\[(.*)\\\\\\]", "$1"); repl_latex = from_utf8(s); LYXERR(Debug::FIND, "Replacing by niceInsert()ing latex: '" << repl_latex << "'"); - cur.niceInsert(repl_latex); + sel_len = cur.niceInsert(repl_latex); } - bv->buffer().markDirty(); - cur.pos() -= repl_buffer.paragraphs().begin()->size(); - bv->putSelectionAt(DocIterator(cur), repl_buffer.paragraphs().begin()->size(), !opt.forward); + cur.pos() -= sel_len; + if (cur.pos() < 0) + cur.pos() = 0; + LYXERR(Debug::FIND, "Putting selection at cur=" << cur << " with len: " << sel_len); + bv->putSelectionAt(DocIterator(cur), sel_len, !opt.forward); + bv->processUpdateFlags(Update::Force); } @@ -1227,12 +1349,7 @@ static void findAdvReplace(BufferView * bv, FindAndReplaceOptions const & opt, M bool findAdv(BufferView * bv, FindAndReplaceOptions const & opt) { DocIterator cur; - int match_len; - - if (opt.search.empty()) { - bv->message(_("Search text is empty!")); - return false; - } + int match_len = 0; try { MatchStringAdv matchAdv(bv->buffer(), opt); @@ -1264,14 +1381,13 @@ bool findAdv(BufferView * bv, FindAndReplaceOptions const & opt) ostringstream & operator<<(ostringstream & os, FindAndReplaceOptions const & opt) { - os << to_utf8(opt.search) << "\nEOSS\n" + os << to_utf8(opt.find_buf_name) << "\nEOSS\n" << opt.casesensitive << ' ' << opt.matchword << ' ' << opt.forward << ' ' << opt.expandmacros << ' ' << opt.ignoreformat << ' ' - << opt.regexp << ' ' - << to_utf8(opt.replace) << "\nEOSS\n" + << to_utf8(opt.repl_buf_name) << "\nEOSS\n" << opt.keep_case << ' ' << int(opt.scope); @@ -1280,6 +1396,7 @@ ostringstream & operator<<(ostringstream & os, FindAndReplaceOptions const & opt return os; } + istringstream & operator>>(istringstream & is, FindAndReplaceOptions & opt) { LYXERR(Debug::FIND, "parsing"); @@ -1294,9 +1411,9 @@ istringstream & operator>>(istringstream & is, FindAndReplaceOptions & opt) break; getline(is, line); } - LYXERR(Debug::FIND, "searching for: '" << s << "'"); - opt.search = from_utf8(s); - is >> opt.casesensitive >> opt.matchword >> opt.forward >> opt.expandmacros >> opt.ignoreformat >> opt.regexp; + LYXERR(Debug::FIND, "file_buf_name: '" << s << "'"); + opt.find_buf_name = from_utf8(s); + is >> opt.casesensitive >> opt.matchword >> opt.forward >> opt.expandmacros >> opt.ignoreformat; is.get(); // Waste space before replace string s = ""; getline(is, line); @@ -1308,14 +1425,14 @@ istringstream & operator>>(istringstream & is, FindAndReplaceOptions & opt) break; getline(is, line); } + LYXERR(Debug::FIND, "repl_buf_name: '" << s << "'"); + opt.repl_buf_name = from_utf8(s); is >> opt.keep_case; int i; is >> i; opt.scope = FindAndReplaceOptions::SearchScope(i); LYXERR(Debug::FIND, "parsed: " << opt.casesensitive << ' ' << opt.matchword << ' ' << opt.forward << ' ' - << opt.expandmacros << ' ' << opt.ignoreformat << ' ' << opt.regexp << ' ' << opt.keep_case); - LYXERR(Debug::FIND, "replacing with: '" << s << "'"); - opt.replace = from_utf8(s); + << opt.expandmacros << ' ' << opt.ignoreformat << ' ' << opt.keep_case); return is; }