diff --git a/development/autotests/findadv-13-in.txt b/development/autotests/findadv-13-in.txt new file mode 100644 index 0000000000..701d23cac1 --- /dev/null +++ b/development/autotests/findadv-13-in.txt @@ -0,0 +1,15 @@ +# Finding footnotes +# +Lang it_IT.utf8 +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \Axfootnote-insert\[Return] +# Work around a little UI bug/non-determinism in cursor position after LFUN +KK: \C\[Home]\[Right] +KK: foo\C\[Home] +KK: \CF +KK: \Axfootnote-insert\[Return] +# Work around a little UI bug/non-determinism in cursor position after LFUN +KK: \C\[Home]\[Right] +KK: foo\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 0\n with len: 1' lyx-log.txt diff --git a/development/autotests/findadv-14-in.txt b/development/autotests/findadv-14-in.txt new file mode 100644 index 0000000000..a5ae4c426d --- /dev/null +++ b/development/autotests/findadv-14-in.txt @@ -0,0 +1,37 @@ +# Finding displayed maths with ignore-format on&off (might affect #7596) +# +Lang it_IT.utf8 +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \Axmath-display\[Return] +KK: x^2 +x^2\C\[Home] +KK: \Cs +KK: \CF +# Uncheck ignore format +KK: \Az\Ag\Ae +KK: \Axmath-display\[Return] +KK: x^2\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 0\n.*idx: 0 par: 0 pos: 0\n with len: 1' lyx-log.txt + +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \CF +# Uncheck ignore format +KK: \Az\Ag\Ae +KK: \Axmath-display\[Return] +KK: x^2\[Return]\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 0\n.*idx: 0 par: 0 pos: 2\n with len: 1' lyx-log.txt + +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \CF +KK: \Axmath-display\[Return] +KK: x^2\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 0\n.*idx: 0 par: 0 pos: 0\n with len: 1' lyx-log.txt + +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \CF +KK: \Axmath-display\[Return] +KK: x^2\[Return]\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 0\n.*idx: 0 par: 0 pos: 2\n with len: 1' lyx-log.txt diff --git a/development/autotests/findadv-15-in.txt b/development/autotests/findadv-15-in.txt new file mode 100644 index 0000000000..c615e6016a --- /dev/null +++ b/development/autotests/findadv-15-in.txt @@ -0,0 +1,37 @@ +# Finding numbered maths with ignore-format on&off (might affect #7596) +# +Lang it_IT.utf8 +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \CM\Axmath-number-toggle\[Return] +KK: x^2 +x^2\C\[Home] +KK: \Cs +KK: \CF +# Uncheck ignore format +KK: \Az\Ag\Ae +KK: \CM\Axmath-number-toggle\[Return] +KK: x^2\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 0\n.*idx: 0 par: 0 pos: 0\n with len: 1' lyx-log.txt + +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \CF +# Uncheck ignore format +KK: \Az\Ag\Ae +KK: \CM\Axmath-number-toggle\[Return] +KK: x^2\[Return]\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 0\n.*idx: 0 par: 0 pos: 2\n with len: 1' lyx-log.txt + +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \CF +KK: \CM\Axmath-number-toggle\[Return] +KK: x^2\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 0\n.*idx: 0 par: 0 pos: 0\n with len: 1' lyx-log.txt + +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \CF +KK: \CM\Axmath-number-toggle\[Return] +KK: x^2\[Return]\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 0\n.*idx: 0 par: 0 pos: 2\n with len: 1' lyx-log.txt diff --git a/development/autotests/findadv-16-in.txt b/development/autotests/findadv-16-in.txt new file mode 100644 index 0000000000..bcf6de548b --- /dev/null +++ b/development/autotests/findadv-16-in.txt @@ -0,0 +1,24 @@ +# Verify matches in *-environments with ignore-format off +# (gather environment comes in the *-form after mutate) +# +Lang it_IT.utf8 +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \CM\Axmath-mutate gather\[Return] +KK: x^2 +x^2\C\[Home] +KK: \Cs +KK: \CF +# Uncheck ignore format +KK: \Az\Ag\Ae +KK: \CM\Axmath-mutate gather\[Return] +KK: x^2\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 0\n.*idx: 0 par: 0 pos: 0\n with len: 1' lyx-log.txt + +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \CF +# Uncheck ignore format +KK: \Az\Ag\Ae +KK: \CM\Axmath-mutate gather\[Return] +KK: x^2\[Return]\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 0\n.*idx: 0 par: 0 pos: 2\n with len: 1' lyx-log.txt diff --git a/development/autotests/findadv-17-in.txt b/development/autotests/findadv-17-in.txt new file mode 100644 index 0000000000..657cf6cbf0 --- /dev/null +++ b/development/autotests/findadv-17-in.txt @@ -0,0 +1,18 @@ +# Finding consecutive macros in math mode +# +Lang it_IT.utf8 +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \Cm\\alpha\\beta\\alpha \C\[Home] +KK: \Cs +KK: \CF +KK: \Cm\\beta\\alpha \[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 0\n.*idx: 0 par: 0 pos: 1\n with len: 2' lyx-log.txt + +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \CF +# Uncheck ignore format +KK: \Az\Ag\Ae +KK: \Cm\\beta\\alpha \[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 0\n.*idx: 0 par: 0 pos: 1\n with len: 2' lyx-log.txt diff --git a/development/autotests/findadv-18-in.txt b/development/autotests/findadv-18-in.txt new file mode 100644 index 0000000000..31d935b2a4 --- /dev/null +++ b/development/autotests/findadv-18-in.txt @@ -0,0 +1,10 @@ +# Searching for regexp with e.g. \[Backspace]\[Backspace]s finds blanks + +Lang it_IT.utf8 +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: a b c\C\[Home] +KK: \Cs +KK: \CF +KK: \Axregexp-mode\[Return]\\s\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 1\n with len: 1' lyx-log.txt diff --git a/development/autotests/findadv-19-in.txt b/development/autotests/findadv-19-in.txt new file mode 100644 index 0000000000..f43dde9199 --- /dev/null +++ b/development/autotests/findadv-19-in.txt @@ -0,0 +1,10 @@ +# Check that searching for regexp "([a-z]+)\s\1" finds duplicate words. + +Lang it_IT.utf8 +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: Hello world world!\C\[Home] +KK: \Cs +KK: \CF +KK: \Axregexp-mode\[Return]([a-z]+)\\s\\1\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 6\n with len: 11' lyx-log.txt diff --git a/development/autotests/findadv-re-01-in.txt b/development/autotests/findadv-re-01-in.txt new file mode 100644 index 0000000000..a4bfed0bf4 --- /dev/null +++ b/development/autotests/findadv-re-01-in.txt @@ -0,0 +1,35 @@ +# Finding special latex/regexp chars: ( +# +Lang it_IT.utf8 +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \\()[]{}%^#@?*.\C\[Home] +KK: \Cs +KK: \CF +KK: \Axregexp-mode\[Return]\\(\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 1\n with len: 1' lyx-log.txt +# +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \CF +# Uncheck ignore format +KK: \Az\Ag\Ae +KK: \Axregexp-mode\[Return]\\(\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 1\n with len: 1' lyx-log.txt + +# Finding special latex/regexp chars: [ +# +Lang it_IT.utf8 +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \CF +KK: \Axregexp-mode\[Return]\\[\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 3\n with len: 1' lyx-log.txt +# +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \CF +# Uncheck ignore format +KK: \Az\Ag\Ae +KK: \Axregexp-mode\[Return]\\[\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 3\n with len: 1' lyx-log.txt diff --git a/development/autotests/findadv-re-02-in.txt b/development/autotests/findadv-re-02-in.txt new file mode 100644 index 0000000000..7ef9679635 --- /dev/null +++ b/development/autotests/findadv-re-02-in.txt @@ -0,0 +1,52 @@ +# Finding special latex/regexp chars: \ +# +Lang it_IT.utf8 +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \\()[]{}%^#@?*.\C\[Home] +KK: \Cs +KK: \CF +KK: \Axregexp-mode\[Return]\\\\\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 0\n with len: 1' lyx-log.txt +# +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \CF +# Uncheck ignore format +KK: \Az\Ag\Ae +KK: \Axregexp-mode\[Return]\\\\\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 0\n with len: 1' lyx-log.txt + +# Finding special latex/regexp chars: % +# +Lang it_IT.utf8 +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \CF +KK: \Axregexp-mode\[Return]%\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 7\n with len: 1' lyx-log.txt +# +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \CF +# Uncheck ignore format +KK: \Az\Ag\Ae +KK: \Axregexp-mode\[Return]%\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 7\n with len: 1' lyx-log.txt + +# Finding special latex/regexp chars: ^ +# +Lang it_IT.utf8 +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \CF +KK: \Axregexp-mode\[Return]\\^\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 8\n with len: 1' lyx-log.txt +# +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \CF +# Uncheck ignore format +KK: \Az\Ag\Ae +KK: \Axregexp-mode\[Return]\\^\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 8\n with len: 1' lyx-log.txt diff --git a/development/autotests/findadv-re-03-in.txt b/development/autotests/findadv-re-03-in.txt new file mode 100644 index 0000000000..c86ac718d9 --- /dev/null +++ b/development/autotests/findadv-re-03-in.txt @@ -0,0 +1,35 @@ +# Finding special latex/regexp chars: { +# +Lang it_IT.utf8 +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \\()[]{}%^#@?*.\C\[Home] +KK: \Cs +KK: \CF +KK: \Axregexp-mode\[Return]\\{\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 5\n with len: 1' lyx-log.txt +# +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \CF +# Uncheck ignore format +KK: \Az\Ag\Ae +KK: \Axregexp-mode\[Return]\\{\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 5\n with len: 1' lyx-log.txt + +# Finding special latex/regexp chars: } +# +Lang it_IT.utf8 +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \CF +KK: \Axregexp-mode\[Return]\\}\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 5\n with len: 1' lyx-log.txt +# +TestBegin test.lyx -dbg find > lyx-log.txt 2>&1 +KK: \CF +# Uncheck ignore format +KK: \Az\Ag\Ae +KK: \Axregexp-mode\[Return]\\}\[Return] +TestEnd +Assert pcregrep -M 'Putting selection at .*idx: 0 par: 0 pos: 5\n with len: 1' lyx-log.txt diff --git a/lib/doc/UserGuide.lyx b/lib/doc/UserGuide.lyx index dded19bbd9..20f9e78114 100644 --- a/lib/doc/UserGuide.lyx +++ b/lib/doc/UserGuide.lyx @@ -30250,11 +30250,7 @@ Finally, references to (sub)expressions in regexp may be used as usual, \begin_inset Formula $\backslash2$ \end_inset -, etc., where a -\begin_inset Formula $\backslash$ -\end_inset - - symbol is entered in regexp mode by pressing twice the backslash key. +, etc.. For example, try searching for the regexp \begin_inset Formula $([a-z]+)[[:blank:]]\backslash1$ \end_inset diff --git a/src/lyxfind.cpp b/src/lyxfind.cpp index 752d9b8f0f..486d10fe9e 100644 --- a/src/lyxfind.cpp +++ b/src/lyxfind.cpp @@ -40,6 +40,7 @@ #include "mathed/InsetMathGrid.h" #include "mathed/InsetMathHull.h" #include "mathed/MathStream.h" +#include "mathed/MathSupport.h" #include "support/convert.h" #include "support/debug.h" @@ -489,12 +490,11 @@ namespace { typedef vector > Escapes; /// A map of symbols and their escaped equivalent needed within a regex. +/// @note Beware of order Escapes const & get_regexp_escapes() { 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("}", "\\}")); @@ -505,6 +505,9 @@ Escapes const & get_regexp_escapes() 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")); } return escape_map; } @@ -513,13 +516,30 @@ Escapes const & get_regexp_escapes() Escapes const & get_lyx_unescapes() { 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("\\backslash{}", "\\")); + escape_map.push_back(pair("\\%", "%")); + escape_map.push_back(pair("\\{", "{")); + 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("\\sim ", "~")); - escape_map.push_back(pair("\\^", "^")); + escape_map.push_back(pair("\\sim", "~")); + } + return escape_map; +} + +/// A map of escapes turning a regexp matching text to one matching latex. +Escapes const & get_regexp_latex_escapes() { + 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("%", "\\\\\\%")); } return escape_map; } @@ -536,7 +556,7 @@ string apply_escapes(string s, Escapes const & escape_map) 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::FIND, "After escape: " << s); + LYXERR(Debug::FIND, "After escape: " << s); pos += it->second.length(); // LYXERR(Debug::FIND, "pos: " << pos); } @@ -548,7 +568,7 @@ string apply_escapes(string s, Escapes const & escape_map) /** Return the position of the closing brace matching the open one at s[pos], ** or s.size() if not found. **/ -size_t find_matching_brace(string const & s, size_t pos) +static size_t find_matching_brace(string const & s, size_t pos) { LASSERT(s[pos] == '{', /* */); int open_braces = 1; @@ -566,8 +586,10 @@ size_t find_matching_brace(string const & s, size_t pos) return s.size(); } -/// Within \regexp{} apply get_regex_escapes(), while outside apply get_lyx_unescapes(). -string escape_for_regex(string s) +/// Within \regexp{} apply get_lyx_unescapes() only (i.e., preserve regexp semantics of the string), +/// while outside apply get_lyx_unescapes()+get_regexp_escapes(). +/// If match_latex is true, then apply regexp_latex_escapes() to \regexp{} contents as well. +string escape_for_regex(string s, bool match_latex) { size_t pos = 0; while (pos < s.size()) { @@ -576,9 +598,9 @@ string escape_for_regex(string s) new_pos = s.size(); LYXERR(Debug::FIND, "new_pos: " << new_pos); string t = apply_escapes(s.substr(pos, new_pos - pos), get_lyx_unescapes()); - LYXERR(Debug::FIND, "t : " << t); + LYXERR(Debug::FIND, "t [lyx]: " << t); t = apply_escapes(t, get_regexp_escapes()); - LYXERR(Debug::FIND, "t : " << t); + LYXERR(Debug::FIND, "t [rxp]: " << t); s.replace(pos, new_pos - pos, t); new_pos = pos + t.size(); LYXERR(Debug::FIND, "Regexp after escaping: " << s); @@ -588,6 +610,8 @@ string escape_for_regex(string s) size_t end_pos = s.find("}}}", new_pos + 10); // find_matching_brace(s, new_pos + 7); LYXERR(Debug::FIND, "end_pos: " << end_pos); t = apply_escapes(s.substr(new_pos + 10, end_pos - (new_pos + 10)), get_lyx_unescapes()); + if (match_latex) + t = apply_escapes(t, get_regexp_latex_escapes()); LYXERR(Debug::FIND, "t : " << t); if (end_pos == s.size()) { s.replace(new_pos, end_pos - new_pos, t); @@ -649,10 +673,10 @@ bool braces_match(string::const_iterator const & beg, } } if (open_pars != unmatched) { - LYXERR(Debug::FIND, "Found " << open_pars - << " instead of " << unmatched - << " unmatched open braces at the end of count"); - return false; + LYXERR(Debug::FIND, "Found " << open_pars + << " instead of " << unmatched + << " unmatched open braces at the end of count"); + return false; } LYXERR(Debug::FIND, "Braces match as expected"); return true; @@ -708,6 +732,10 @@ private: lyx::regex regexp; // same as regexp, but prefixed with a ".*" lyx::regex regexp2; + // leading format material as string + string lead_as_string; + // par_as_string after removal of lead_as_string + string par_as_string_nolead; // unmatched open braces in the search string/regexp int open_braces; // number of (.*?) subexpressions added at end of search regexp for closing @@ -766,7 +794,7 @@ static docstring stringifySearchBuffer(Buffer & buffer, FindAndReplaceOptions co 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)\\*?\\{", "") + 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 ", "") @@ -776,6 +804,27 @@ static size_t identifyLeading(string const & s) { } +// Remove trailing closure of math, macros and environments, so to catch parts of them. +static int identifyClosing(string & t) { + int open_braces = 0; + do { + LYXERR(Debug::FIND, "identifyClosing(): t now is '" << t << "'"); + if (regex_replace(t, t, "(.*[^\\\\])\\$\\'", "$1")) + continue; + if (regex_replace(t, t, "(.*[^\\\\]) \\\\\\]\\'", "$1")) + continue; + if (regex_replace(t, t, "(.*[^\\\\]) \\\\end\\{[a-zA-Z_]*\\*?\\}\\'", "$1")) + continue; + if (regex_replace(t, t, "(.*[^\\\\])\\}\\'", "$1")) { + ++open_braces; + continue; + } + break; + } while (true); + return open_braces; +} + + MatchStringAdv::MatchStringAdv(lyx::Buffer & buf, FindAndReplaceOptions const & opt) : p_buf(&buf), p_first_buf(&buf), opt(opt) { @@ -784,37 +833,30 @@ MatchStringAdv::MatchStringAdv(lyx::Buffer & buf, FindAndReplaceOptions const & open_braces = 0; close_wildcards = 0; - use_regexp = !opt.ignoreformat || par_as_string.find("\\regexp") != std::string::npos; + use_regexp = par_as_string.find("\\regexp") != std::string::npos; + + size_t lead_size = 0; + if (!opt.ignoreformat) { + 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); + } 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 << "'"); - if (regex_replace(par_as_string, par_as_string, "(.*[^\\\\])\\$\\'", "$1")) - continue; - // @todo need to account for open square braces as well ? - if (regex_replace(par_as_string, par_as_string, "(.*[^\\\\]) \\\\\\]\\'", "$1")) - continue; - if (regex_replace(par_as_string, par_as_string, "(.*[^\\\\]) \\\\end\\{[a-zA-Z_]*\\*?\\}\\'", "$1")) - continue; - if (regex_replace(par_as_string, par_as_string, "(.*[^\\\\])\\}\\'", "$1")) { - ++open_braces; - continue; - } - break; - } while (true); + open_braces = identifyClosing(par_as_string); + identifyClosing(par_as_string_nolead); 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); + // @todo No need to search for \regexp{} insets in leading material + lead_as_regexp = escape_for_regex(par_as_string.substr(0, lead_size), !opt.ignoreformat); + par_as_string = par_as_string_nolead; 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); + par_as_string = escape_for_regex(par_as_string, !opt.ignoreformat); // 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 << "'"); if ( @@ -836,12 +878,12 @@ MatchStringAdv::MatchStringAdv(lyx::Buffer & buf, FindAndReplaceOptions const & 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; - LYXERR(Debug::FIND, "Setting regexp to : " << regexp_str << endl); + 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; - LYXERR(Debug::FIND, "Setting regexp2 to: " << regexp2_str << endl); + LYXERR(Debug::FIND, "Setting regexp2 to: '" << regexp2_str << "'"); regexp2 = lyx::regex(regexp2_str); } } @@ -855,17 +897,13 @@ int MatchStringAdv::findAux(DocIterator const & cur, int len, bool at_begin) con 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 (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 { - 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); + size_t pos = str.find(par_as_string_nolead); if (pos != string::npos) return par_as_string.size(); } @@ -966,15 +1004,16 @@ docstring stringifyFromCursor(DocIterator const & cur, int len) << cur << ", from pos: " << cur.pos() << ", end: " << end); return par.stringify(cur.pos(), end, AS_STR_INSETS, runparams); } else if (cur.inMathed()) { - odocstringstream os; + 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) - os << *it; - return os.str(); + 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(); @@ -1027,7 +1066,7 @@ docstring latexifyFromCursor(DocIterator const & cur, int 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) - ods << *it; + ods << asString(*it); // Retrieve the math environment type, and add '$' or '$]' // or others (\end{equation}) accordingly diff --git a/src/mathed/InsetMathHull.cpp b/src/mathed/InsetMathHull.cpp index 7be9d7d6ed..804d3d32b1 100644 --- a/src/mathed/InsetMathHull.cpp +++ b/src/mathed/InsetMathHull.cpp @@ -439,6 +439,8 @@ void InsetMathHull::metrics(MetricsInfo & mi, Dimension & dim) const dim.wid += 30 + l; } + if (type_ == hullRegexp) + dim.wid += 2; // make it at least as high as the current font int asc = 0; int des = 0; @@ -740,7 +742,7 @@ void InsetMathHull::validate(LaTeXFeatures & features) const features.addPreambleSnippet( string("\\newcommand{\\regexp}[1]{\\fcolorbox{") + frcol + string("}{") - + bgcol + string("}{\\texttt{#1}}}")); + + bgcol + string("}{\\ensuremath{\\mathtt{#1}}}}")); } // Validation is necessary only if not using AMS math. diff --git a/src/mathed/InsetMathNest.cpp b/src/mathed/InsetMathNest.cpp index 8e04e2a5d9..9dd01cca0c 100644 --- a/src/mathed/InsetMathNest.cpp +++ b/src/mathed/InsetMathNest.cpp @@ -1668,7 +1668,10 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c) bool reduced = cap::reduceSelectionToOneCell(cur); if (reduced || !cur.selection()) { docstring const safe = cap::grabAndEraseSelection(cur); - cur.insert(MathAtom(new InsetMathUnknown(from_ascii("\\"), safe, false))); + if (!cur.inRegexped()) + cur.insert(MathAtom(new InsetMathUnknown(from_ascii("\\"), safe, false))); + else + cur.niceInsert(createInsetMath("backslash", buf)); } return true; } @@ -1721,7 +1724,29 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c) } // These should be treated differently when not in text mode: - if (currentMode() != InsetMath::TEXT_MODE) { + if (cur.inRegexped()) { + switch (c) { + case '\\': + cur.niceInsert(createInsetMath("backslash", buf)); + break; + case '^': + cur.niceInsert(createInsetMath("mathcircumflex", buf)); + break; + case '{': + case '}': + case '#': + case '%': + case '_': + cur.niceInsert(createInsetMath(docstring(1, c), buf)); + break; + case '~': + cur.niceInsert(createInsetMath("sim", buf)); + break; + default: + cur.insert(c); + } + return true; + } else if (currentMode() != InsetMath::TEXT_MODE) { if (c == '_') { script(cur, false, save_selection); return true; diff --git a/status.20x b/status.20x index 7abc17c13a..7b68627199 100644 --- a/status.20x +++ b/status.20x @@ -184,6 +184,17 @@ What's new - Now advanced find and replace doesn't ignore white spaces while matching with ignore format. +- Now the cursor is visible while at the rightmost part of a regexp inset. + +- Now a regexp inset with a \backslash or braces is previewed correctly. + +- Disabled possibility to type macros in regexp-mode. + +- Now backslash-prefixed regexps like "\s", "\d", etc., are all understood by Advanced F&R. + +- Now Adv. F&R correctly interprets escape sequences within regexp insets, e.g., \\ or \(, + for finding characters with a special meaning in regular expression context (\^()[]). + * DOCUMENTATION AND LOCALIZATION