msgstr ""
"Project-Id-Version: LyX 2.4\n"
"Report-Msgid-Bugs-To: lyx-devel@lists.lyx.org\n"
-"POT-Creation-Date: 2022-03-17 18:13+0100\n"
-"PO-Revision-Date: 2022-03-17 18:23+0100\n"
+"POT-Creation-Date: 2022-04-19 18:17+0200\n"
+"PO-Revision-Date: 2022-04-19 18:20+0200\n"
"Last-Translator: Jean-Pierre Chrétien <jeanpierre.chretien@free.fr>\n"
"Language-Team: lyxfr\n"
"Language: fr\n"
msgid "Greyedout"
msgstr "Grisée"
-#: lib/layouts/stdinsets.inc:208 src/insets/InsetERT.cpp:253
-#: src/insets/InsetERT.cpp:254
+#: lib/layouts/stdinsets.inc:208 src/insets/InsetERT.cpp:251
+#: src/insets/InsetERT.cpp:252
msgid "ERT"
msgstr "TeX"
#: lib/ui/stdcontext.inc:61 lib/ui/stdcontext.inc:375 lib/ui/stdmenus.inc:108
#: lib/ui/stdtoolbars.inc:86 src/Text3.cpp:1584
-#: src/mathed/InsetMathNest.cpp:555
+#: src/mathed/InsetMathNest.cpp:561
msgid "Cut"
msgstr "Couper"
#: lib/ui/stdcontext.inc:63 lib/ui/stdcontext.inc:377 lib/ui/stdmenus.inc:110
#: lib/ui/stdtoolbars.inc:88 src/Text3.cpp:1528
#: src/frontends/qt/GuiToolbar.cpp:441 src/mathed/InsetMathGrid.cpp:1565
-#: src/mathed/InsetMathNest.cpp:533
+#: src/mathed/InsetMathNest.cpp:539
msgid "Paste"
msgstr "Coller"
#: src/insets/InsetCommandParams.cpp:508 src/insets/InsetCommandParams.cpp:516
#: src/insets/InsetGraphics.cpp:900 src/insets/InsetGraphics.cpp:908
#: src/insets/InsetListings.cpp:299 src/insets/InsetListings.cpp:307
-#: src/insets/InsetListings.cpp:332 src/mathed/MathExtern.cpp:1440
-#: src/mathed/MathExtern.cpp:1514
+#: src/insets/InsetListings.cpp:332 src/mathed/MathExtern.cpp:1444
+#: src/mathed/MathExtern.cpp:1518
msgid "LyX Warning: "
msgstr "Avertissement LyX : "
#: src/insets/InsetCommandParams.cpp:509 src/insets/InsetCommandParams.cpp:517
#: src/insets/InsetGraphics.cpp:901 src/insets/InsetGraphics.cpp:909
#: src/insets/InsetListings.cpp:300 src/insets/InsetListings.cpp:308
-#: src/mathed/MathExtern.cpp:1441 src/mathed/MathExtern.cpp:1515
+#: src/mathed/MathExtern.cpp:1445 src/mathed/MathExtern.cpp:1519
msgid "uncodable character"
msgstr "caractère incodable"
msgid "No output file was generated."
msgstr "Aucun fichier imprimable créé."
-#: src/Cursor.cpp:416 src/Text.cpp:2141
+#: src/Cursor.cpp:417 src/Text.cpp:2141
msgid ", Inset: "
msgstr ", insert : "
-#: src/Cursor.cpp:417 src/Text.cpp:2143
+#: src/Cursor.cpp:418 src/Text.cpp:2143
msgid ", Cell: "
msgstr ", cellule : "
-#: src/Cursor.cpp:418 src/Text.cpp:2146
+#: src/Cursor.cpp:419 src/Text.cpp:2146
msgid ", Position: "
msgstr ", position : "
msgid "No valid math formula"
msgstr "Pas de formule mathématique valide"
-#: src/Text3.cpp:210 src/mathed/InsetMathNest.cpp:1032
+#: src/Text3.cpp:210 src/mathed/InsetMathNest.cpp:1038
msgid "Already in regular expression mode"
msgstr "Déjà en mode « expression régulière »"
msgid "Sorting: "
msgstr "Tri : "
-#: src/insets/InsetNote.cpp:252
+#: src/insets/InsetNote.cpp:269
msgid "note"
msgstr "note"
"L'information de suivi de modifications pour les lignes/colonnes de tableau "
"est incomplète. Elle sera ignorée."
-#: src/insets/InsetTabular.cpp:5680
+#: src/insets/InsetTabular.cpp:5636
msgid "Column movement not supported with multi-columns."
msgstr "Déplacement de colonne non implanté pour les colonnes multiples."
-#: src/insets/InsetTabular.cpp:5698
+#: src/insets/InsetTabular.cpp:5654
msgid "Row movement not supported with multi-rows."
msgstr "Déplacement de ligne non implanté pour les lignes multiples."
-#: src/insets/InsetTabular.cpp:6219
+#: src/insets/InsetTabular.cpp:6175
msgid "Selection size should match clipboard content."
msgstr ""
"La taille de la sélection doit correspondre au contenu du presse-papier."
-#: src/insets/InsetText.cpp:1380
+#: src/insets/InsetText.cpp:1381
msgid "[contains tracked changes]"
msgstr "[contient les modifications suivies]"
msgid "%1$d strings have been replaced."
msgstr "%1$d chaînes remplacées."
-#: src/lyxfind.cpp:4584
+#: src/lyxfind.cpp:4680
msgid "One match has been replaced."
msgstr "Une correspondance a été remplacée."
-#: src/lyxfind.cpp:4587
+#: src/lyxfind.cpp:4683
msgid "Two matches have been replaced."
msgstr "Deux correspondances ont été remplacées."
-#: src/lyxfind.cpp:4590
+#: src/lyxfind.cpp:4686
#, c-format
msgid "%1$d matches have been replaced."
msgstr "%1$d correspondances ont été remplacées."
-#: src/lyxfind.cpp:4596
+#: src/lyxfind.cpp:4692
msgid "Match not found."
msgstr "Chaîne de caractères introuvable."
-#: src/lyxfind.cpp:4602
+#: src/lyxfind.cpp:4698
msgid "Match has been replaced."
msgstr "Chaîne de caractères remplacée."
-#: src/lyxfind.cpp:4604
+#: src/lyxfind.cpp:4700
msgid "Match found."
msgstr "Chaîne de caractères reconnue."
msgid "Invalid macro! \\%1$s"
msgstr "Macro mathématique invalide ! \\%1$s"
-#: src/mathed/InsetMathNest.cpp:1018
+#: src/mathed/InsetMathNest.cpp:1024
msgid "create new math text environment ($...$)"
msgstr "créé un nouvel environnement texte math ($...$)"
-#: src/mathed/InsetMathNest.cpp:1021
+#: src/mathed/InsetMathNest.cpp:1027
msgid "entered math text mode (textrm)"
msgstr "entré en mode texte math (textrm)"
-#: src/mathed/InsetMathNest.cpp:1043
+#: src/mathed/InsetMathNest.cpp:1049
msgid "Regular expression editor mode"
msgstr "Mode d'édition « expression régulière »"
-#: src/mathed/InsetMathNest.cpp:1948
+#: src/mathed/InsetMathNest.cpp:1954
#, c-format
msgid "Cannot apply %1$s here."
msgstr "Impossible d'appliquer %1$s ici."
msgstr "Mécanisme de sélection copier/coller"
#: src/support/debug.cpp:74
-msgid "Find and replace mechanism"
-msgstr "Rechercher et remplacer"
+msgid "Find and replace mechanism, terse version"
+msgstr "Rechercher et remplacer, version laconique du moteur"
#: src/support/debug.cpp:75
+msgid "Find and replace mechanism, verbose version"
+msgstr "Rechercher et remplacer, version bavarde du moteur"
+
+#: src/support/debug.cpp:76
msgid "Developers' general debug messages"
msgstr "Messages de débogage généraux pour les développeurs"
-#: src/support/debug.cpp:76 src/support/debug.cpp:77
+#: src/support/debug.cpp:77 src/support/debug.cpp:78
msgid "All debugging messages"
msgstr "Tous les messages de débogage"
-#: src/support/debug.cpp:184
+#: src/support/debug.cpp:185
#, c-format
msgid "Debugging `%1$s' (%2$s)"
msgstr "Débogage de '%1$s' (%2$s)"
replace = accents["braceright"];
else {
// else part should not exist
- LASSERT(1, /**/);
+ LASSERT(0, /**/);
}
}
else {
replace = "\\}";
else {
// else part should not exist
- LASSERT(1, /**/);
+ LASSERT(0, /**/);
}
}
}
pit_type const endpit = buffer.paragraphs().size();
for (pit_type pit = 0; pit != endpit; ++pit) {
TeXOnePar(buffer, buffer.text(), pit, os, runparams);
- LYXERR(Debug::FIND, "searchString up to here: " << ods.str());
+ LYXERR(Debug::FINDVERBOSE, "searchString up to here: " << ods.str());
}
return ods.str();
}
add = addtmp;
else if (addtmp.length() > lastpos)
add += addtmp.substr(lastpos, addtmp.length() - lastpos);
- LYXERR(Debug::FIND, "Adding to search string: '"
+ LYXERR(Debug::FINDVERBOSE, "Adding to search string: '"
<< add << "'");
return add;
}
string add = latexNamesToUtf8(par.asString(pos_type(0), par.size(),
option,
&runparams));
- LYXERR(Debug::FIND, "Adding to search string: '"
+ LYXERR(Debug::FINDVERBOSE, "Adding to search string: '"
<< add << "'");
t += add;
}
|| regex_replace(t, t, "^ ?\\\\item\\{[a-z]+\\}", "")
|| regex_replace(t, t, "^\\\\begin\\{[a-zA-Z_]*\\*?\\}", ""))
;
- LYXERR(Debug::FIND, " after removing leading $, \\[ , \\emph{, \\textbf{, etc.: '" << t << "'");
+ LYXERR(Debug::FINDVERBOSE, " after removing leading $, \\[ , \\emph{, \\textbf{, etc.: '" << t << "'");
return s.find(t);
}
{
if (actualdeptindex <= 0) {
if (! closingAllowed)
- LYXERR(Debug::FIND, "Bad closing parenthesis in latex"); /* should not happen, but the latex input may be wrong */
+ LYXERR(Debug::FINDVERBOSE, "Bad closing parenthesis in latex"); /* should not happen, but the latex input may be wrong */
// if we are at the very end
addIntervall(i, i+1);
}
if (withformat) {
// Split the latex input into pieces which
// can be digested by our search engine
- LYXERR(Debug::FIND, "input: \"" << par << "\"");
+ LYXERR(Debug::FINDVERBOSE, "input: \"" << par << "\"");
if (isPatternString && (pbuf != nullptr)) { // Check if we should disable/enable test for language
// We check for polyglossia, because in runparams.flavor we use Flavor::XeTeX
string doclang = pbuf->params().language->polyglossia();
}
result = splitOnKnownMacros(par.substr(0,parlen), isPatternString);
- LYXERR(Debug::FIND, "After splitOnKnownMacros:\n\"" << result << "\"");
+ LYXERR(Debug::FINDVERBOSE, "After splitOnKnownMacros:\n\"" << result << "\"");
}
else
result = par.substr(0, parlen);
features += " " + a;
// LYXERR(Debug::INFO, "Identified regex format:" << a);
}
- LYXERR(Debug::FIND, "Identified Features" << features);
+ LYXERR(Debug::FINDVERBOSE, "Identified Features" << features);
}
} else if (regex_with_format) {
bool b = it->second;
if (b && ! info[a]) {
missed++;
- LYXERR(Debug::FIND, "Missed(" << missed << " " << a <<", srclen = " << parlen );
+ LYXERR(Debug::FINDVERBOSE, "Missed(" << missed << " " << a <<", srclen = " << parlen );
return "";
}
}
// Remove trailing closure of math, macros and environments, so to catch parts of them.
-static int identifyClosing(string & t)
+static void identifyClosing(string & t, bool ignoreformat)
{
- int open_braces = 0;
do {
- LYXERR(Debug::FIND, "identifyClosing(): t now is '" << t << "'");
+ LYXERR(Debug::FINDVERBOSE, "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;
+ if (regex_replace(t, t, "(.*[^\\\\])\\\\end\\{[a-zA-Z_]+\\*?\\}$", "$1"))
continue;
+ if (! ignoreformat) {
+ if (regex_replace(t, t, "(.*[^\\\\])\\}$", "$1"))
+ continue;
}
break;
} while (true);
- return open_braces;
+ return;
}
static int num_replaced = 0;
}
opt.matchAtStart = false;
if (!use_regexp) {
- identifyClosing(par_as_string); // Removes math closings ($, ], ...) at end of string
+ identifyClosing(par_as_string, opt.ignoreformat); // Removes math closings ($, ], ...) at end of string
if (opt.ignoreformat) {
lead_size = 0;
}
string regexp2_str = "(" + lead_as_regex_string + ")(.*?)" + par_as_regex_string_nolead;
CreateRegexp(opt, regexp_str, regexp2_str);
use_regexp = true;
- LYXERR(Debug::FIND, "Setting regexp to : '" << regexp_str << "'");
- LYXERR(Debug::FIND, "Setting regexp2 to: '" << regexp2_str << "'");
+ LYXERR(Debug::FINDVERBOSE|Debug::FIND, "Setting regexp to : '" << regexp_str << "'");
+ LYXERR(Debug::FINDVERBOSE|Debug::FIND, "Setting regexp2 to: '" << regexp2_str << "'");
return;
}
if (!opt.ignoreformat) {
lead_size = identifyLeading(par_as_string);
- LYXERR(Debug::FIND, "Lead_size: " << lead_size);
+ LYXERR(Debug::FINDVERBOSE, "Lead_size: " << lead_size);
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);
}
(void)regex_replace(par_as_string_nolead, par_as_string_nolead, "\\$$", "");
(void)regex_replace(par_as_string_nolead, par_as_string_nolead, "}$", "");
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 << "'");
+ LYXERR(Debug::FINDVERBOSE, "lead_as_regexp is '" << lead_as_regexp << "'");
+ LYXERR(Debug::FINDVERBOSE, "par_as_string now is '" << par_as_string << "'");
}
- // LYXERR(Debug::FIND, "par_as_string before escape_for_regex() is '" << par_as_string << "'");
+ // LYXERR(Debug::FINDVERBOSE, "par_as_string before escape_for_regex() is '" << 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 << "'");
+ // LYXERR(Debug::FINDVERBOSE, "par_as_string now is '" << par_as_string << "'");
++close_wildcards;
size_t lng = par_as_string.size();
if (!opt.ignoreformat) {
if (lng < par_as_string.size())
par_as_string = par_as_string.substr(0,lng);
}
- LYXERR(Debug::FIND, "par_as_string after correctRegex is '" << par_as_string << "'");
+ LYXERR(Debug::FINDVERBOSE, "par_as_string after correctRegex is '" << par_as_string << "'");
if ((lng > 0) && (par_as_string[0] == '^')) {
par_as_string = par_as_string.substr(1);
--lng;
opt.matchAtStart = true;
}
- // LYXERR(Debug::FIND, "par_as_string now is '" << par_as_string << "'");
- // LYXERR(Debug::FIND, "Open braces: " << open_braces);
- // LYXERR(Debug::FIND, "Replaced text (to be used as regex): " << par_as_string);
+ // LYXERR(Debug::FINDVERBOSE, "par_as_string now is '" << par_as_string << "'");
+ // LYXERR(Debug::FINDVERBOSE, "Open braces: " << open_braces);
+ // LYXERR(Debug::FINDVERBOSE, "Replaced text (to be used as regex): " << par_as_string);
// If entered regexp must match at begin of searched string buffer
// Kornel: Added parentheses to use $1 for size of the leading string
regexp_str = "(" + lead_as_regexp + ")()" + par_as_string;
regexp2_str = "(" + lead_as_regexp + ")(.*?)" + par_as_string;
}
- LYXERR(Debug::FIND, "Setting regexp to : '" << regexp_str << "'");
- LYXERR(Debug::FIND, "Setting regexp2 to: '" << regexp2_str << "'");
+ LYXERR(Debug::FINDVERBOSE|Debug::FIND, "Setting regexp to : '" << regexp_str << "'");
+ LYXERR(Debug::FINDVERBOSE|Debug::FIND, "Setting regexp2 to: '" << regexp2_str << "'");
CreateRegexp(opt, regexp_str, regexp2_str, par_as_string);
}
}
mres.match_len = -1;
return mres;
}
- LYXERR(Debug::FIND, "After normalization: Matching against:\n'" << str << "'");
+ LYXERR(Debug::FINDVERBOSE, "After normalization: Matching against:\n'" << str << "'");
LASSERT(use_regexp, /**/);
{
// use_regexp always true
- LYXERR(Debug::FIND, "Searching in regexp mode: at_begin=" << at_begin);
+ LYXERR(Debug::FINDVERBOSE, "Searching in regexp mode: at_begin=" << at_begin);
#if QTSEARCH
QString qstr = QString::fromStdString(str);
QRegularExpression const *p_regexp;
{
MatchResult mres = findAux(cur, len, at_begin);
int res = mres.match_len;
- LYXERR(Debug::FIND,
+ LYXERR(Debug::FINDVERBOSE,
"res=" << res << ", at_begin=" << at_begin
<< ", matchAtStart=" << opt.matchAtStart
<< ", inTexted=" << cur.inTexted());
// Remove stale empty \emph{}, \textbf{} and similar blocks from latexify
// Kornel: Added textsl, textsf, textit, texttt and noun
// + allow to seach for colored text too
- LYXERR(Debug::FIND, "Removing stale empty macros from: " << t);
+ LYXERR(Debug::FINDVERBOSE, "Removing stale empty macros from: " << t);
while (regex_replace(t, t, "\\\\(emph|noun|text(bf|sl|sf|it|tt)|(u|uu)line|(s|x)out|uwave)(\\{(\\{\\})?\\})+", ""))
- LYXERR(Debug::FIND, " further removing stale empty \\emph{}, \\textbf{} macros from: " << t);
+ LYXERR(Debug::FINDVERBOSE, " further removing stale empty \\emph{}, \\textbf{} macros from: " << t);
while (regex_replace(t, t, "\\\\((sub)?(((sub)?section)|paragraph)|part)\\*?(\\{(\\{\\})?\\})+", ""))
- LYXERR(Debug::FIND, " further removing stale empty \\emph{}, \\textbf{} macros from: " << t);
+ LYXERR(Debug::FINDVERBOSE, " further removing stale empty \\emph{}, \\textbf{} macros from: " << t);
while (regex_replace(t, t, "\\\\(foreignlanguage|textcolor|item)\\{[a-z]+\\}(\\{(\\{\\})?\\})+", ""));
return t;
docstring stringifyFromCursor(DocIterator const & cur, int len)
{
- LYXERR(Debug::FIND, "Stringifying with len=" << len << " from cursor at pos: " << cur);
+ LYXERR(Debug::FINDVERBOSE, "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 ?
if (ignoreFormats.getNonContent()) {
runparams.for_search |= OutputParams::SearchNonOutput;
}
- LYXERR(Debug::FIND, "Stringifying with cur: "
+ LYXERR(Debug::FINDVERBOSE, "Stringifying with cur: "
<< cur << ", from pos: " << cur.pos() << ", end: " << end);
- return from_utf8(latexNamesToUtf8(par.asString(cur.pos(), end,
- option,
- &runparams)));
+ docstring res = from_utf8(latexNamesToUtf8(par.asString(cur.pos(), end,
+ option,
+ &runparams)));
+ LYXERR(Debug::FIND, "Stringified text from pos(" << cur.pos() << ") len(" << len << "): " << res);
+ return res;
} else if (cur.inMathed()) {
CursorSlice cs = cur.top();
MathData md = cs.cell();
MathData md2;
for (MathData::const_iterator it = md.begin() + cs.pos(); it != it_end; ++it)
md2.push_back(*it);
- docstring s = from_utf8(latexNamesToUtf8(asString(md2)));
- LYXERR(Debug::FIND, "Stringified math: '" << s << "'");
- return s;
+ docstring res = from_utf8(latexNamesToUtf8(asString(md2)));
+ LYXERR(Debug::FINDVERBOSE|Debug::FIND, "Stringified math from pos(" << cur.pos() << ") len(" << len << "): " << res);
+ return res;
}
- LYXERR(Debug::FIND, "Don't know how to stringify from here: " << cur);
+ LYXERR(Debug::FINDVERBOSE|Debug::FIND, "Don't know how to stringify from here: " << cur);
return docstring();
}
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="
+ LYXERR(Debug::FINDVERBOSE, "Latexifying with len=" << len << " from cursor at pos: " << cur);
+ LYXERR(Debug::FINDVERBOSE, " with cur.lastpost=" << cur.lastpos() << ", cur.lastrow="
<< cur.lastrow() << ", cur.lastcol=" << cur.lastcol());
*/
Buffer const & buf = *cur.buffer();
endpos = cur.pos() + len;
TeXOnePar(buf, *cur.innerText(), cur.pit(), os, runparams,
string(), cur.pos(), endpos);
- string s = lyx::to_utf8(ods.str());
- LYXERR(Debug::FIND, "Latexified +modified text: '" << s << "'");
- return(lyx::from_utf8(s));
+ LYXERR(Debug::FIND, "Latexified text from pos(" << cur.pos() << ") len(" << len << "): " << ods.str());
+ return(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) {
break;
}
}
- LYXERR(Debug::FIND, "Latexified math: '" << lyx::to_utf8(ods.str()) << "'");
+ LYXERR(Debug::FINDVERBOSE|Debug::FIND, "Latexified math from pos(" << cur.pos() << ") len(" << len << "): " << ods.str());
} else {
- LYXERR(Debug::FIND, "Don't know how to stringify from here: " << cur);
+ LYXERR(Debug::FINDVERBOSE|Debug::FIND, "Don't know how to stringify from here: " << cur);
}
return ods.str();
}
max_match = mres;
}
if (max_match.match_len <= 0) return fail;
- LYXERR(Debug::FIND, "Ok");
+ LYXERR(Debug::FINDVERBOSE, "Ok");
// Compute the match length
int len = 1;
MatchResult orig_mres;
while (!theApp()->longOperationCancelled() && cur) {
//(void) findAdvForwardInnermost(cur);
- LYXERR(Debug::FIND, "findForwardAdv() cur: " << cur);
+ LYXERR(Debug::FINDVERBOSE, "findForwardAdv() cur: " << cur);
MatchResult mres = match(cur, -1, false);
string msg = "Starting";
if (repeat)
if (match_len <= 0) {
// This should exit nested insets, if any, or otherwise undefine the currsor.
cur.pos() = cur.lastpos();
- LYXERR(Debug::FIND, "Advancing pos: cur=" << cur);
+ LYXERR(Debug::FINDVERBOSE, "Advancing pos: cur=" << cur);
cur.forwardPos();
}
else { // match_len > 0
if (increment < 1)
increment = 1;
}
- LYXERR(Debug::FIND, "Set increment to " << increment);
+ LYXERR(Debug::FINDVERBOSE, "Set increment to " << increment);
while (increment > 0) {
DocIterator old_cur = cur;
if (cur.pos() + increment >= cur.lastpos()) {
mres = orig_mres;
}
// LYXERR0("Leaving first loop");
- LYXERR(Debug::FIND, "Finalizing 1");
+ LYXERR(Debug::FINDVERBOSE, "Finalizing 1");
MatchResult found_match = findAdvFinalize(cur, match, mres);
if (found_match.match_len > 0) {
- LASSERT(found_match.pos_len > 0, /**/);
match.FillResults(found_match);
return found_match.pos_len;
}
MatchResult mr = findAdvFinalize(tmp_cur, match, expected);
Inset & inset = cur.inset();
for (; cur != cur_begin; cur.backwardPos()) {
- LYXERR(Debug::FIND, "findMostBackwards(): cur=" << cur);
+ LYXERR(Debug::FINDVERBOSE, "findMostBackwards(): cur=" << cur);
DocIterator new_cur = cur;
new_cur.backwardPos();
if (new_cur == cur || &new_cur.inset() != &inset || !match(new_cur).match_len)
break;
mr = new_mr;
}
- LYXERR(Debug::FIND, "findMostBackwards(): exiting with cur=" << cur);
+ LYXERR(Debug::FINDVERBOSE, "findMostBackwards(): exiting with cur=" << cur);
return mr;
}
cur.pos() = cur.lastpos();
else
cur.pos() = cur_orig.pos();
- LYXERR(Debug::FIND, "findBackAdv2: cur: " << cur);
+ LYXERR(Debug::FINDVERBOSE, "findBackAdv2: cur: " << cur);
DocIterator cur_prev_iter;
do {
found_match = match(cur);
- LYXERR(Debug::FIND, "findBackAdv3: found_match="
+ LYXERR(Debug::FINDVERBOSE, "findBackAdv3: found_match="
<< (found_match.match_len > 0) << ", cur: " << cur);
if (found_match.match_len > 0) {
MatchResult found_mr = findMostBackwards(cur, match, found_match);
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");
+ LYXERR(Debug::FINDVERBOSE, "This should not happen, more debug needed");
len = cur.lastpos() + 1 - beg_pos;
end_pos = beg_pos + len;
}
char_type ch1, ch2;
pos_type pos = cur.selectionBegin().pos();
if (pos >= cur.lastpos() - 1) {
- LYXERR(Debug::FIND, "No upper-case at cur: " << cur);
+ LYXERR(Debug::FINDVERBOSE, "No upper-case at cur: " << cur);
return false;
}
ch1 = cur.paragraph().getChar(pos);
ch2 = cur.paragraph().getChar(pos + 1);
bool result = isUpperCase(ch1) && isLowerCase(ch2);
- LYXERR(Debug::FIND, "firstUppercase(): "
+ LYXERR(Debug::FINDVERBOSE, "firstUppercase(): "
<< "ch1=" << ch1 << "(" << char(ch1) << "), ch2="
<< ch2 << "(" << char(ch2) << ")"
<< ", result=" << result << ", cur=" << cur);
|| sel_beg.idx() != sel_end.idx())
return 0;
int sel_len = sel_end.pos() - sel_beg.pos();
- LYXERR(Debug::FIND, "sel_beg: " << sel_beg << ", sel_end: " << sel_end
+ LYXERR(Debug::FINDVERBOSE, "sel_beg: " << sel_beg << ", sel_end: " << sel_end
<< ", sel_len: " << sel_len << endl);
if (sel_len == 0)
return 0;
repl_buffer.setUnnamed(true);
LASSERT(repl_buffer.readString(lyx), return 0);
if (opt.keep_case && sel_len >= 2) {
- LYXERR(Debug::FIND, "keep_case true: cur.pos()=" << cur.pos() << ", sel_len=" << sel_len);
+ LYXERR(Debug::FINDVERBOSE, "keep_case true: cur.pos()=" << cur.pos() << ", sel_len=" << sel_len);
if (cur.inTexted()) {
if (firstUppercase(cur))
changeFirstCase(repl_buffer, text_uppercase, text_lowercase);
repl_buffer.changeLanguage(
repl_buffer.language(),
cur.getFont().language());
- LYXERR(Debug::FIND, "Replacing by pasteParagraphList()ing repl_buffer");
- LYXERR(Debug::FIND, "Before pasteParagraphList() cur=" << cur << endl);
+ LYXERR(Debug::FINDVERBOSE, "Replacing by pasteParagraphList()ing repl_buffer");
+ LYXERR(Debug::FINDVERBOSE, "Before pasteParagraphList() cur=" << cur << endl);
cap::pasteParagraphList(cur, repl_buffer.paragraphs(),
repl_buffer.params().documentClassPtr(),
repl_buffer.params().authors(),
bv->buffer().errorList("Paste"));
- LYXERR(Debug::FIND, "After pasteParagraphList() cur=" << cur << endl);
+ LYXERR(Debug::FINDVERBOSE, "After pasteParagraphList() cur=" << cur << endl);
sel_len = repl_buffer.paragraphs().begin()->size();
} else if (cur.inMathed()) {
odocstringstream ods;
TeXOnePar(repl_buffer, repl_buffer.text(), 0, os, runparams);
//repl_buffer.getSourceCode(ods, 0, repl_buffer.paragraphs().size(), false);
docstring repl_latex = ods.str();
- LYXERR(Debug::FIND, "Latexified replace_buffer: '" << repl_latex << "'");
+ LYXERR(Debug::FINDVERBOSE, "Latexified replace_buffer: '" << repl_latex << "'");
string s;
(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());
+ LYXERR(Debug::FINDVERBOSE, "Replacing by insert()ing latex: '" << repl_latex << "' cur=" << cur << " with depth=" << cur.depth());
MathData ar(cur.buffer());
asArray(repl_latex, ar, Parse::NORMAL);
cur.insert(ar);
sel_len = ar.size();
- LYXERR(Debug::FIND, "After insert() cur=" << cur << " with depth: " << cur.depth() << " and len: " << sel_len);
+ LYXERR(Debug::FINDVERBOSE, "After insert() cur=" << cur << " with depth: " << cur.depth() << " and len: " << sel_len);
}
if (cur.pos() >= sel_len)
cur.pos() -= sel_len;
else
cur.pos() = 0;
- LYXERR(Debug::FIND, "After pos adj cur=" << cur << " with depth: " << cur.depth() << " and len: " << sel_len);
+ LYXERR(Debug::FINDVERBOSE, "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);
return 1;
// Should never happen, maybe LASSERT() here?
pos_len = cur.lastpos() - cur.pos();
}
- LYXERR(Debug::FIND, "Putting selection at cur=" << cur << " with len: " << pos_len);
+ LYXERR(Debug::FINDVERBOSE|Debug::FIND, "Putting selection at cur=" << cur << " with len: " << pos_len);
bv->putSelectionAt(cur, pos_len, !opt.forward);
return true;
<< int(opt.scope) << ' '
<< int(opt.restr);
- LYXERR(Debug::FIND, "built: " << os.str());
+ LYXERR(Debug::FINDVERBOSE, "built: " << os.str());
return os;
}
istringstream & operator>>(istringstream & is, FindAndReplaceOptions & opt)
{
- // LYXERR(Debug::FIND, "parsing");
+ // LYXERR(Debug::FINDVERBOSE, "parsing");
string s;
string line;
getline(is, line);
break;
getline(is, line);
}
- // LYXERR(Debug::FIND, "file_buf_name: '" << s << "'");
+ // LYXERR(Debug::FINDVERBOSE, "file_buf_name: '" << s << "'");
opt.find_buf_name = from_utf8(s);
is >> opt.casesensitive >> opt.matchword >> opt.forward >> opt.expandmacros >> opt.ignoreformat >> opt.replace_all;
is.get(); // Waste space before replace string
break;
getline(is, line);
}
- // LYXERR(Debug::FIND, "repl_buf_name: '" << s << "'");
+ // LYXERR(Debug::FINDVERBOSE, "repl_buf_name: '" << s << "'");
opt.repl_buf_name = from_utf8(s);
is >> opt.keep_case;
int i;
opt.restr = FindAndReplaceOptions::SearchRestriction(i);
/*
- LYXERR(Debug::FIND, "parsed: " << opt.casesensitive << ' ' << opt.matchword << ' ' << opt.forward << ' '
+ LYXERR(Debug::FINDVERBOSE, "parsed: " << opt.casesensitive << ' ' << opt.matchword << ' ' << opt.forward << ' '
<< opt.expandmacros << ' ' << opt.ignoreformat << ' ' << opt.keep_case << ' '
<< opt.scope << ' ' << opt.restr);
*/
projects / lyx.git / commitdiff