X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyxfind.cpp;h=8b2c9343592c3ae952978a3de8194c20842810c0;hb=19bec6e8bc13c00c528392cb77826dc7de3f68e8;hp=278f81c26266bfd9754de36235590462b1e4338e;hpb=67503f8fe139acdf3ff8ce7c0b44cd81240767ac;p=lyx.git diff --git a/src/lyxfind.cpp b/src/lyxfind.cpp index 278f81c262..8b2c934359 100644 --- a/src/lyxfind.cpp +++ b/src/lyxfind.cpp @@ -117,10 +117,10 @@ bool findBackwards(DocIterator & cur, MatchString const & match, bool findChange(DocIterator & cur, bool next) { - if (!next) + if (!next) cur.backwardPos(); for (; cur; next ? cur.forwardPos() : cur.backwardPos()) - if (cur.inTexted() && !cur.paragraph().isUnchanged(cur.pos())) { + if (cur.inTexted() && cur.paragraph().isChanged(cur.pos())) { if (!next) // if we search backwards, take a step forward // to correctly set the anchor @@ -202,9 +202,17 @@ int replaceAll(BufferView * bv, } -bool stringSelected(BufferView * bv, docstring const & searchstr, +bool stringSelected(BufferView * bv, docstring & searchstr, bool cs, bool mw, bool fw) { + // if nothing selected and searched string is empty, this + // means that we want to search current word at cursor position. + if (!bv->cursor().selection() && searchstr.empty()) { + bv->cursor().innerText()->selectWord(bv->cursor(), WHOLE_WORD); + searchstr = bv->cursor().selectionAsString(false); + return true; + } + // if nothing selected or selection does not equal search // string search and select next occurance and return docstring const & str1 = searchstr; @@ -218,13 +226,13 @@ bool stringSelected(BufferView * bv, docstring const & searchstr, } -int replace(BufferView * bv, docstring const & searchstr, +int replace(BufferView * bv, docstring & searchstr, docstring const & replacestr, bool cs, bool mw, bool fw) { - if (!searchAllowed(bv, searchstr) || bv->buffer().isReadonly()) + if (!stringSelected(bv, searchstr, cs, mw, fw)) return 0; - if (!stringSelected(bv, searchstr, cs, mw, fw)) + if (!searchAllowed(bv, searchstr) || bv->buffer().isReadonly()) return 0; Cursor & cur = bv->cursor(); @@ -252,13 +260,13 @@ docstring const find2string(docstring const & search, } -docstring const replace2string(docstring const & search, docstring const & replace, - bool casesensitive, bool matchword, - bool all, bool forward) +docstring const replace2string(docstring const & replace, + docstring const & search, bool casesensitive, bool matchword, + bool all, bool forward) { odocstringstream ss; - ss << search << '\n' - << replace << '\n' + ss << replace << '\n' + << search << '\n' << int(casesensitive) << ' ' << int(matchword) << ' ' << int(all) << ' ' @@ -299,8 +307,8 @@ void replace(BufferView * bv, FuncRequest const & ev, bool has_deleted) // " docstring search; docstring rplc; - docstring howto = split(ev.argument(), search, '\n'); - howto = split(howto, rplc, '\n'); + docstring howto = split(ev.argument(), rplc, '\n'); + howto = split(howto, search, '\n'); bool casesensitive = parse_bool(howto); bool matchword = parse_bool(howto); @@ -311,7 +319,7 @@ void replace(BufferView * bv, FuncRequest const & ev, bool has_deleted) int const replace_count = all ? replaceAll(bv, search, rplc, casesensitive, matchword) : replace(bv, search, rplc, casesensitive, matchword, forward); - + Buffer & buf = bv->buffer(); if (replace_count == 0) { // emit message signal. @@ -355,20 +363,20 @@ bool findChange(BufferView * bv, bool next) 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().anchor()) + if (next != (bv->cursor().top() > bv->cursor().anchor())) bv->cursor().setCursorToAnchor(); } DocIterator cur = bv->cursor(); - - // Are we within a change ? Then first search forward (backward), + + // 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; if (cur.pos() > 1) { - Change change_next_pos + Change change_next_pos = cur.paragraph().lookupChange(cur.pos()); - Change change_prev_pos + Change change_prev_pos = cur.paragraph().lookupChange(cur.pos() - 1); if (change_next_pos.isSimilarTo(change_prev_pos)) search_both_sides = true; @@ -394,7 +402,8 @@ bool findChange(BufferView * bv, bool next) break; } } else { - for (; !tip.at_begin(); tip.backwardPos()) { + for (; !tip.at_begin();) { + tip.backwardPos(); Change change = tip.paragraph().lookupChange(tip.pos()); if (change != orig_change) { // take a step forward to correctly set the selection @@ -461,19 +470,19 @@ Escapes const & get_lyx_unescapes() { **/ string apply_escapes(string s, Escapes const & escape_map) { - LYXERR(Debug::DEBUG, "Escaping: '" << s << "'"); + LYXERR(Debug::FIND, "Escaping: '" << s << "'"); Escapes::const_iterator it; for (it = escape_map.begin(); it != escape_map.end(); ++it) { -// LYXERR(Debug::DEBUG, "Escaping " << it->first << " as " << it->second); +// LYXERR(Debug::FIND, "Escaping " << it->first << " as " << it->second); unsigned int pos = 0; while (pos < s.length() && (pos = s.find(it->first, pos)) < s.length()) { s.replace(pos, it->first.length(), it->second); -// LYXERR(Debug::DEBUG, "After escape: " << s); +// LYXERR(Debug::FIND, "After escape: " << s); pos += it->second.length(); -// LYXERR(Debug::DEBUG, "pos: " << pos); +// LYXERR(Debug::FIND, "pos: " << pos); } } - LYXERR(Debug::DEBUG, "Escaped : '" << s << "'"); + LYXERR(Debug::FIND, "Escaped : '" << s << "'"); return s; } @@ -498,7 +507,7 @@ size_t find_matching_brace(string const & s, size_t pos) return s.size(); } -/// Within \regex{} apply get_regex_escapes(), while outside apply get_lyx_unescapes(). +/// Within \regexp{} apply get_regex_escapes(), while outside apply get_lyx_unescapes(). string escape_for_regex(string s) { size_t pos = 0; @@ -506,30 +515,30 @@ string escape_for_regex(string s) size_t new_pos = s.find("\\regexp{", pos); if (new_pos == string::npos) new_pos = s.size(); - LYXERR(Debug::DEBUG, "new_pos: " << new_pos); + LYXERR(Debug::FIND, "new_pos: " << new_pos); string t = apply_escapes(s.substr(pos, new_pos - pos), get_lyx_unescapes()); - LYXERR(Debug::DEBUG, "t : " << t); + LYXERR(Debug::FIND, "t : " << t); t = apply_escapes(t, get_regexp_escapes()); s.replace(pos, new_pos - pos, t); new_pos = pos + t.size(); - LYXERR(Debug::DEBUG, "Regexp after escaping: " << s); - LYXERR(Debug::DEBUG, "new_pos: " << new_pos); + LYXERR(Debug::FIND, "Regexp after escaping: " << s); + LYXERR(Debug::FIND, "new_pos: " << new_pos); if (new_pos == s.size()) break; size_t end_pos = find_matching_brace(s, new_pos + 7); - LYXERR(Debug::DEBUG, "end_pos: " << end_pos); + LYXERR(Debug::FIND, "end_pos: " << end_pos); t = apply_escapes(s.substr(new_pos + 8, end_pos - (new_pos + 8)), get_lyx_unescapes()); - LYXERR(Debug::DEBUG, "t : " << t); + LYXERR(Debug::FIND, "t : " << t); if (end_pos == s.size()) { s.replace(new_pos, end_pos - new_pos, t); pos = s.size(); - LYXERR(Debug::DEBUG, "Regexp after \\regexp{} removal: " << s); + LYXERR(Debug::FIND, "Regexp after \\regexp{} removal: " << s); break; } s.replace(new_pos, end_pos + 1 - new_pos, t); - LYXERR(Debug::DEBUG, "Regexp after \\regexp{} removal: " << s); + LYXERR(Debug::FIND, "Regexp after \\regexp{} removal: " << s); pos = new_pos + t.size(); - LYXERR(Debug::DEBUG, "pos: " << pos); + LYXERR(Debug::FIND, "pos: " << pos); } return s; } @@ -561,7 +570,7 @@ bool braces_match(string::const_iterator const & beg, { int open_pars = 0; string::const_iterator it = beg; - LYXERR(Debug::DEBUG, "Checking " << unmatched << " unmatched braces in '" << string(beg, end) << "'"); + LYXERR(Debug::FIND, "Checking " << unmatched << " unmatched braces in '" << string(beg, end) << "'"); for (; it != end; ++it) { // Skip escaped braces in the count if (*it == '\\') { @@ -572,24 +581,23 @@ bool braces_match(string::const_iterator const & beg, ++open_pars; } else if (*it == '}') { if (open_pars == 0) { - LYXERR(Debug::DEBUG, "Found unmatched closed brace"); + LYXERR(Debug::FIND, "Found unmatched closed brace"); return false; } else --open_pars; } } if (open_pars != unmatched) { - LYXERR(Debug::DEBUG, "Found " << open_pars << " instead of " << unmatched << " unmatched open braces at the end of count"); + LYXERR(Debug::FIND, "Found " << open_pars + << " instead of " << unmatched + << " unmatched open braces at the end of count"); return false; } - LYXERR(Debug::DEBUG, "Braces match as expected"); + LYXERR(Debug::FIND, "Braces match as expected"); return true; } /** The class performing a match between a position in the document and the FindAdvOptions. - ** - ** @todo The user-entered regexp expression(s) should be enclosed within something like \regexp{}, - ** to be written by a dedicated Inset, so to avoid escaping it in escape_for_regex(). **/ class MatchStringAdv { public: @@ -601,7 +609,7 @@ public: ** @param at_begin ** If set, then match is searched only against beginning of text starting at cur. ** If unset, then match is searched anywhere in text starting at cur. - ** + ** ** @return ** The length of the matching text, or zero if no match was found. **/ @@ -652,7 +660,7 @@ MatchStringAdv::MatchStringAdv(lyx::Buffer const & buf, FindAndReplaceOptions co if (! opt.regexp) { // Remove trailing closure of math, macros and environments, so to catch parts of them. do { - LYXERR(Debug::DEBUG, "par_as_string now is '" << par_as_string << "'"); + LYXERR(Debug::FIND, "par_as_string now is '" << par_as_string << "'"); if (regex_replace(par_as_string, par_as_string, "(.*)[[:blank:]]\\'", "$1")) continue; if (regex_replace(par_as_string, par_as_string, "(.*[^\\\\]) ?\\$\\'", "$1")) @@ -668,34 +676,35 @@ MatchStringAdv::MatchStringAdv(lyx::Buffer const & buf, FindAndReplaceOptions co } break; } while (true); - LYXERR(Debug::DEBUG, "Open braces: " << open_braces); + LYXERR(Debug::FIND, "Open braces: " << open_braces); LASSERT(braces_match(par_as_string.begin(), par_as_string.end(), open_braces), /* */); - LYXERR(Debug::DEBUG, "Built MatchStringAdv object: par_as_string = '" << par_as_string << "'"); + LYXERR(Debug::FIND, "Built MatchStringAdv object: par_as_string = '" << par_as_string << "'"); } else { 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::DEBUG, "par_as_string now is '" << par_as_string << "'"); + LYXERR(Debug::FIND, "par_as_string now is '" << par_as_string << "'"); 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") + || regex_replace(par_as_string, par_as_string, + "(.*[^\\\\])(\\\\\\\\end\\\\\\{[a-zA-Z_]*\\\\\\})\\'", "$1(.*?)$2") // Insert .* before trailing '\}' ('}' has been escaped by escape_for_regex) || regex_replace(par_as_string, par_as_string, "(.*[^\\\\])(\\\\\\})\\'", "$1(.*?)$2") ) { ++close_wildcards; } - LYXERR(Debug::DEBUG, "par_as_string now is '" << par_as_string << "'"); - LYXERR(Debug::DEBUG, "Open braces: " << open_braces); - LYXERR(Debug::DEBUG, "Close .*? : " << 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); LASSERT(braces_match(par_as_string.begin(), par_as_string.end(), open_braces), /* */); - // Entered regexp must match at begin of searched string buffer - par_as_string = string("\\`") + par_as_string; - LYXERR(Debug::DEBUG, "Replaced text (to be used as regex): " << par_as_string); - regexp = boost::regex(par_as_string); - regexp2 = boost::regex(string(".*") + par_as_string); + 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 = boost::regex(string("\\`") + par_as_string); + // If entered regexp may match wherever in searched string buffer + regexp2 = boost::regex(string("\\`.*") + par_as_string); } } @@ -703,9 +712,9 @@ MatchStringAdv::MatchStringAdv(lyx::Buffer const & buf, FindAndReplaceOptions co int MatchStringAdv::operator()(DocIterator const & cur, int len, bool at_begin) const { docstring docstr = stringifyFromForSearch(opt, cur, len); - LYXERR(Debug::DEBUG, "Matching against '" << lyx::to_utf8(docstr) << "'"); + LYXERR(Debug::FIND, "Matching against '" << lyx::to_utf8(docstr) << "'"); string str = normalize(docstr); - LYXERR(Debug::DEBUG, "After normalization: '" << str << "'"); + LYXERR(Debug::FIND, "After normalization: '" << str << "'"); if (! opt.regexp) { if (at_begin) { if (str.substr(0, par_as_string.size()) == par_as_string) @@ -716,7 +725,8 @@ int MatchStringAdv::operator()(DocIterator const & cur, int len, bool at_begin) return par_as_string.size(); } } else { - // Try all possible regexp matches, until one that verifies the braces match test is found + // Try all possible regexp matches, + //until one that verifies the braces match test is found boost::regex const *p_regexp = at_begin ? ®exp : ®exp2; boost::sregex_iterator re_it(str.begin(), str.end(), *p_regexp); boost::sregex_iterator re_it_end; @@ -730,7 +740,8 @@ int MatchStringAdv::operator()(DocIterator const & cur, int len, bool at_begin) for (size_t i = 1; i < m.size(); ++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 + // 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 @@ -759,20 +770,22 @@ string MatchStringAdv::normalize(docstring const & s) const while ((pos = t.find("\n")) != string::npos) t.replace(pos, 1, " "); // Remove stale empty \emph{}, \textbf{} and similar blocks from latexify - while (regex_replace(t, t, "\\\\[a-zA-Z_]+(\\{\\})+", "")) - ; + LYXERR(Debug::FIND, "Removing stale empty \\emph{}, \\textbf{}, \\*section{} macros from: " << t); + while (regex_replace(t, t, "\\\\(emph|textbf|subsubsection|subsection|section|subparagraph|paragraph)(\\{\\})+", "")) + LYXERR(Debug::FIND, " further removing stale empty \\emph{}, \\textbf{} macros from: " << t); return t; } docstring stringifyFromCursor(DocIterator const & cur, int len) { - LYXERR(Debug::DEBUG, "Stringifying with len=" << len << " from cursor at pos: " << cur); + 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; + 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; @@ -780,30 +793,33 @@ docstring stringifyFromCursor(DocIterator const & cur, int len) runparams.linelen = 100000; //lyxrc.plaintext_linelen; // No side effect of file copying and image conversion runparams.dryrun = true; - LYXERR(Debug::DEBUG, "Stringifying with cur: " << cur << ", from pos: " << cur.pos() << ", end: " << end); + LYXERR(Debug::FIND, "Stringifying with cur: " + << cur << ", from pos: " << cur.pos() << ", end: " << end); return par.stringify(cur.pos(), end, AS_STR_INSETS, runparams); } else if (cur.inMathed()) { odocstringstream os; 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 ); + 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) os << *it; return os.str(); } - LYXERR(Debug::DEBUG, "Don't know how to stringify from here: " << cur); + LYXERR(Debug::FIND, "Don't know how to stringify from here: " << cur); return docstring(); } + /** Computes the LaTeX export of buf starting from cur and ending len positions * after cur, if len is positive, or at the paragraph or innermost inset end * if len is -1. */ - docstring latexifyFromCursor(DocIterator const & cur, int len) { - LYXERR(Debug::DEBUG, "Latexifying with len=" << len << " from cursor at pos: " << cur); - LYXERR(Debug::DEBUG, " with cur.lastpost=" << cur.lastpos() << ", cur.lastrow=" + 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()); Buffer const & buf = *cur.buffer(); LASSERT(buf.isLatex(), /* */); @@ -829,7 +845,7 @@ docstring latexifyFromCursor(DocIterator const & cur, int len) ? pit->size() : cur.pos() + len; TeXOnePar(buf, *cur.innerText(), pit, ods, texrow, runparams, string(), cur.pos(), endpos); - LYXERR(Debug::DEBUG, "Latexified text: '" << lyx::to_utf8(ods.str()) << "'"); + 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) { @@ -866,9 +882,9 @@ docstring latexifyFromCursor(DocIterator const & cur, int len) break; } } - LYXERR(Debug::DEBUG, "Latexified math: '" << lyx::to_utf8(ods.str()) << "'"); + LYXERR(Debug::FIND, "Latexified math: '" << lyx::to_utf8(ods.str()) << "'"); } else { - LYXERR(Debug::DEBUG, "Don't know how to stringify from here: " << cur); + LYXERR(Debug::FIND, "Don't know how to stringify from here: " << cur); } return ods.str(); } @@ -884,21 +900,21 @@ int findAdvFinalize(DocIterator & cur, MatchStringAdv const & match) size_t d; DocIterator old_cur(cur.buffer()); do { - LYXERR(Debug::DEBUG, "Forwarding one step (searching for innermost match)"); + LYXERR(Debug::FIND, "Forwarding one step (searching for innermost match)"); d = cur.depth(); old_cur = cur; cur.forwardPos(); } while (cur && cur.depth() > d && match(cur) > 0); cur = old_cur; LASSERT(match(cur) > 0, /* */); - LYXERR(Debug::DEBUG, "Ok"); + LYXERR(Debug::FIND, "Ok"); // Compute the match length int len = 1; - LYXERR(Debug::DEBUG, "verifying unmatch with len = " << len); + LYXERR(Debug::FIND, "verifying unmatch with len = " << len); while (cur.pos() + len <= cur.lastpos() && match(cur, len) == 0) { ++len; - LYXERR(Debug::DEBUG, "verifying unmatch with len = " << len); + LYXERR(Debug::FIND, "verifying unmatch with len = " << len); } // Length of matched text (different from len param) int old_len = match(cur, len); @@ -907,7 +923,7 @@ int findAdvFinalize(DocIterator & cur, MatchStringAdv const & match) while ((new_len = match(cur, len + 1)) > old_len) { ++len; old_len = new_len; - LYXERR(Debug::DEBUG, "verifying match with len = " << len); + LYXERR(Debug::FIND, "verifying match with len = " << len); } return len; } @@ -932,10 +948,10 @@ int findForwardAdv(DocIterator & cur, MatchStringAdv const & match) return findAdvFinalize(cur, match); } wrap_answer = frontend::Alert::prompt( - _("Wrap search ?"), - _("End of document reached while searching forward\n" + _("Wrap search?"), + _("End of document reached while searching forward.\n" "\n" - "Continue searching from beginning ?"), + "Continue searching from beginning?"), 0, 1, _("&Yes"), _("&No")); cur.clear(); cur.push_back(CursorSlice(match.buf.inset())); @@ -943,62 +959,95 @@ int findForwardAdv(DocIterator & cur, MatchStringAdv const & match) return 0; } +/// Find the most backward consecutive match within same paragraph while searching backwards. +void findMostBackwards(DocIterator & cur, MatchStringAdv const & match, int & len) { + DocIterator cur_begin = doc_iterator_begin(cur.buffer()); + len = findAdvFinalize(cur, match); + if (cur != cur_begin) { + Inset & inset = cur.inset(); + int old_len; + DocIterator old_cur; + DocIterator dit2; + do { + old_cur = cur; + old_len = len; + cur.backwardPos(); + LYXERR(Debug::FIND, "findMostBackwards(): old_cur=" + << old_cur << ", old_len=" << len << ", cur=" << cur); + dit2 = cur; + } while (cur != cur_begin && &cur.inset() == &inset && match(cur) + && (len = findAdvFinalize(dit2, match)) > old_len); + cur = old_cur; + len = old_len; + } + LYXERR(Debug::FIND, "findMostBackwards(): cur=" << cur); +} /// Finds backwards int findBackwardsAdv(DocIterator & cur, MatchStringAdv const & match) { - // if (cur.pos() > 0 || cur.depth() > 0) - // cur.backwardPos(); + if (! cur) + return 0; DocIterator cur_orig(cur); - if (match(cur_orig)) - findAdvFinalize(cur_orig, match); - // int total = cur.bottom().pit() + 1; - int wrap_answer; + DocIterator cur_begin = doc_iterator_begin(cur.buffer()); +/* if (match(cur_orig)) */ +/* findAdvFinalize(cur_orig, match); */ + int wrap_answer = 0; + bool found_match; do { - // TODO No ! così non va. bool pit_changed = false; - while (cur && !match(cur, -1, false)) { + found_match = false; + // Search in current par occurs from start to end, + // but in next loop match is discarded if pos > original pos + cur.pos() = 0; + found_match = match(cur, -1, false); + LYXERR(Debug::FIND, "findBackAdv0: found_match=" << found_match << ", cur: " << cur); + while (cur != cur_begin) { + if (found_match) + break; if (cur.pit() > 0) --cur.pit(); - else { + else cur.backwardPos(); - if (cur) - cur.pos() = 0; - } pit_changed = true; + // Search in previous pars occurs from start to end + cur.pos() = 0; + found_match = match(cur, -1, false); + LYXERR(Debug::FIND, "findBackAdv1: found_match=" + << found_match << ", cur: " << cur); } - if (cur && pit_changed) + if (pit_changed) cur.pos() = cur.lastpos(); - for (; cur; cur.backwardPos()) { - if (match(cur)) { - // Find the most backward consecutive match within same paragraph while searching backwards. - int pit = cur.pit(); - int old_len; - DocIterator old_cur; - int len = findAdvFinalize(cur, match); - do { - old_cur = cur; - old_len = len; - cur.backwardPos(); - LYXERR(Debug::DEBUG, "old_cur: " << old_cur << ", old_len=" << len << ", cur: " << cur); - } while (cur && cur.pit() == pit && match(cur) - && (len = findAdvFinalize(cur, match)) > old_len); - cur = old_cur; - len = old_len; - LYXERR(Debug::DEBUG, "cur_orig : " << cur_orig); - LYXERR(Debug::DEBUG, "cur : " << cur); - if (cur != cur_orig) - return len; - } + else + cur.pos() = cur_orig.pos(); + LYXERR(Debug::FIND, "findBackAdv2: cur: " << cur); + if (found_match) { + while (true) { + found_match=match(cur); + LYXERR(Debug::FIND, "findBackAdv3: found_match=" + << found_match << ", cur: " << cur); + if (found_match) { + int len; + findMostBackwards(cur, match, len); + if (&cur.inset() != &cur_orig.inset() + || !(cur.pit()==cur_orig.pit()) + || cur.pos() < cur_orig.pos()) + return len; + } + if (cur == cur_begin) + break; + cur.backwardPos(); + }; } wrap_answer = frontend::Alert::prompt( - _("Wrap search ?"), + _("Wrap search?"), _("Beginning of document reached while searching backwards\n" - "\n" - "Continue searching from end ?"), + "\n" + "Continue searching from end?"), 0, 1, _("&Yes"), _("&No")); cur = doc_iterator_end(&match.buf); cur.backwardPos(); } while (wrap_answer == 0); + cur = cur_orig; return 0; } @@ -1015,15 +1064,69 @@ docstring stringifyFromForSearch(FindAndReplaceOptions const & opt, } -lyx::FindAndReplaceOptions::FindAndReplaceOptions(docstring const & search, bool casesensitive, +FindAndReplaceOptions::FindAndReplaceOptions(docstring const & search, bool casesensitive, bool matchword, bool forward, bool expandmacros, bool ignoreformat, - bool regexp, docstring const & replace) + bool regexp, docstring const & replace, bool keep_case) : search(search), casesensitive(casesensitive), matchword(matchword), forward(forward), expandmacros(expandmacros), ignoreformat(ignoreformat), - regexp(regexp), replace(replace) + regexp(regexp), replace(replace), keep_case(keep_case) { } + +/** Checks if the supplied character is lower-case */ +static bool isLowerCase(char_type ch) { + return lowercase(ch) == ch; +} + + +/** Checks if the supplied character is upper-case */ +static bool isUpperCase(char_type ch) { + return uppercase(ch) == ch; +} + + +/** 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) + if (isLowerCase(cur.paragraph().getChar(pos))) + return false; + return true; +} + + +/** Check if first letter is upper case and second one is lower case */ +static bool firstUppercase(DocIterator const & cur) { + char_type ch1, ch2; + if (cur.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); + bool result = isUpperCase(ch1) && isLowerCase(ch2); + LYXERR(Debug::FIND, "firstUppercase(): " + << "ch1=" << ch1 << "(" << char(ch1) << "), ch2=" + << ch2 << "(" << char(ch2) << ")" + << ", result=" << result << ", cur=" << cur); + return result; +} + + +/** Make first letter of supplied buffer upper-case, and the rest lower-case. + ** + ** \fixme What to do with possible further paragraphs in replace buffer ? + **/ +static void changeFirstCase(Buffer & buffer, TextCase first_case, TextCase others_case) { + ParagraphList::iterator pit = buffer.paragraphs().begin(); + 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); +} + + /// Perform a FindAdv operation. bool findAdv(BufferView * bv, FindAndReplaceOptions const & opt) { @@ -1056,11 +1159,56 @@ bool findAdv(BufferView * bv, FindAndReplaceOptions const & opt) return false; } - LYXERR(Debug::DEBUG, "Putting selection at " << cur << " with len: " << match_len); + LYXERR(Debug::FIND, "Putting selection at " << cur << " with len: " << match_len); bv->putSelectionAt(cur, match_len, ! opt.forward); - bv->message(_("Match found!")); - if (opt.replace != docstring(from_utf8(LYX_FR_NULL_STRING))) { - dispatch(FuncRequest(LFUN_SELF_INSERT, opt.replace)); + if (opt.replace == docstring(from_utf8(LYX_FR_NULL_STRING))) { + bv->message(_("Match found !")); + } else { + 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()) + Buffer repl_buffer("", false); + repl_buffer.setUnnamed(true); + if (repl_buffer.readString(lyx)) { + if (opt.keep_case && match_len >= 2) { + if (cur.inTexted()) { + if (firstUppercase(cur)) + changeFirstCase(repl_buffer, text_uppercase, text_lowercase); + else if (allNonLowercase(cur, match_len)) + changeFirstCase(repl_buffer, text_uppercase, text_uppercase); + } + } + cap::cutSelection(bv->cursor(), false, false); + if (! cur.inMathed()) { + LYXERR(Debug::FIND, "Replacing by pasteParagraphList()ing repl_buffer"); + cap::pasteParagraphList(bv->cursor(), repl_buffer.paragraphs(), + repl_buffer.params().documentClassPtr(), + bv->buffer().errorList("Paste")); + } else { + odocstringstream ods; + 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); + //repl_buffer.getSourceCode(ods, 0, repl_buffer.paragraphs().size(), false); + 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"); + repl_latex = from_utf8(s); + LYXERR(Debug::FIND, "Replacing by niceInsert()ing latex: '" << repl_latex << "'"); + bv->cursor().niceInsert(repl_latex); + } + bv->putSelectionAt(cur, repl_buffer.paragraphs().begin()->size(), ! opt.forward); + bv->message(_("Match found and replaced !")); + } else + LASSERT(false, /**/); + // dispatch(FuncRequest(LFUN_SELF_INSERT, opt.replace)); } return true; @@ -1088,16 +1236,17 @@ ostringstream & operator<<(ostringstream & os, lyx::FindAndReplaceOptions const << opt.expandmacros << ' ' << opt.ignoreformat << ' ' << opt.regexp << ' ' - << to_utf8(opt.replace) << "\nEOSS\n"; + << to_utf8(opt.replace) << "\nEOSS\n" + << opt.keep_case; - LYXERR(Debug::DEBUG, "built: " << os.str()); + LYXERR(Debug::FIND, "built: " << os.str()); return os; } istringstream & operator>>(istringstream & is, lyx::FindAndReplaceOptions & opt) { - LYXERR(Debug::DEBUG, "parsing"); + LYXERR(Debug::FIND, "parsing"); string s; string line; getline(is, line); @@ -1109,7 +1258,7 @@ istringstream & operator>>(istringstream & is, lyx::FindAndReplaceOptions & opt) break; getline(is, line); } - LYXERR(Debug::DEBUG, "searching for: '" << s << "'"); + LYXERR(Debug::FIND, "searching for: '" << s << "'"); opt.search = from_utf8(s); is >> opt.casesensitive >> opt.matchword >> opt.forward >> opt.expandmacros >> opt.ignoreformat >> opt.regexp; is.get(); // Waste space before replace string @@ -1123,9 +1272,10 @@ istringstream & operator>>(istringstream & is, lyx::FindAndReplaceOptions & opt) break; getline(is, line); } - LYXERR(Debug::DEBUG, "parsed: " << opt.casesensitive << ' ' << opt.matchword << ' ' << opt.forward << ' ' - << opt.expandmacros << ' ' << opt.ignoreformat << ' ' << opt.regexp); - LYXERR(Debug::DEBUG, "replacing with: '" << s << "'"); + is >> opt.keep_case; + 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); return is; }