X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyxfind.cpp;h=0e79172fe57af321fbb8e147e2b543642945dc76;hb=d6a93143ec2146210d79f58cac42f9608da86100;hp=bd4e04e860e9825fdd4b0961402b792bc979c69e;hpb=a9de2597ed8df035576e92053bcaac21af062c82;p=lyx.git diff --git a/src/lyxfind.cpp b/src/lyxfind.cpp index bd4e04e860..0e79172fe5 100644 --- a/src/lyxfind.cpp +++ b/src/lyxfind.cpp @@ -39,18 +39,19 @@ #include "mathed/InsetMath.h" #include "mathed/InsetMathGrid.h" #include "mathed/InsetMathHull.h" +#include "mathed/MathData.h" #include "mathed/MathStream.h" #include "mathed/MathSupport.h" #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" #include "support/regex.h" -#include using namespace std; using namespace lyx::support; @@ -94,7 +95,7 @@ private: int findForward(DocIterator & cur, MatchString const & match, - bool find_del = true) + bool find_del = true) { for (; cur; cur.forwardChar()) if (cur.inTexted()) { @@ -107,7 +108,7 @@ int findForward(DocIterator & cur, MatchString const & match, int findBackwards(DocIterator & cur, MatchString const & match, - bool find_del = true) + bool find_del = true) { while (cur) { cur.backwardChar(); @@ -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()) { @@ -149,20 +133,50 @@ bool searchAllowed(docstring const & str) bool findOne(BufferView * bv, docstring const & searchstr, - bool case_sens, bool whole, bool forward, bool find_del = true) + bool case_sens, bool whole, bool forward, + bool find_del = true, bool check_wrap = false) { 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); - int match_len = forward ? findForward(cur, match, find_del) : - findBackwards(cur, match, find_del); + int match_len = forward + ? findForward(cur, match, find_del) + : findBackwards(cur, match, find_del); if (match_len > 0) bv->putSelectionAt(cur, match_len, !forward); + else if (check_wrap) { + DocIterator cur_orig(bv->cursor()); + docstring q; + if (forward) + q = _("End of file reached while searching forward.\n" + "Continue searching from the beginning?"); + else + q = _("Beginning of file reached while searching backward.\n" + "Continue searching from the end?"); + int wrap_answer = frontend::Alert::prompt(_("Wrap search?"), + q, 0, 1, _("&Yes"), _("&No")); + if (wrap_answer == 0) { + if (forward) { + bv->cursor().clear(); + bv->cursor().push_back(CursorSlice(bv->buffer().inset())); + } else { + bv->cursor().setCursor(doc_iterator_end(&bv->buffer())); + bv->cursor().backwardPos(); + } + bv->clearSelection(); + if (findOne(bv, searchstr, case_sens, whole, forward, find_del, false)) + return true; + } + bv->cursor().setCursor(cur_orig); + return false; + } return match_len > 0; } @@ -193,11 +207,13 @@ int replaceAll(BufferView * bv, 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 + match_len, - buf.params().trackChanges); + int striked = ssize - + cur.paragraph().eraseChars(pos, pos + match_len, + buf.params().track_changes); cur.paragraph().insert(pos, replacestr, font, - Change(buf.params().trackChanges ? - Change::INSERTED : Change::UNCHANGED)); + Change(buf.params().track_changes + ? Change::INSERTED + : Change::UNCHANGED)); for (int i = 0; i < rsize + striked; ++i) cur.forwardChar(); ++num; @@ -214,79 +230,84 @@ int replaceAll(BufferView * bv, // the idea here is that we are going to replace the string that -// is selected IF it is the search string. +// is selected IF it is the search string. // if there is a selection, but it is not the search string, then // we basically ignore it. (FIXME We ought to replace only within // the selection.) // if there is no selection, then: // (i) if some search string has been provided, then we find it. // (think of how the dialog works when you hit "replace" the -// first time.) +// first time.) // (ii) if no search string has been provided, then we treat the // word the cursor is in as the search string. (why? i have no // idea.) but this only works in text? // -// returns the number of replacements made (one, if any) and +// returns the number of replacements made (one, if any) and // whether anything at all was done. pair replaceOne(BufferView * bv, docstring searchstr, - docstring const & replacestr, bool case_sens, - bool whole, bool forward, bool findnext) + docstring const & replacestr, bool case_sens, + bool whole, bool forward, bool findnext) { Cursor & cur = bv->cursor(); + bool found = false; if (!cur.selection()) { // no selection, non-empty search string: find it if (!searchstr.empty()) { - findOne(bv, searchstr, case_sens, whole, forward); - return pair(true, 0); + found = findOne(bv, searchstr, case_sens, whole, forward, true, findnext); + return make_pair(found, 0); } // empty search string if (!cur.inTexted()) // bail in math - return pair(false, 0); - // select current word and treat it as the search string + return make_pair(false, 0); + // 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); } - + // if we still don't have a search string, report the error // and abort. if (!searchAllowed(searchstr)) - return pair(false, 0); - + return make_pair(false, 0); + bool have_selection = cur.selection(); docstring const selected = cur.selectionAsString(false); - bool match = - case_sens ? searchstr == selected - : compare_no_case(searchstr, selected) == 0; + bool match = + case_sens + ? searchstr == selected + : compare_no_case(searchstr, selected) == 0; // no selection or current selection is not search word: // just find the search word if (!have_selection || !match) { - findOne(bv, searchstr, case_sens, whole, forward); - return pair(true, 0); + found = findOne(bv, searchstr, case_sens, whole, forward, true, findnext); + return make_pair(found, 0); } // we're now actually ready to replace. if the buffer is // read-only, we can't, though. if (bv->buffer().isReadonly()) - return pair(false, 0); + return make_pair(false, 0); 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); + findOne(bv, searchstr, case_sens, whole, forward, false, findnext); - return pair(true, 1); + return make_pair(true, 1); } -} // namespace anon +} // namespace docstring const find2string(docstring const & search, - bool casesensitive, bool matchword, bool forward) + bool casesensitive, bool matchword, bool forward) { odocstringstream ss; ss << search << '\n' @@ -298,8 +319,9 @@ docstring const find2string(docstring const & search, docstring const replace2string(docstring const & replace, - docstring const & search, bool casesensitive, bool matchword, - bool all, bool forward, bool findnext) + docstring const & search, + bool casesensitive, bool matchword, + bool all, bool forward, bool findnext) { odocstringstream ss; ss << replace << '\n' @@ -330,11 +352,11 @@ bool lyxfind(BufferView * bv, FuncRequest const & ev) bool matchword = parse_bool(howto); bool forward = parse_bool(howto); - return findOne(bv, search, casesensitive, matchword, forward); + return findOne(bv, search, casesensitive, matchword, forward, true, true); } -bool lyxreplace(BufferView * bv, +bool lyxreplace(BufferView * bv, FuncRequest const & ev, bool has_deleted) { if (!bv || ev.action() != LFUN_WORD_REPLACE) @@ -355,15 +377,15 @@ bool lyxreplace(BufferView * bv, bool forward = parse_bool(howto); bool findnext = howto.empty() ? true : parse_bool(howto); - int replace_count = 0; bool update = false; if (!has_deleted) { + int replace_count = 0; if (all) { replace_count = replaceAll(bv, search, rplc, casesensitive, matchword); update = replace_count > 0; } else { - pair rv = + pair rv = replaceOne(bv, search, rplc, casesensitive, matchword, forward, findnext); update = rv.first; replace_count = rv.second; @@ -372,14 +394,14 @@ 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.")); } else if (replace_count == 1) { buf.message(_("String has been replaced.")); } else { - docstring const str = + docstring const str = bformat(_("%1$d strings have been replaced."), replace_count); buf.message(str); } @@ -387,101 +409,129 @@ bool lyxreplace(BufferView * bv, } else if (findnext) { // if we have deleted characters, we do not replace at all, but // rather search for the next occurence - if (findOne(bv, search, casesensitive, matchword, forward)) + if (findOne(bv, search, casesensitive, matchword, forward, true, findnext)) update = true; else - bv->message(_("String not found!")); + bv->message(_("String not found.")); } return update; } -bool findNextChange(BufferView * bv) +bool findNextChange(BufferView * bv, Cursor & cur, bool const check_wrap) { - return findChange(bv, true); -} + for (; cur; cur.forwardPos()) + if (cur.inTexted() && cur.paragraph().isChanged(cur.pos())) + return true; + if (check_wrap) { + DocIterator cur_orig(bv->cursor()); + docstring q = _("End of file reached while searching forward.\n" + "Continue searching from the beginning?"); + int wrap_answer = frontend::Alert::prompt(_("Wrap search?"), + q, 0, 1, _("&Yes"), _("&No")); + if (wrap_answer == 0) { + bv->cursor().clear(); + bv->cursor().push_back(CursorSlice(bv->buffer().inset())); + bv->clearSelection(); + cur.setCursor(bv->cursor().selectionBegin()); + if (findNextChange(bv, cur, false)) + return true; + } + bv->cursor().setCursor(cur_orig); + } -bool findPreviousChange(BufferView * bv) -{ - return findChange(bv, false); + return false; } -bool findChange(BufferView * bv, bool next) +bool findPreviousChange(BufferView * bv, Cursor & cur, bool const check_wrap) { - 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(); + for (cur.backwardPos(); cur; cur.backwardPos()) { + if (cur.inTexted() && cur.paragraph().isChanged(cur.pos())) + return true; } - 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; + if (check_wrap) { + DocIterator cur_orig(bv->cursor()); + docstring q = _("Beginning of file reached while searching backward.\n" + "Continue searching from the end?"); + int wrap_answer = frontend::Alert::prompt(_("Wrap search?"), + q, 0, 1, _("&Yes"), _("&No")); + if (wrap_answer == 0) { + bv->cursor().setCursor(doc_iterator_end(&bv->buffer())); + bv->cursor().backwardPos(); + bv->clearSelection(); + cur.setCursor(bv->cursor().selectionBegin()); + if (findPreviousChange(bv, cur, false)) + return true; + } + bv->cursor().setCursor(cur_orig); } - if (!findChange(cur, next)) - return false; - - bv->cursor().setCursor(cur); - bv->cursor().resetAnchor(); + return false; +} - if (!next) - // take a step into the change - cur.backwardPos(); - Change orig_change = cur.paragraph().lookupChange(cur.pos()); +bool selectChange(Cursor & cur, bool forward) +{ + if (!cur.inTexted() || !cur.paragraph().isChanged(cur.pos())) + return false; + Change ch = cur.paragraph().lookupChange(cur.pos()); - 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; - } + 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; +} - // Now put cursor to end of selection: - bv->cursor().setCursor(cur); - bv->cursor().setSelection(); - if (search_both_sides) { - bv->cursor().setSelection(false); - findChange(bv, !next); - } +namespace { - return true; + +bool findChange(BufferView * bv, bool forward) +{ + Cursor cur(*bv); + cur.setCursor(forward ? bv->cursor().selectionEnd() + : bv->cursor().selectionBegin()); + forward ? findNextChange(bv, cur, true) : findPreviousChange(bv, cur, true); + return selectChange(cur, forward); +} + +} // namespace + +bool findNextChange(BufferView * bv) +{ + return findChange(bv, true); +} + + +bool findPreviousChange(BufferView * bv) +{ + return findChange(bv, false); } + + namespace { typedef vector > Escapes; @@ -490,53 +540,62 @@ typedef vector > Escapes; /// @note Beware of order Escapes const & get_regexp_escapes() { + typedef std::pair P; + static Escapes escape_map; if (escape_map.empty()) { - escape_map.push_back(pair("$", "\\$")); - escape_map.push_back(pair("{", "\\{")); - escape_map.push_back(pair("}", "\\}")); - escape_map.push_back(pair("[", "\\[")); - escape_map.push_back(pair("]", "\\]")); - escape_map.push_back(pair("(", "\\(")); - escape_map.push_back(pair(")", "\\)")); - escape_map.push_back(pair("+", "\\+")); - escape_map.push_back(pair("*", "\\*")); - escape_map.push_back(pair(".", "\\.")); - escape_map.push_back(pair("\\", "(?:\\\\|\\\\backslash)")); - escape_map.push_back(pair("~", "(?:\\\\textasciitilde|\\\\sim)")); - escape_map.push_back(pair("^", "(?:\\^|\\\\textasciicircum\\{\\}|\\\\mathcircumflex)")); + escape_map.push_back(P("$", "_x_$")); + escape_map.push_back(P("{", "_x_{")); + escape_map.push_back(P("}", "_x_}")); + escape_map.push_back(P("[", "_x_[")); + escape_map.push_back(P("]", "_x_]")); + escape_map.push_back(P("(", "_x_(")); + escape_map.push_back(P(")", "_x_)")); + escape_map.push_back(P("+", "_x_+")); + escape_map.push_back(P("*", "_x_*")); + escape_map.push_back(P(".", "_x_.")); + escape_map.push_back(P("\\", "(?:\\\\|\\\\backslash)")); + escape_map.push_back(P("~", "(?:\\\\textasciitilde|\\\\sim)")); + escape_map.push_back(P("^", "(?:\\^|\\\\textasciicircum\\{\\}|\\\\textasciicircum|\\\\mathcircumflex)")); + escape_map.push_back(P("_x_", "\\")); } return escape_map; } /// A map of lyx escaped strings and their unescaped equivalent. -Escapes const & get_lyx_unescapes() { +Escapes const & get_lyx_unescapes() +{ + typedef std::pair P; + static Escapes escape_map; if (escape_map.empty()) { - escape_map.push_back(pair("\\%", "%")); - escape_map.push_back(pair("\\mathcircumflex ", "^")); - escape_map.push_back(pair("\\mathcircumflex", "^")); - escape_map.push_back(pair("\\backslash ", "\\")); - escape_map.push_back(pair("\\backslash", "\\")); - escape_map.push_back(pair("\\\\{", "_x_<")); - escape_map.push_back(pair("\\\\}", "_x_>")); - escape_map.push_back(pair("\\sim ", "~")); - escape_map.push_back(pair("\\sim", "~")); + escape_map.push_back(P("\\%", "%")); + escape_map.push_back(P("\\mathcircumflex ", "^")); + escape_map.push_back(P("\\mathcircumflex", "^")); + escape_map.push_back(P("\\backslash ", "\\")); + escape_map.push_back(P("\\backslash", "\\")); + escape_map.push_back(P("\\\\{", "_x_<")); + escape_map.push_back(P("\\\\}", "_x_>")); + escape_map.push_back(P("\\sim ", "~")); + escape_map.push_back(P("\\sim", "~")); } return escape_map; } /// A map of escapes turning a regexp matching text to one matching latex. -Escapes const & get_regexp_latex_escapes() { +Escapes const & get_regexp_latex_escapes() +{ + typedef std::pair P; + static Escapes escape_map; if (escape_map.empty()) { - escape_map.push_back(pair("\\\\", "(?:\\\\\\\\|\\\\backslash|\\\\textbackslash\\{\\})")); - escape_map.push_back(pair("(("(("\\[", "\\{\\[\\}")); - escape_map.push_back(pair("\\]", "\\{\\]\\}")); - escape_map.push_back(pair("\\^", "(?:\\^|\\\\textasciicircum\\{\\}|\\\\mathcircumflex)")); - escape_map.push_back(pair("%", "\\\\\\%")); + escape_map.push_back(P("\\\\", "(?:\\\\\\\\|\\\\backslash|\\\\textbackslash\\{\\}|\\\\textbackslash)")); + escape_map.push_back(P("( it(oss); lyx::regex_replace(it, s.begin(), s.end(), e, replacestr); @@ -623,6 +682,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, @@ -655,8 +715,8 @@ bool braces_match(string::const_iterator const & beg, } } if (open_pars != unmatched) { - LYXERR(Debug::FIND, "Found " << open_pars - << " instead of " << unmatched + LYXERR(Debug::FIND, "Found " << open_pars + << " instead of " << unmatched << " unmatched open braces at the end of count"); return false; } @@ -664,6 +724,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 { @@ -728,12 +789,11 @@ private: }; -static docstring buffer_to_latex(Buffer & buffer) +static docstring buffer_to_latex(Buffer & buffer) { OutputParams runparams(&buffer.params().encoding()); - TexRow texrow; odocstringstream ods; - otexstream os(ods, texrow); + otexstream os(ods); runparams.nice = true; runparams.flavor = OutputParams::LATEX; runparams.linelen = 80; //lyxrc.plaintext_linelen; @@ -748,7 +808,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); @@ -758,14 +819,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) - << "'"); - str += 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.asString(pos_type(0), par.size(), + AS_STR_INSETS | AS_STR_SKIPDELETE | AS_STR_PLAINTEXT, + &runparams); } } return str; @@ -773,31 +837,33 @@ 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)\\*?\\{", "") - || regex_replace(t, t, "^\\$", "") - || regex_replace(t, t, "^\\\\\\[ ", "") - || regex_replace(t, t, "^\\\\item ", "") - || regex_replace(t, t, "^\\\\begin\\{[a-zA-Z_]*\\*?\\} ", "")) + while (regex_replace(t, t, REGEX_BOS "\\\\(emph|textbf|subsubsection|subsection|section|subparagraph|paragraph|part)\\*?\\{", "") + || regex_replace(t, t, REGEX_BOS "\\$", "") + || regex_replace(t, t, REGEX_BOS "\\\\\\[ ", "") + || regex_replace(t, t, REGEX_BOS "\\\\item ", "") + || regex_replace(t, t, REGEX_BOS "\\\\begin\\{[a-zA-Z_]*\\*?\\} ", "")) LYXERR(Debug::FIND, " after removing leading $, \\[ , \\emph{, \\textbf{, etc.: '" << t << "'"); return s.find(t); } // 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 << "'"); - if (regex_replace(t, t, "(.*[^\\\\])\\$\\'", "$1")) + if (regex_replace(t, t, "(.*[^\\\\])\\$" REGEX_EOS, "$1")) continue; - if (regex_replace(t, t, "(.*[^\\\\]) \\\\\\]\\'", "$1")) + if (regex_replace(t, t, "(.*[^\\\\]) \\\\\\]" REGEX_EOS, "$1")) continue; - if (regex_replace(t, t, "(.*[^\\\\]) \\\\end\\{[a-zA-Z_]*\\*?\\}\\'", "$1")) + if (regex_replace(t, t, "(.*[^\\\\]) \\\\end\\{[a-zA-Z_]*\\*?\\}" REGEX_EOS, "$1")) continue; - if (regex_replace(t, t, "(.*[^\\\\])\\}\\'", "$1")) { + if (regex_replace(t, t, "(.*[^\\\\])\\}" REGEX_EOS, "$1")) { ++open_braces; continue; } @@ -819,7 +885,15 @@ 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); @@ -845,27 +919,28 @@ MatchStringAdv::MatchStringAdv(lyx::Buffer & buf, FindAndReplaceOptions const & if ( // Insert .* before trailing '\$' ('$' has been escaped by escape_for_regex) regex_replace(par_as_string, par_as_string, "(.*[^\\\\])(\\\\\\$)\\'", "$1(.*?)$2") - // Insert .* before trailing '\\\]' ('\]' has been escaped by escape_for_regex) - || regex_replace(par_as_string, par_as_string, "(.*[^\\\\])( \\\\\\\\\\\\\\])\\'", "$1(.*?)$2") - // Insert .* before trailing '\\end\{...}' ('\end{...}' has been escaped by escape_for_regex) - || regex_replace(par_as_string, par_as_string, - "(.*[^\\\\])( \\\\\\\\end\\\\\\{[a-zA-Z_]*)(\\\\\\*)?(\\\\\\})\\'", "$1(.*?)$2$3$4") - // Insert .* before trailing '\}' ('}' has been escaped by escape_for_regex) - || regex_replace(par_as_string, par_as_string, "(.*[^\\\\])(\\\\\\})\\'", "$1(.*?)$2") - ) { + // Insert .* before trailing '\\\]' ('\]' has been escaped by escape_for_regex) + || regex_replace(par_as_string, par_as_string, "(.*[^\\\\])( \\\\\\\\\\\\\\])\\'", "$1(.*?)$2") + // Insert .* before trailing '\\end\{...}' ('\end{...}' has been escaped by escape_for_regex) + || regex_replace(par_as_string, par_as_string, + "(.*[^\\\\])( \\\\\\\\end\\\\\\{[a-zA-Z_]*)(\\\\\\*)?(\\\\\\})\\'", "$1(.*?)$2$3$4") + // Insert .* before trailing '\}' ('}' has been escaped by escape_for_regex) + || regex_replace(par_as_string, par_as_string, "(.*[^\\\\])(\\\\\\})\\'", "$1(.*?)$2") + ) { ++close_wildcards; } LYXERR(Debug::FIND, "par_as_string now is '" << par_as_string << "'"); LYXERR(Debug::FIND, "Open braces: " << open_braces); 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 - string regexp_str = string("\\`") + lead_as_regexp + par_as_string; + string regexp_str = lead_as_regexp + par_as_string; LYXERR(Debug::FIND, "Setting regexp to : '" << regexp_str << "'"); regexp = lyx::regex(regexp_str); // If entered regexp may match wherever in searched string buffer - string regexp2_str = string("\\`.*") + lead_as_regexp + ".*" + par_as_string; + string regexp2_str = lead_as_regexp + ".*" + par_as_string; LYXERR(Debug::FIND, "Setting regexp2 to: '" << regexp2_str << "'"); regexp2 = lyx::regex(regexp2_str); } @@ -874,47 +949,66 @@ 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); + LYXERR(Debug::FIND, "Matching against '" << lyx::to_utf8(docstr) << "'"); LYXERR(Debug::FIND, "After normalization: '" << str << "'"); - if (! use_regexp) { - LYXERR(Debug::FIND, "Searching in normal mode: par_as_string='" << par_as_string << "', str='" << str << "'"); - LYXERR(Debug::FIND, "Searching in normal mode: lead_as_string='" << lead_as_string << "', par_as_string_nolead='" << par_as_string_nolead << "'"); + + if (use_regexp) { + LYXERR(Debug::FIND, "Searching in regexp mode: at_begin=" << at_begin); + regex const *p_regexp; + regex_constants::match_flag_type flags; 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(); + flags = regex_constants::match_continuous; + p_regexp = ®exp; } else { - size_t pos = str.find(par_as_string_nolead); - if (pos != string::npos) - return par_as_string.size(); + flags = regex_constants::match_default; + p_regexp = ®exp2; } + sregex_iterator re_it(str.begin(), str.end(), *p_regexp, flags); + if (re_it == sregex_iterator()) + return 0; + 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)) + return 0; + + // Check braces on segments that matched all (.*?) subexpressions, + // except the last "padding" one inserted by lyx. + for (size_t i = 1; i < m.size() - 1; ++i) + 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 + if (close_wildcards == 0) + return m[0].second - m[0].first; + + return m[m.size() - close_wildcards].first - m[0].first; + } + + // else !use_regexp: but all code paths above return + LYXERR(Debug::FIND, "Searching in normal mode: par_as_string='" + << par_as_string << "', str='" << str << "'"); + LYXERR(Debug::FIND, "Searching in normal mode: lead_as_string='" + << lead_as_string << "', par_as_string_nolead='" + << par_as_string_nolead << "'"); + + 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 { - 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; - sregex_iterator re_it(str.begin(), str.end(), *p_regexp); - sregex_iterator re_it_end; - for (; re_it != re_it_end; ++re_it) { - 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)) - return 0; - // Check braces on segments that matched all (.*?) subexpressions, - // except the last "padding" one inserted by lyx. - for (size_t i = 1; i < m.size() - 1; ++i) - 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 - if (close_wildcards == 0) - return m[0].second - m[0].first; - else - return m[m.size() - close_wildcards].first - m[0].first; - } + size_t pos = str.find(par_as_string_nolead); + if (pos != string::npos) + return par_as_string.size(); } return 0; } @@ -924,14 +1018,18 @@ int MatchStringAdv::operator()(DocIterator const & cur, int len, bool at_begin) { int res = findAux(cur, len, at_begin); LYXERR(Debug::FIND, - "res=" << res << ", at_begin=" << at_begin << ", matchword=" << opt.matchword << ", inTexted=" << cur.inTexted()); + "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(); - bool ws_left = cur.pos() > 0 ? - par.isWordSeparator(cur.pos() - 1) : true; - bool ws_right = cur.pos() + res < par.size() ? - par.isWordSeparator(cur.pos() + res) : true; + bool ws_left = (cur.pos() > 0) + ? par.isWordSeparator(cur.pos() - 1) + : true; + bool ws_right = (cur.pos() + res < par.size()) + ? par.isWordSeparator(cur.pos() + res) + : true; LYXERR(Debug::FIND, "cur.pos()=" << cur.pos() << ", res=" << res << ", separ: " << ws_left << ", " << ws_right @@ -950,10 +1048,10 @@ string MatchStringAdv::normalize(docstring const & s, bool hack_braces) const else t = lyx::to_utf8(s); // Remove \n at begin - while (t.size() > 0 && t[0] == '\n') + while (!t.empty() && t[0] == '\n') t = t.substr(1); // Remove \n at end - while (t.size() > 0 && t[t.size() - 1] == '\n') + while (!t.empty() && t[t.size() - 1] == '\n') t = t.substr(0, t.size() - 1); size_t pos; // Replace all other \n with spaces @@ -984,32 +1082,35 @@ docstring stringifyFromCursor(DocIterator const & cur, int len) { LYXERR(Debug::FIND, "Stringifying with len=" << len << " from cursor at pos: " << cur); if (cur.inTexted()) { - Paragraph const & par = cur.paragraph(); - // TODO what about searching beyond/across paragraph breaks ? - // TODO Try adding a AS_STR_INSERTS as last arg - pos_type end = ( len == -1 || cur.pos() + len > int(par.size()) ) ? - int(par.size()) : cur.pos() + len; - OutputParams runparams(&cur.buffer()->params().encoding()); - odocstringstream os; - runparams.nice = true; - runparams.flavor = OutputParams::LATEX; - runparams.linelen = 100000; //lyxrc.plaintext_linelen; - // No side effect of file copying and image conversion - 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); + Paragraph const & par = cur.paragraph(); + // TODO what about searching beyond/across paragraph breaks ? + // TODO Try adding a AS_STR_INSERTS as last arg + pos_type end = ( len == -1 || cur.pos() + len > int(par.size()) ) ? + int(par.size()) : cur.pos() + len; + OutputParams runparams(&cur.buffer()->params().encoding()); + runparams.nice = true; + runparams.flavor = OutputParams::LATEX; + runparams.linelen = 100000; //lyxrc.plaintext_linelen; + // No side effect of file copying and image conversion + runparams.dryrun = true; + LYXERR(Debug::FIND, "Stringifying with cur: " + << cur << ", from pos: " << cur.pos() << ", end: " << end); + 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(); - MathData md = cs.cell(); - MathData::const_iterator it_end = - ( ( len == -1 || cs.pos() + len > int(md.size()) ) - ? md.end() : md.begin() + cs.pos() + len ); - for (MathData::const_iterator it = md.begin() + cs.pos(); it != it_end; ++it) - s = s + asString(*it); - LYXERR(Debug::FIND, "Stringified math: '" << s << "'"); - return s; + docstring s; + CursorSlice cs = cur.top(); + MathData md = cs.cell(); + MathData::const_iterator it_end = + (( len == -1 || cs.pos() + len > int(md.size())) + ? md.end() + : md.begin() + cs.pos() + len ); + for (MathData::const_iterator it = md.begin() + cs.pos(); + it != it_end; ++it) + s = s + asString(*it); + LYXERR(Debug::FIND, "Stringified math: '" << s << "'"); + return s; } LYXERR(Debug::FIND, "Don't know how to stringify from here: " << cur); return docstring(); @@ -1024,13 +1125,11 @@ docstring latexifyFromCursor(DocIterator const & cur, int len) { LYXERR(Debug::FIND, "Latexifying with len=" << len << " from cursor at pos: " << cur); LYXERR(Debug::FIND, " with cur.lastpost=" << cur.lastpos() << ", cur.lastrow=" - << cur.lastrow() << ", cur.lastcol=" << cur.lastcol()); + << cur.lastrow() << ", cur.lastcol=" << cur.lastcol()); Buffer const & buf = *cur.buffer(); - LASSERT(buf.params().isLatex(), /* */); - TexRow texrow; odocstringstream ods; - otexstream os(ods, texrow); + otexstream os(ods); OutputParams runparams(&buf.params().encoding()); runparams.nice = false; runparams.flavor = OutputParams::LATEX; @@ -1044,33 +1143,36 @@ docstring latexifyFromCursor(DocIterator const & cur, int len) if (len != -1 && endpos > cur.pos() + len) endpos = cur.pos() + len; TeXOnePar(buf, *cur.innerText(), cur.pit(), os, runparams, - string(), cur.pos(), endpos); + 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 for (int s = cur.depth() - 1; s >= 0; --s) { - CursorSlice const & cs = cur[s]; - if (cs.asInsetMath() && cs.asInsetMath() && cs.asInsetMath()->asHullInset()) { - WriteStream ws(ods); - cs.asInsetMath()->asHullInset()->header_write(ws); - break; - } + CursorSlice const & cs = cur[s]; + if (cs.asInsetMath() && cs.asInsetMath()->asHullInset()) { + WriteStream ws(os); + cs.asInsetMath()->asHullInset()->header_write(ws); + break; + } } CursorSlice const & cs = cur.top(); MathData md = cs.cell(); - MathData::const_iterator it_end = ( ( len == -1 || cs.pos() + len > int(md.size()) ) - ? md.end() : md.begin() + cs.pos() + len ); - for (MathData::const_iterator it = md.begin() + cs.pos(); it != it_end; ++it) + MathData::const_iterator it_end = + ((len == -1 || cs.pos() + len > int(md.size())) + ? md.end() + : md.begin() + cs.pos() + len); + for (MathData::const_iterator it = md.begin() + cs.pos(); + it != it_end; ++it) ods << asString(*it); // Retrieve the math environment type, and add '$' or '$]' // or others (\end{equation}) accordingly for (int s = cur.depth() - 1; s >= 0; --s) { - CursorSlice const & cs = cur[s]; - InsetMath * inset = cs.asInsetMath(); + CursorSlice const & cs2 = cur[s]; + InsetMath * inset = cs2.asInsetMath(); if (inset && inset->asHullInset()) { - WriteStream ws(ods); + WriteStream ws(os); inset->asHullInset()->footer_write(ws); break; } @@ -1100,7 +1202,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 @@ -1137,9 +1239,9 @@ int findForwardAdv(DocIterator & cur, MatchStringAdv & match) if (match_len) { for (; !theApp()->longOperationCancelled() && cur; cur.forwardPos()) { LYXERR(Debug::FIND, "Advancing cur: " << cur); - int match_len = match(cur); - LYXERR(Debug::FIND, "match_len: " << match_len); - if (match_len) { + int match_len2 = match(cur); + LYXERR(Debug::FIND, "match_len: " << match_len2); + if (match_len2) { // Sometimes in finalize we understand it wasn't a match // and we need to continue the outest loop int len = findAdvFinalize(cur, match); @@ -1188,7 +1290,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 @@ -1197,12 +1300,10 @@ int findBackwardsAdv(DocIterator & cur, MatchStringAdv & match) { return 0; cur.backwardPos(); DocIterator cur_orig(cur); - bool found_match; bool pit_changed = false; - found_match = false; do { cur.pos() = 0; - found_match = match(cur, -1, false); + bool found_match = match(cur, -1, false); if (found_match) { if (pit_changed) @@ -1213,7 +1314,7 @@ int findBackwardsAdv(DocIterator & cur, MatchStringAdv & match) { DocIterator cur_prev_iter; do { found_match = match(cur); - LYXERR(Debug::FIND, "findBackAdv3: found_match=" + LYXERR(Debug::FIND, "findBackAdv3: found_match=" << found_match << ", cur: " << cur); if (found_match) return findMostBackwards(cur, match); @@ -1237,13 +1338,14 @@ int findBackwardsAdv(DocIterator & cur, MatchStringAdv & match) { } -} // anonym namespace +} // namespace docstring stringifyFromForSearch(FindAndReplaceOptions const & opt, - DocIterator const & cur, int len) + 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 @@ -1251,13 +1353,14 @@ docstring stringifyFromForSearch(FindAndReplaceOptions const & opt, } -FindAndReplaceOptions::FindAndReplaceOptions(docstring const & find_buf_name, bool casesensitive, +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) + forward(forward), expandmacros(expandmacros), ignoreformat(ignoreformat), + repl_buf_name(repl_buf_name), keep_case(keep_case), scope(scope), restr(restr) { } @@ -1266,9 +1369,16 @@ 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; + end_pos = beg_pos + len; + } + for (pos_type pos = beg_pos; pos != end_pos; ++pos) if (isLowerCase(cur.paragraph().getChar(pos))) return false; return true; @@ -1276,17 +1386,19 @@ 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=" + << "ch1=" << ch1 << "(" << char(ch1) << "), ch2=" << ch2 << "(" << char(ch2) << ")" << ", result=" << result << ", cur=" << cur); return result; @@ -1297,33 +1409,39 @@ 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 + +} // namespace /// static void findAdvReplace(BufferView * bv, FindAndReplaceOptions const & opt, MatchStringAdv & matchAdv) { Cursor & cur = bv->cursor(); - if (opt.repl_buf_name == docstring()) + if (opt.repl_buf_name == docstring() + || theBufferList().getBuffer(FileName(to_utf8(opt.repl_buf_name)), true) == 0 + || theBufferList().getBuffer(FileName(to_utf8(opt.find_buf_name)), true) == 0) return; 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; @@ -1335,8 +1453,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); @@ -1344,7 +1463,7 @@ static void findAdvReplace(BufferView * bv, FindAndReplaceOptions const & opt, M changeFirstCase(repl_buffer, text_uppercase, text_uppercase); } } - cap::cutSelection(cur, false, false); + cap::cutSelection(cur, false); if (cur.inTexted()) { repl_buffer.changeLanguage( repl_buffer.language(), @@ -1357,9 +1476,8 @@ static void findAdvReplace(BufferView * bv, FindAndReplaceOptions const & opt, M LYXERR(Debug::FIND, "After pasteParagraphList() cur=" << cur << endl); sel_len = repl_buffer.paragraphs().begin()->size(); } else if (cur.inMathed()) { - TexRow texrow; odocstringstream ods; - otexstream os(ods, texrow); + otexstream os(ods); OutputParams runparams(&repl_buffer.params().encoding()); runparams.nice = false; runparams.flavor = OutputParams::LATEX; @@ -1370,8 +1488,8 @@ static void findAdvReplace(BufferView * bv, FindAndReplaceOptions const & opt, M docstring repl_latex = ods.str(); LYXERR(Debug::FIND, "Latexified replace_buffer: '" << repl_latex << "'"); string s; - regex_replace(to_utf8(repl_latex), s, "\\$(.*)\\$", "$1"); - regex_replace(s, s, "\\\\\\[(.*)\\\\\\]", "$1"); + (void)regex_replace(to_utf8(repl_latex), s, "\\$(.*)\\$", "$1"); + (void)regex_replace(s, s, "\\\\\\[(.*)\\\\\\]", "$1"); repl_latex = from_utf8(s); LYXERR(Debug::FIND, "Replacing by insert()ing latex: '" << repl_latex << "' cur=" << cur << " with depth=" << cur.depth()); MathData ar(cur.buffer()); @@ -1387,7 +1505,6 @@ static void findAdvReplace(BufferView * bv, FindAndReplaceOptions const & opt, M LYXERR(Debug::FIND, "After pos adj cur=" << cur << " with depth: " << cur.depth() << " and len: " << sel_len); bv->putSelectionAt(DocIterator(cur), sel_len, !opt.forward); bv->processUpdateFlags(Update::Force); - bv->buffer().updatePreviews(); } @@ -1397,14 +1514,22 @@ bool findAdv(BufferView * bv, FindAndReplaceOptions const & opt) DocIterator cur; int match_len = 0; + // e.g., when invoking word-findadv from mini-buffer wither with + // wrong options syntax or before ever opening advanced F&R pane + if (theBufferList().getBuffer(FileName(to_utf8(opt.find_buf_name)), true) == 0) + return false; + 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) - match_len = findForwardAdv(cur, matchAdv); + match_len = findForwardAdv(cur, matchAdv); else - match_len = findBackwardsAdv(cur, matchAdv); + match_len = findBackwardsAdv(cur, matchAdv); } catch (...) { // This may only be raised by lyx::regex() bv->message(_("Invalid regular expression!")); @@ -1435,7 +1560,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()); @@ -1451,10 +1577,10 @@ istringstream & operator>>(istringstream & is, FindAndReplaceOptions & opt) getline(is, line); while (line != "EOSS") { if (! s.empty()) - s = s + "\n"; + s = s + "\n"; s = s + line; if (is.eof()) // Tolerate malformed request - break; + break; getline(is, line); } LYXERR(Debug::FIND, "file_buf_name: '" << s << "'"); @@ -1465,10 +1591,10 @@ istringstream & operator>>(istringstream & is, FindAndReplaceOptions & opt) getline(is, line); while (line != "EOSS") { if (! s.empty()) - s = s + "\n"; + s = s + "\n"; s = s + line; if (is.eof()) // Tolerate malformed request - break; + break; getline(is, line); } LYXERR(Debug::FIND, "repl_buf_name: '" << s << "'"); @@ -1477,9 +1603,13 @@ 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; } -} // lyx namespace +} // namespace lyx