* \author Jürgen Vigna
* \author Alfredo Braunstein
* \author Tommaso Cucinotta
+ * \author Kornel Benko
*
* Full author contact details are available in file CREDITS.
*/
#include "lyxfind.h"
#include "Buffer.h"
-#include "buffer_funcs.h"
#include "BufferList.h"
#include "BufferParams.h"
#include "BufferView.h"
#include "output_latex.h"
#include "OutputParams.h"
#include "Paragraph.h"
-#include "ParIterator.h"
-#include "TexRow.h"
#include "Text.h"
#include "Encoding.h"
#include "frontends/alert.h"
#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 "support/textutils.h"
+
#include <map>
+#include <regex>
+#define USE_QT_FOR_SEARCH
+#if defined(USE_QT_FOR_SEARCH)
+ #include <QtCore> // sets QT_VERSION
+ #if (QT_VERSION >= 0x050000)
+ #include <QRegularExpression>
+ #define QTSEARCH 1
+ #else
+ #define QTSEARCH 0
+ #endif
+#else
+ #define QTSEARCH 0
+#endif
using namespace std;
using namespace lyx::support;
class IgnoreFormats {
public:
///
- IgnoreFormats()
- : ignoreFamily_(false), ignoreSeries_(false),
- ignoreShape_(false), ignoreUnderline_(false),
- ignoreMarkUp_(false), ignoreStrikeOut_(false),
- ignoreSectioning_(false), ignoreFrontMatter_(false),
- ignoreColor_(false), ignoreLanguage_(false) {}
+ IgnoreFormats() = default;
///
- bool getFamily() { return ignoreFamily_; };
+ bool getFamily() const { return ignoreFamily_; }
///
- bool getSeries() { return ignoreSeries_; };
+ bool getSeries() const { return ignoreSeries_; }
///
- bool getShape() { return ignoreShape_; };
+ bool getShape() const { return ignoreShape_; }
///
- bool getUnderline() { return ignoreUnderline_; };
+ bool getUnderline() const { return ignoreUnderline_; }
///
- bool getMarkUp() { return ignoreMarkUp_; };
+ bool getMarkUp() const { return ignoreMarkUp_; }
///
- bool getStrikeOut() { return ignoreStrikeOut_; };
+ bool getStrikeOut() const { return ignoreStrikeOut_; }
///
- bool getSectioning() { return ignoreSectioning_; };
+ bool getSectioning() const { return ignoreSectioning_; }
///
- bool getFrontMatter() { return ignoreFrontMatter_; };
+ bool getFrontMatter() const { return ignoreFrontMatter_; }
///
- bool getColor() { return ignoreColor_; };
+ bool getColor() const { return ignoreColor_; }
///
- bool getLanguage() { return ignoreLanguage_; };
+ bool getLanguage() const { return ignoreLanguage_; }
///
- void setIgnoreFormat(string type, bool value);
+ void setIgnoreFormat(string const & type, bool value);
private:
///
- bool ignoreFamily_;
+ bool ignoreFamily_ = false;
///
- bool ignoreSeries_;
+ bool ignoreSeries_ = false;
///
- bool ignoreShape_;
+ bool ignoreShape_ = false;
///
- bool ignoreUnderline_;
+ bool ignoreUnderline_ = false;
///
- bool ignoreMarkUp_;
+ bool ignoreMarkUp_ = false;
///
- bool ignoreStrikeOut_;
+ bool ignoreStrikeOut_ = false;
///
- bool ignoreSectioning_;
+ bool ignoreSectioning_ = false;
///
- bool ignoreFrontMatter_;
+ bool ignoreFrontMatter_ = false;
///
- bool ignoreColor_;
+ bool ignoreColor_ = false;
///
- bool ignoreLanguage_;
+ bool ignoreLanguage_ = false;
};
-void IgnoreFormats::setIgnoreFormat(string type, bool value)
+void IgnoreFormats::setIgnoreFormat(string const & type, bool value)
{
if (type == "color") {
ignoreColor_ = value;
IgnoreFormats ignoreFormats;
-void setIgnoreFormat(string type, bool value)
+void setIgnoreFormat(string const & type, bool value)
{
ignoreFormats.setIgnoreFormat(type, value);
}
}
-class MatchString : public binary_function<Paragraph, pos_type, int>
+class MatchString
{
public:
- MatchString(docstring const & str, bool cs, bool mw)
- : str(str), case_sens(cs), whole_words(mw)
+ MatchString(docstring const & s, bool cs, bool mw)
+ : str(s), case_sens(cs), whole_words(mw)
{}
// returns true if the specified string is at the specified position
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()) {
- found = findOne(bv, searchstr, case_sens, whole, forward, true, findnext);
+ bool const found = findOne(bv, searchstr, case_sens, whole, forward, true, findnext);
return make_pair(found, 0);
}
// empty search string
// no selection or current selection is not search word:
// just find the search word
if (!have_selection || !match) {
- found = findOne(bv, searchstr, case_sens, whole, forward, true, findnext);
+ bool const found = findOne(bv, searchstr, case_sens, whole, forward, true, findnext);
return make_pair(found, 0);
}
static Escapes escape_map;
if (escape_map.empty()) {
escape_map.push_back(P("\\%", "%"));
+ escape_map.push_back(P("\\{", "{"));
+ 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", "~"));
}
new_pos = s.size();
string t;
if (new_pos > pos) {
+ // outside regexp
LYXERR(Debug::FIND, "new_pos: " << new_pos);
t = apply_escapes(s.substr(pos, new_pos - pos), get_lyx_unescapes());
LYXERR(Debug::FIND, "t [lyx]: " << t);
t = s.substr(new_pos + 8, end_pos - (new_pos + 8));
LYXERR(Debug::FIND, "t in regexp : " << t);
t = apply_escapes(t, get_lyx_unescapes());
- LYXERR(Debug::FIND, "t in regexp [lyx]: " << t);
+ LYXERR(Debug::FIND, "t in regexp after unescapes [lyx]: " << t);
if (match_latex) {
t = apply_escapes(t, get_regexp_latex_escapes());
- LYXERR(Debug::FIND, "t in regexp [ltx]: " << t);
+ LYXERR(Debug::FIND, "t in regexp after latex_escapes [ltx]: " << t);
}
if (end_pos == s.size()) {
s.replace(new_pos, end_pos - new_pos, t);
bool regex_replace(string const & s, string & t, string const & searchstr,
string const & replacestr)
{
- lyx::regex e(searchstr, regex_constants::ECMAScript);
+ regex e(searchstr, regex_constants::ECMAScript);
ostringstream oss;
ostream_iterator<char, char> it(oss);
- lyx::regex_replace(it, s.begin(), s.end(), e, replacestr);
+ regex_replace(it, s.begin(), s.end(), e, replacestr);
// tolerate t and s be references to the same variable
bool rv = (s != oss.str());
t = oss.str();
** @param unmatched
** Number of open braces that must remain open at the end for the verification to succeed.
**/
-bool braces_match(string::const_iterator const & beg,
- string::const_iterator const & end,
+#if QTSEARCH
+bool braces_match(QString const & beg,
int unmatched = 0)
+#else
+bool braces_match(string const & beg,
+ int unmatched = 0)
+#endif
{
int open_pars = 0;
- string::const_iterator it = beg;
- LYXERR(Debug::FIND, "Checking " << unmatched << " unmatched braces in '" << string(beg, end) << "'");
- for (; it != end; ++it) {
+#if QTSEARCH
+ LYXERR(Debug::FIND, "Checking " << unmatched << " unmatched braces in '" << beg.toStdString() << "'");
+#else
+ LYXERR(Debug::FIND, "Checking " << unmatched << " unmatched braces in '" << beg << "'");
+#endif
+ int lastidx = beg.size();
+ for (int i=0; i < lastidx; ++i) {
// Skip escaped braces in the count
- if (*it == '\\') {
- ++it;
- if (it == end)
+#if QTSEARCH
+ QChar c = beg.at(i);
+#else
+ char c = beg.at(i);
+#endif
+ if (c == '\\') {
+ ++i;
+ if (i >= lastidx)
break;
- } else if (*it == '{') {
+ } else if (c == '{') {
++open_pars;
- } else if (*it == '}') {
+ } else if (c == '}') {
if (open_pars == 0) {
LYXERR(Debug::FIND, "Found unmatched closed brace");
return false;
class MatchResult {
public:
+ enum range {
+ newIsTooFar,
+ newIsBetter,
+ newIsInvalid
+ };
int match_len;
+ int match_prefix;
int match2end;
int pos;
- MatchResult(): match_len(0),match2end(0), pos(0) {};
+ int leadsize;
+ MatchResult(): match_len(0),match_prefix(0),match2end(0), pos(0),leadsize(0) {};
};
+static MatchResult::range interpretMatch(MatchResult &oldres, MatchResult &newres)
+{
+ int range = oldres.match_len;
+ if (range < 2) range = 2;
+ if (newres.match2end < oldres.match2end - oldres.match_len)
+ return MatchResult::newIsTooFar;
+ if (newres.match_len < oldres.match_len)
+ return MatchResult::newIsTooFar;
+ if ((newres.match_len == oldres.match_len) &&
+ (newres.match2end < oldres.match2end + range) &&
+ (newres.match2end > oldres.match2end - range)) {
+ return MatchResult::newIsBetter;
+ }
+ return MatchResult::newIsInvalid;
+}
+
/** The class performing a match between a position in the document and the FindAdvOptions.
**/
+
class MatchStringAdv {
public:
MatchStringAdv(lyx::Buffer & buf, FindAndReplaceOptions const & opt);
** The length of the matching text, or zero if no match was found.
**/
MatchResult operator()(DocIterator const & cur, int len = -1, bool at_begin = true) const;
+#if QTSEARCH
+ bool regexIsValid;
+ string regexError;
+#endif
public:
/// buffer
// normalized string to search
string par_as_string;
// regular expression to use for searching
- lyx::regex regexp;
- // same as regexp, but prefixed with a ".*?"
- lyx::regex regexp2;
+ // regexp2 is same as regexp, but prefixed with a ".*?"
+#if QTSEARCH
+ QRegularExpression regexp;
+ QRegularExpression regexp2;
+#else
+ regex regexp;
+ regex regexp2;
+#endif
// leading format material as string
string lead_as_string;
// par_as_string after removal of lead_as_string
// number of (.*?) subexpressions added at end of search regexp for closing
// environments, math mode, styles, etc...
int close_wildcards;
+public:
// Are we searching with regular expressions ?
bool use_regexp;
};
odocstringstream ods;
otexstream os(ods);
runparams.nice = true;
- runparams.flavor = OutputParams::XETEX;
+ runparams.flavor = Flavor::XeTeX;
runparams.linelen = 10000; //lyxrc.plaintext_linelen;
// No side effect of file copying and image conversion
runparams.dryrun = true;
// OutputParams runparams(&buffer.params().encoding());
OutputParams runparams(encodings.fromLyXName("utf8"));
runparams.nice = true;
- runparams.flavor = OutputParams::XETEX;
+ runparams.flavor = Flavor::XeTeX;
runparams.linelen = 10000; //lyxrc.plaintext_linelen;
runparams.dryrun = true;
runparams.for_search = true;
AS_STR_INSETS | AS_STR_SKIPDELETE | AS_STR_PLAINTEXT,
&runparams);
}
+ // Even in ignore-format we have to remove "\text{}, \lyxmathsym{}" parts
+ string t = to_utf8(str);
+ while (regex_replace(t, t, "\\\\(text|lyxmathsym)\\{([^\\}]*)\\}", "$2"));
+ str = from_utf8(t);
}
return str;
}
// @TODO Support \item[text]
// Kornel: Added textsl, textsf, textit, texttt and noun
// + allow to search for colored text too
- while (regex_replace(t, t, REGEX_BOS "\\\\(((footnotesize|tiny|scriptsize|small|large|Large|LARGE|huge|Huge|emph|noun|minisec|text(bf|md|sl|sf|it|tt))|((textcolor|foreignlanguage|latexenvironment)\\{[a-z]+\\*?\\})|(u|uu)line|(s|x)out|uwave)|((sub)?(((sub)?section)|paragraph)|part|chapter)\\*?)\\{", "")
- || regex_replace(t, t, REGEX_BOS "\\$", "")
- || regex_replace(t, t, REGEX_BOS "\\\\\\[ ", "")
- || regex_replace(t, t, REGEX_BOS " ?\\\\item\\{[a-z]+\\}", "")
- || regex_replace(t, t, REGEX_BOS "\\\\begin\\{[a-zA-Z_]*\\*?\\} ", ""))
+ while (regex_replace(t, t, "^\\\\(("
+ "(author|title|subtitle|subject|publishers|dedication|uppertitleback|lowertitleback|extratitle|"
+ "lyxaddress|lyxrightaddress|"
+ "footnotesize|tiny|scriptsize|small|large|Large|LARGE|huge|Huge|"
+ "emph|noun|minisec|text(bf|md|sl|sf|it|tt))|"
+ "((textcolor|foreignlanguage|latexenvironment)\\{[a-z]+\\*?\\})|"
+ "(u|uu)line|(s|x)out|uwave)|((sub)?(((sub)?section)|paragraph)|part|chapter)\\*?)\\{", "")
+ || regex_replace(t, t, "^\\$", "")
+ || regex_replace(t, t, "^\\\\\\[", "")
+ || 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 << "'");
return s.find(t);
}
}
}
- return(info);
+ return info;
}
/*
noContent,
/* Char, like \backslash */
isChar,
+ /* replace starting backslash with '#' */
+ isText,
/* \part, \section*, ... */
isSectioning,
/* title, author etc */
isIgnored,
/* like \lettrine[lines=5]{}{} */
cleanToStart,
+ // like isStandard, but always remove head
+ headRemove,
/* End of arguments marker for lettrine,
* so that they can be ignored */
endArguments
};
- KeyInfo()
- : keytype(invalid),
- head(""),
- _tokensize(-1),
- _tokenstart(-1),
- _dataStart(-1),
- _dataEnd(-1),
- parenthesiscount(1),
- disabled(false),
- used(false)
- {};
+ KeyInfo() = default;
KeyInfo(KeyType type, int parcount, bool disable)
: keytype(type),
- _tokensize(-1),
- _tokenstart(-1),
- _dataStart(-1),
- _dataEnd(-1),
parenthesiscount(parcount),
- disabled(disable),
- used(false) {};
- KeyType keytype;
+ disabled(disable) {}
+ KeyType keytype = invalid;
string head;
- int _tokensize;
- int _tokenstart;
- int _dataStart;
- int _dataEnd;
- int parenthesiscount;
- bool disabled;
- bool used; /* by pattern */
+ int _tokensize = -1;
+ int _tokenstart = -1;
+ int _dataStart = -1;
+ int _dataEnd = -1;
+ int parenthesiscount = 1;
+ bool disabled = false;
+ bool used = false; /* by pattern */
};
class Border {
int upper;
};
-static vector<Border> borders = vector<Border>(30);
-
#define MAXOPENED 30
class Intervall {
- bool isPatternString;
- public:
- explicit Intervall(bool isPattern) :
- isPatternString(isPattern),
- ignoreidx(-1),
- actualdeptindex(0) { depts[0] = 0; closes[0] = 0;};
+ bool isPatternString_;
+public:
+ explicit Intervall(bool isPattern, string const & p) :
+ isPatternString_(isPattern), par(p), ignoreidx(-1), actualdeptindex(0),
+ hasTitle(false), langcount(0)
+ {
+ depts[0] = 0;
+ closes[0] = 0;
+ }
+
string par;
int ignoreidx;
+ static vector<Border> borders;
int depts[MAXOPENED];
int closes[MAXOPENED];
int actualdeptindex;
- int previousNotIgnored(int);
- int nextNotIgnored(int);
+ int previousNotIgnored(int) const;
+ int nextNotIgnored(int) const;
void handleOpenP(int i);
void handleCloseP(int i, bool closingAllowed);
void resetOpenedP(int openPos);
void addIntervall(int upper);
void addIntervall(int low, int upper); /* if explicit */
void removeAccents();
- void setForDefaultLang(KeyInfo &defLang);
+ void setForDefaultLang(KeyInfo const & defLang) const;
int findclosing(int start, int end, char up, char down, int repeat);
void handleParentheses(int lastpos, bool closingAllowed);
bool hasTitle;
- int isOpeningPar(int pos);
+ int langcount; // Number of disabled language specs up to current position in actual interval
+ int isOpeningPar(int pos) const;
string titleValue;
void output(ostringstream &os, int lastpos);
// string show(int lastpos);
};
-int Intervall::isOpeningPar(int pos)
+vector<Border> Intervall::borders = vector<Border>(30);
+
+int Intervall::isOpeningPar(int pos) const
{
if ((pos < 0) || (size_t(pos) >= par.size()))
return 0;
return 1;
}
-void Intervall::setForDefaultLang(KeyInfo &defLang)
+void Intervall::setForDefaultLang(KeyInfo const & defLang) const
{
// Enable the use of first token again
if (ignoreidx >= 0) {
int value = defLang._tokenstart + defLang._tokensize;
+ int borderidx = 0;
+ if (hasTitle) {
+ borderidx = 1;
+ }
if (value > 0) {
- if (borders[0].low < value)
- borders[0].low = value;
- if (borders[0].upper < value)
- borders[0].upper = value;
+ if (borders[borderidx].low < value)
+ borders[borderidx].low = value;
+ if (borders[borderidx].upper < value)
+ borders[borderidx].upper = value;
}
}
}
static int maxdepthidx = MAXOPENED-2;
static int lastmaxdepth = 0;
if (val > lastmaxdepth) {
- LYXERR0("Depth reached " << val);
+ LYXERR(Debug::INFO, "Depth reached " << val);
lastmaxdepth = val;
}
if (val > maxdepthidx) {
maxdepthidx = val;
- LYXERR0("maxdepthidx now " << val);
+ LYXERR(Debug::INFO, "maxdepthidx now " << val);
}
}
{
static int lastmaxignore = -1;
if ((lastmaxignore < val) && (size_t(val+1) >= borders.size())) {
- LYXERR0("IgnoreIdx reached " << val);
+ LYXERR(Debug::INFO, "IgnoreIdx reached " << val);
lastmaxignore = val;
}
}
const char delim = '|';
while (getline(s, name, delim)) {
size_t start = 0;
- for (size_t i = 0; i < param.size(); i++) {
- string key = name + "{" + param[i] + "}";
+ for (char c : param) {
+ string key = name + "{" + c + "}";
// get the corresponding utf8-value
if ((values[start] & 0xc0) != 0xc0) {
// should not happen, utf8 encoding starts at least with 11xxxxxx
if ((values[start] & 0x80) == 0) {
// is ascii
accents[key] = values.substr(start, 1);
- // LYXERR0("" << key << "=" << accents[key]);
+ // LYXERR(Debug::INFO, "" << key << "=" << accents[key]);
}
start++;
continue;
// This is the first byte of following utf8 char
accents[key] = values.substr(start, j);
start += j;
- // LYXERR0("" << key << "=" << accents[key]);
+ // LYXERR(Debug::INFO, "" << key << "=" << accents[key]);
break;
}
}
}
}
+// Helper function
+static string getutf8(unsigned uchar)
+{
+ #define maxc 5
+ string ret = string();
+ char c[maxc] = {0};
+ if (uchar <= 0x7f) {
+ c[maxc-1] = uchar & 0x7f;
+ }
+ else {
+ unsigned char rest = 0x40;
+ unsigned char first = 0x80;
+ int start = maxc-1;
+ for (int i = start; i >=0; --i) {
+ if (uchar < rest) {
+ c[i] = first + uchar;
+ break;
+ }
+ c[i] = 0x80 | (uchar & 0x3f);
+ uchar >>= 6;
+ rest >>= 1;
+ first >>= 1;
+ first |= 0x80;
+ }
+ }
+ for (int i = 0; i < maxc; i++) {
+ if (c[i] == 0) continue;
+ ret += c[i];
+ }
+ return(ret);
+}
+
static void buildAccentsMap()
{
accents["imath"] = "ı";
accents["i"] = "ı";
accents["jmath"] = "ȷ";
- accents["lyxmathsym{ß}"] = "ß";
- accents["text{ß}"] = "ß";
+ accents["cdot"] = "·";
+ accents["hairspace"] = getutf8(0xf0000); // select from free unicode plane 15
+ accents["thinspace"] = getutf8(0xf0002); // and used _only_ by findadv
+ accents["negthinspace"] = getutf8(0xf0003); // to omit backslashed latex macros
+ accents["medspace"] = getutf8(0xf0004); // See https://en.wikipedia.org/wiki/Private_Use_Areas
+ accents["negmedspace"] = getutf8(0xf0005);
+ accents["thickspace"] = getutf8(0xf0006);
+ accents["negthickspace"] = getutf8(0xf0007);
+ accents["lyx"] = getutf8(0xf0010); // Used logos
+ accents["LyX"] = getutf8(0xf0010);
+ accents["tex"] = getutf8(0xf0011);
+ accents["TeX"] = getutf8(0xf0011);
+ accents["latex"] = getutf8(0xf0012);
+ accents["LaTeX"] = getutf8(0xf0012);
+ accents["latexe"] = getutf8(0xf0013);
+ accents["LaTeXe"] = getutf8(0xf0013);
+ accents["lyxarrow"] = getutf8(0xf0020);
+ accents["backslash lyx"] = getutf8(0xf0010); // Used logos inserted with starting \backslash
+ accents["backslash LyX"] = getutf8(0xf0010);
+ accents["backslash tex"] = getutf8(0xf0011);
+ accents["backslash TeX"] = getutf8(0xf0011);
+ accents["backslash latex"] = getutf8(0xf0012);
+ accents["backslash LaTeX"] = getutf8(0xf0012);
+ accents["backslash latexe"] = getutf8(0xf0013);
+ accents["backslash LaTeXe"] = getutf8(0xf0013);
+ accents["backslash lyxarrow"] = getutf8(0xf0020);
accents["ddot{\\imath}"] = "ï";
- buildaccent("ddot", "aAeEiIioOuUyY",
- "äÄëËïÏïöÖüÜÿŸ"); // umlaut
- buildaccent("dot|.", "cCeEGgIizZaAoObBdDfFyY",
- "ċĊėĖĠġİİżŻȧȦȯȮḃḂḋḊḟḞẏẎ"); // dot{i} can only happen if ignoring case, but there is no lowercase of 'İ'
+ buildaccent("ddot", "aAeEhHiIioOtuUwWxXyY",
+ "äÄëËḧḦïÏïöÖẗüÜẅẄẍẌÿŸ"); // umlaut
+ buildaccent("dot|.", "aAbBcCdDeEfFGghHIimMnNoOpPrRsStTwWxXyYzZ",
+ "ȧȦḃḂċĊḋḊėĖḟḞĠġḣḢİİṁṀṅṄȯȮṗṖṙṘṡṠṫṪẇẆẋẊẏẎżŻ"); // dot{i} can only happen if ignoring case, but there is no lowercase of 'İ'
accents["acute{\\imath}"] = "í";
- buildaccent("acute", "aAcCeElLoOnNrRsSuUyYzZiI",
- "áÁćĆéÉĺĹóÓńŃŕŔśŚúÚýÝźŹíÍ");
+ buildaccent("acute", "aAcCeEgGkKlLmMoOnNpPrRsSuUwWyYzZiI",
+ "áÁćĆéÉǵǴḱḰĺĹḿḾóÓńŃṕṔŕŔśŚúÚẃẂýÝźŹíÍ");
buildaccent("dacute|H|h", "oOuU", "őŐűŰ"); // double acute
buildaccent("mathring|r", "aAuUwy",
"åÅůŮẘẙ"); // ring
"čČďĎǎǍěĚǐǏǒǑǔǓǧǦǩǨȟȞľĽňŇřŘšŠŤťžŽ"); // caron
accents["hat{\\imath}"] = "î";
accents["hat{\\jmath}"] = "ĵ";
- buildaccent("hat|^", "aAeEiIcCgGhHjJsSwWyYzZoOuU",
- "âÂêÊîÎĉĈĝĜĥĤĵĴŝŜŵŴŷŶẑẐôÔûÛ"); // circ
+ buildaccent("hat|^", "aAcCeEgGhHiIjJoOsSuUwWyYzZ",
+ "âÂĉĈêÊĝĜĥĤîÎĵĴôÔŝŜûÛŵŴŷŶẑẐ"); // circ
accents["bar{\\imath}"] = "ī";
buildaccent("bar|=", "aAeEiIoOuUyY",
"āĀēĒīĪōŌūŪȳȲ"); // macron
accents["tilde{\\imath}"] = "ĩ";
- buildaccent("tilde", "aAnNoOiIuU",
- "ãÃñÑõÕĩĨũŨ"); // tilde
+ buildaccent("tilde", "aAeEiInNoOuUvVyY",
+ "ãÃẽẼĩĨñÑõÕũŨṽṼỹỸ"); // tilde
accents["breve{\\imath}"] = "ĭ";
buildaccent("breve|u", "aAeEgGiIoOuU",
"ăĂĕĔğĞĭĬŏŎŭŬ"); // breve
buildaccent("ogonek|k", "AaEeIiUuOo",
"ĄąĘęĮįŲųǪǫ"); // ogonek
buildaccent("cedilla|c", "CcGgKkLlNnRrSsTtEeDdHh",
- "Ã\87çĢĢĶķĻļŅņŖŗŞşŢţȨȩḐḑḨḩ"); // cedilla
+ "Ã\87çĢģĶķĻļŅņŖŗŞşŢţȨȩḐḑḨḩ"); // cedilla
buildaccent("subring|textsubring", "Aa",
"Ḁḁ"); // subring
buildaccent("subhat|textsubcircum", "DdEeLlNnTtUu",
"ḒḓḘḙḼḽṊṋṰṱṶṷ"); // subcircum
buildaccent("subtilde|textsubtilde", "EeIiUu",
"ḚḛḬḭṴṵ"); // subtilde
+ accents["dgrave{\\imath}"] = "ȉ";
+ accents["textdoublegrave{\\i}"] = "ȉ";
+ buildaccent("dgrave|textdoublegrave", "AaEeIiOoRrUu",
+ "ȀȁȄȅȈȉȌȍȐȑȔȕ"); // double grave
+ accents["rcap{\\imath}"] = "ȉ";
+ accents["textroundcap{\\i}"] = "ȉ";
+ buildaccent("rcap|textroundcap", "AaEeIiOoRrUu",
+ "ȂȃȆȇȊȋȎȏȒȓȖȗ"); // inverted breve
+ buildaccent("slashed", "oO",
+ "øØ"); // slashed
}
/*
{
if (accents.empty())
buildAccentsMap();
- static regex const accre("\\\\(([\\S]|grave|breve|lyxmathsym|text|ddot|dot|acute|dacute|mathring|check|hat|bar|tilde|subdot|ogonek|cedilla|subring|textsubring|subhat|textsubcircum|subtilde|textsubtilde)\\{[^\\{\\}]+\\}|(i|imath|jmath)(?![a-zA-Z]))");
+ static regex const accre("\\\\(([\\S]|grave|breve|ddot|dot|acute|dacute|mathring|check|hat|bar|tilde|subdot|ogonek|"
+ "cedilla|subring|textsubring|subhat|textsubcircum|subtilde|textsubtilde|dgrave|textdoublegrave|rcap|textroundcap|slashed)\\{[^\\{\\}]+\\}"
+ "|((i|imath|jmath|cdot|[a-z]+space)|((backslash )?([lL]y[xX]|[tT]e[xX]|[lL]a[tT]e[xX]e?|lyxarrow)))(?![a-zA-Z]))");
smatch sub;
for (sregex_iterator itacc(par.begin(), par.end(), accre), end; itacc != end; ++itacc) {
sub = *itacc;
for (size_t i = 0; i < val.size(); i++) {
par[pos+i] = val[i];
}
- addIntervall(pos+val.size(), pos + sub.str(0).size());
+ // Remove possibly following space too
+ if (par[pos+sub.str(0).size()] == ' ')
+ addIntervall(pos+val.size(), pos + sub.str(0).size()+1);
+ else
+ addIntervall(pos+val.size(), pos + sub.str(0).size());
for (size_t i = pos+val.size(); i < pos + sub.str(0).size(); i++) {
// remove traces of any remaining chars
par[i] = ' ';
}
}
else {
- LYXERR0("Not added accent for \"" << key << "\"");
+ LYXERR(Debug::INFO, "Not added accent for \"" << key << "\"");
}
}
}
closes[1] = -1;
}
-int Intervall::previousNotIgnored(int start)
+int Intervall::previousNotIgnored(int start) const
{
int idx = 0; /* int intervalls */
for (idx = ignoreidx; idx >= 0; --idx) {
return start;
}
-int Intervall::nextNotIgnored(int start)
+int Intervall::nextNotIgnored(int start) const
{
int idx = 0; /* int intervalls */
for (idx = 0; idx <= ignoreidx; idx++) {
class LatexInfo {
private:
- int entidx;
- Entries entries;
- Intervall interval;
+ int entidx_;
+ Entries entries_;
+ Intervall interval_;
void buildKeys(bool);
void buildEntries(bool);
void makeKey(const string &, KeyInfo, bool isPatternString);
void processRegion(int start, int region_end); /* remove {} parts */
- void removeHead(KeyInfo&, int count=0);
+ void removeHead(KeyInfo const &, int count=0);
public:
- LatexInfo(string par, bool isPatternString) : entidx(-1), interval(isPatternString) {
- interval.par = par;
- interval.hasTitle = false;
- interval.titleValue = "";
+ LatexInfo(string const & par, bool isPatternString)
+ : entidx_(-1), interval_(isPatternString, par)
+ {
buildKeys(isPatternString);
- entries = vector<KeyInfo>();
+ entries_ = vector<KeyInfo>();
buildEntries(isPatternString);
};
int getFirstKey() {
- entidx = 0;
- if (entries.empty()) {
- return (-1);
- }
- if (entries[0].keytype == KeyInfo::isTitle) {
- if (! entries[0].disabled) {
- interval.hasTitle = true;
- interval.titleValue = entries[0].head;
+ entidx_ = 0;
+ if (entries_.empty()) {
+ return -1;
+ }
+ if (entries_[0].keytype == KeyInfo::isTitle) {
+ interval_.hasTitle = true;
+ if (! entries_[0].disabled) {
+ interval_.titleValue = entries_[0].head;
}
else {
- interval.hasTitle = false;
- interval.titleValue = "";
+ interval_.titleValue = "";
}
- removeHead(entries[0]);
- if (entries.size() > 1)
- return (1);
+ removeHead(entries_[0]);
+ if (entries_.size() > 1)
+ return 1;
else
- return (-1);
+ return -1;
}
return 0;
};
int getNextKey() {
- entidx++;
- if (int(entries.size()) > entidx) {
- return entidx;
+ entidx_++;
+ if (int(entries_.size()) > entidx_) {
+ return entidx_;
}
else {
- return (-1);
+ return -1;
}
};
bool setNextKey(int idx) {
- if ((idx == entidx) && (entidx >= 0)) {
- entidx--;
+ if ((idx == entidx_) && (entidx_ >= 0)) {
+ entidx_--;
return true;
}
else
return false;
};
- int find(int start, KeyInfo::KeyType keytype) {
+ int find(int start, KeyInfo::KeyType keytype) const {
if (start < 0)
- return (-1);
+ return -1;
int tmpIdx = start;
- while (tmpIdx < int(entries.size())) {
- if (entries[tmpIdx].keytype == keytype)
+ while (tmpIdx < int(entries_.size())) {
+ if (entries_[tmpIdx].keytype == keytype)
return tmpIdx;
tmpIdx++;
}
- return(-1);
+ return -1;
};
- int process(ostringstream &os, KeyInfo &actual);
- int dispatch(ostringstream &os, int previousStart, KeyInfo &actual);
+ int process(ostringstream & os, KeyInfo const & actual);
+ int dispatch(ostringstream & os, int previousStart, KeyInfo & actual);
// string show(int lastpos) { return interval.show(lastpos);};
- int nextNotIgnored(int start) { return interval.nextNotIgnored(start);};
+ int nextNotIgnored(int start) { return interval_.nextNotIgnored(start);};
KeyInfo &getKeyInfo(int keyinfo) {
static KeyInfo invalidInfo = KeyInfo();
- if ((keyinfo < 0) || ( keyinfo >= int(entries.size())))
+ if ((keyinfo < 0) || ( keyinfo >= int(entries_.size())))
return invalidInfo;
else
- return entries[keyinfo];
+ return entries_[keyinfo];
};
- void setForDefaultLang(KeyInfo &defLang) {interval.setForDefaultLang(defLang);};
- void addIntervall(int low, int up) { interval.addIntervall(low, up); };
+ void setForDefaultLang(KeyInfo const & defLang) {interval_.setForDefaultLang(defLang);};
+ void addIntervall(int low, int up) { interval_.addIntervall(low, up); };
};
{
int skip = 0;
int depth = 0;
- repeat--;
for (int i = start; i < end; i += 1 + skip) {
char c;
c = par[i];
}
else if (c == down) {
if (depth == 0) {
+ repeat--;
if ((repeat <= 0) || (par[i+1] != up))
return i;
}
size_t mathStart;
size_t mathSize;
};
- size_t actualIdx;
- vector<MathEntry> entries;
+ size_t actualIdx_;
+ vector<MathEntry> entries_;
public:
MathInfo() {
- actualIdx = 0;
+ actualIdx_ = 0;
}
- void insert(string wait, size_t start, size_t end) {
+ void insert(string const & wait, size_t start, size_t end) {
MathEntry m = MathEntry();
m.wait = wait;
m.mathStart = start;
m.mathEnd = end;
m.mathSize = end - start;
- entries.push_back(m);
+ entries_.push_back(m);
}
- bool empty() { return entries.empty(); };
- size_t getEndPos() {
- if (entries.empty() || (actualIdx >= entries.size())) {
+ bool empty() const { return entries_.empty(); };
+ size_t getEndPos() const {
+ if (entries_.empty() || (actualIdx_ >= entries_.size())) {
return 0;
}
- return entries[actualIdx].mathEnd;
+ return entries_[actualIdx_].mathEnd;
}
- size_t getStartPos() {
- if (entries.empty() || (actualIdx >= entries.size())) {
+ size_t getStartPos() const {
+ if (entries_.empty() || (actualIdx_ >= entries_.size())) {
return 100000; /* definitely enough? */
}
- return entries[actualIdx].mathStart;
+ return entries_[actualIdx_].mathStart;
}
size_t getFirstPos() {
- actualIdx = 0;
+ actualIdx_ = 0;
return getStartPos();
}
- size_t getSize() {
- if (entries.empty() || (actualIdx >= entries.size())) {
+ size_t getSize() const {
+ if (entries_.empty() || (actualIdx_ >= entries_.size())) {
return size_t(0);
}
- return entries[actualIdx].mathSize;
+ return entries_[actualIdx_].mathSize;
}
- void incrEntry() { actualIdx++; };
+ void incrEntry() { actualIdx_++; };
};
void LatexInfo::buildEntries(bool isPatternString)
bool math_end_waiting = false;
size_t math_pos = 10000;
string math_end;
+ static vector<string> usedText = vector<string>();
- interval.removeAccents();
+ interval_.removeAccents();
- for (sregex_iterator itmath(interval.par.begin(), interval.par.end(), rmath), end; itmath != end; ++itmath) {
+ for (sregex_iterator itmath(interval_.par.begin(), interval_.par.end(), rmath), end; itmath != end; ++itmath) {
submath = *itmath;
if (math_end_waiting) {
size_t pos = submath.position(size_t(0));
if ((math_end == "$") &&
(submath.str(0) == "$") &&
- (interval.par[pos-1] != '\\')) {
+ (interval_.par[pos-1] != '\\')) {
mi.insert("$", math_pos, pos + 1);
math_end_waiting = false;
}
continue;
}
else {
+ size_t pos = submath.position(size_t(0));
+ if ((pos > 0) && (interval_.par[pos-1] == '\\'))
+ continue;
if (submath.str(1).compare("begin") == 0) {
math_end_waiting = true;
math_end = submath.str(2);
}
else if (submath.str(0) == "$") {
size_t pos = submath.position(size_t(0));
- if ((pos == 0) || (interval.par[pos-1] != '\\')) {
+ if ((pos == 0) || (interval_.par[pos-1] != '\\')) {
math_end_waiting = true;
math_end = "$";
math_pos = pos;
}
// Ignore language if there is math somewhere in pattern-string
if (isPatternString) {
+ for (auto s: usedText) {
+ // Remove entries created in previous search runs
+ keys.erase(s);
+ }
+ usedText = vector<string>();
if (! mi.empty()) {
// Disable language
keys["foreignlanguage"].disabled = true;
}
}
math_pos = mi.getFirstPos();
- for (sregex_iterator it(interval.par.begin(), interval.par.end(), rkeys), end; it != end; ++it) {
+ for (sregex_iterator it(interval_.par.begin(), interval_.par.end(), rkeys), end; it != end; ++it) {
sub = *it;
string key = sub.str(3);
if (key == "") {
key = sub.str(0);
if (key == "$") {
size_t k_pos = sub.position(size_t(0));
- if ((k_pos > 0) && (interval.par[k_pos - 1] == '\\')) {
+ if ((k_pos > 0) && (interval_.par[k_pos - 1] == '\\')) {
// Escaped '$', ignoring
continue;
}
}
}
- };
+ }
+ else {
+ size_t pos = sub.position(size_t(0));
+ if ((pos > 0) && (interval_.par[pos-1] == '\\'))
+ continue;
+ }
+ if (keys.find(key) != keys.end()) {
+ if (keys[key].keytype == KeyInfo::headRemove) {
+ KeyInfo found1 = keys[key];
+ found1.disabled = true;
+ found1.head = "\\" + key + "{";
+ found1._tokenstart = sub.position(size_t(0));
+ found1._tokensize = found1.head.length();
+ found1._dataStart = found1._tokenstart + found1.head.length();
+ int endpos = interval_.findclosing(found1._dataStart, interval_.par.length(), '{', '}', 1);
+ found1._dataEnd = endpos;
+ removeHead(found1);
+ continue;
+ }
+ }
if (evaluatingRegexp) {
if (sub.str(1).compare("endregexp") == 0) {
evaluatingRegexp = false;
found._dataStart = found._dataEnd;
found._tokensize = found._dataEnd - found._tokenstart;
found.parenthesiscount = 0;
- found.head = interval.par.substr(found._tokenstart, found._tokensize);
+ found.head = interval_.par.substr(found._tokenstart, found._tokensize);
}
else {
continue;
}
if (keys.find(key) == keys.end()) {
found = KeyInfo(KeyInfo::isStandard, 0, true);
+ LYXERR(Debug::INFO, "Undefined key " << key << " ==> will be used as text");
+ found = KeyInfo(KeyInfo::isText, 0, false);
if (isPatternString) {
found.keytype = KeyInfo::isChar;
found.disabled = false;
found.used = true;
}
keys[key] = found;
+ usedText.push_back(key);
}
else
found = keys[key];
found._dataEnd = found._tokenstart + found._tokensize;
found._dataStart = found._dataEnd;
found.parenthesiscount = 0;
- found.head = interval.par.substr(found._tokenstart, found._tokensize);
+ found.head = interval_.par.substr(found._tokenstart, found._tokensize);
evaluatingMath = true;
}
else {
int pos = sub.position(size_t(0));
int count;
for (count = 0; pos - count > 0; count++) {
- char c = interval.par[pos-count-1];
+ char c = interval_.par[pos-count-1];
if (discardComment) {
if ((c != ' ') && (c != '%'))
break;
if (sub.str(1).compare(0, 5, "begin") == 0) {
size_t pos1 = pos + sub.str(0).length();
if (sub.str(5).compare("cjk") == 0) {
- pos1 = interval.findclosing(pos1+1, interval.par.length()) + 1;
- if ((interval.par[pos1] == '{') && (interval.par[pos1+1] == '}'))
+ pos1 = interval_.findclosing(pos1+1, interval_.par.length()) + 1;
+ if ((interval_.par[pos1] == '{') && (interval_.par[pos1+1] == '}'))
pos1 += 2;
found.keytype = KeyInfo::isMain;
found._dataStart = pos1;
- found._dataEnd = interval.par.length();
+ found._dataEnd = interval_.par.length();
found.disabled = keys["foreignlanguage"].disabled;
found.used = keys["foreignlanguage"].used;
found._tokensize = pos1 - found._tokenstart;
- found.head = interval.par.substr(found._tokenstart, found._tokensize);
+ found.head = interval_.par.substr(found._tokenstart, found._tokensize);
}
else {
// Swallow possible optional params
- while (interval.par[pos1] == '[') {
- pos1 = interval.findclosing(pos1+1, interval.par.length(), '[', ']')+1;
+ while (interval_.par[pos1] == '[') {
+ pos1 = interval_.findclosing(pos1+1, interval_.par.length(), '[', ']')+1;
}
// Swallow also the eventual parameter
- if (interval.par[pos1] == '{') {
- found._dataEnd = interval.findclosing(pos1+1, interval.par.length()) + 1;
+ if (interval_.par[pos1] == '{') {
+ found._dataEnd = interval_.findclosing(pos1+1, interval_.par.length()) + 1;
}
else {
found._dataEnd = pos1;
found._dataStart = found._dataEnd;
found._tokensize = count + found._dataEnd - pos;
found.parenthesiscount = 0;
- found.head = interval.par.substr(found._tokenstart, found._tokensize);
+ found.head = interval_.par.substr(found._tokenstart, found._tokensize);
found.disabled = true;
}
}
found._dataEnd = found._dataStart;
found._tokensize = count + found._dataEnd - pos;
found.parenthesiscount = 0;
- found.head = interval.par.substr(found._tokenstart, found._tokensize);
+ found.head = interval_.par.substr(found._tokenstart, found._tokensize);
found.disabled = true;
}
}
if (found.parenthesiscount == 0) {
// Probably to be discarded
size_t following_pos = sub.position(size_t(0)) + sub.str(3).length() + 1;
- char following = interval.par[following_pos];
+ char following = interval_.par[following_pos];
if (following == ' ')
found.head = "\\" + sub.str(3) + " ";
else if (following == '=') {
}
}
int optend = params;
- while (interval.par[optend] == '[') {
+ while (interval_.par[optend] == '[') {
// discard optional parameters
- optend = interval.findclosing(optend+1, interval.par.length(), '[', ']') + 1;
+ optend = interval_.findclosing(optend+1, interval_.par.length(), '[', ']') + 1;
}
if (optend > params) {
- key += interval.par.substr(params, optend-params);
+ key += interval_.par.substr(params, optend-params);
evaluatingOptional = true;
optionalEnd = optend;
}
string token = sub.str(5);
- int closings = found.parenthesiscount;
+ int closings;
+ if (interval_.par[optend] != '{') {
+ closings = 0;
+ found.parenthesiscount = 0;
+ found.head = "\\" + key;
+ }
+ else
+ closings = found.parenthesiscount;
if (found.parenthesiscount == 1) {
found.head = "\\" + key + "{";
}
}
found._tokensize = found.head.length();
found._dataStart = found._tokenstart + found.head.length();
- if (interval.par.substr(found._dataStart-1, 15).compare("\\endarguments{}") == 0) {
+ if (found.keytype == KeyInfo::doRemove) {
+ if (closings > 0) {
+ size_t endpar = 2 + interval_.findclosing(found._dataStart, interval_.par.length(), '{', '}', closings);
+ if (endpar >= interval_.par.length())
+ found._dataStart = interval_.par.length();
+ else
+ found._dataStart = endpar;
+ found._tokensize = found._dataStart - found._tokenstart;
+ }
+ else {
+ found._dataStart = found._tokenstart + found._tokensize;
+ }
+ closings = 0;
+ }
+ if (interval_.par.substr(found._dataStart-1, 15).compare("\\endarguments{}") == 0) {
found._dataStart += 15;
}
- size_t endpos = interval.findclosing(found._dataStart, interval.par.length(), '{', '}', closings);
+ size_t endpos;
+ if (closings < 1)
+ endpos = found._dataStart - 1;
+ else
+ endpos = interval_.findclosing(found._dataStart, interval_.par.length(), '{', '}', closings);
if (found.keytype == KeyInfo::isList) {
// Check if it really is list env
static regex const listre("^([a-z]+)$");
// Disable this key, treate it as standard
found.keytype = KeyInfo::isStandard;
found.disabled = true;
- if ((codeEnd == interval.par.length()) &&
+ if ((codeEnd +1 >= interval_.par.length()) &&
(found._tokenstart == codeStart)) {
// trickery, because the code inset starts
// with \selectlanguage ...
codeEnd = endpos;
- if (entries.size() > 1) {
- entries[entries.size()-1]._dataEnd = codeEnd;
+ if (entries_.size() > 1) {
+ entries_[entries_.size()-1]._dataEnd = codeEnd;
}
}
}
}
- if ((endpos == interval.par.length()) &&
+ if ((endpos == interval_.par.length()) &&
(found.keytype == KeyInfo::doRemove)) {
// Missing closing => error in latex-input?
// therefore do not delete remaining data
keys[key].used = true;
}
}
- entries.push_back(found);
+ entries_.push_back(found);
}
}
static bool keysBuilt = false;
if (keysBuilt && !isPatternString) return;
+ // Keys to ignore in any case
+ makeKey("text|textcyrillic|lyxmathsym", KeyInfo(KeyInfo::headRemove, 1, true), true);
// Known standard keys with 1 parameter.
// Split is done, if not at start of region
makeKey("textsf|textss|texttt", KeyInfo(KeyInfo::isStandard, 1, ignoreFormats.getFamily()), isPatternString);
makeKey("textasciicircum|textasciitilde", KeyInfo(KeyInfo::isChar, 0, false), isPatternString);
makeKey("textasciiacute|texemdash", KeyInfo(KeyInfo::isChar, 0, false), isPatternString);
makeKey("dots|ldots", KeyInfo(KeyInfo::isChar, 0, false), isPatternString);
+ makeKey("guillemotright|guillemotleft", KeyInfo(KeyInfo::isChar, 0, false), isPatternString);
// Spaces
makeKey("quad|qquad|hfill|dotfill", KeyInfo(KeyInfo::isChar, 0, false), isPatternString);
makeKey("textvisiblespace|nobreakspace", KeyInfo(KeyInfo::isChar, 0, false), isPatternString);
makeKey("negthickspace|negmedspace|negthinspace", KeyInfo(KeyInfo::isChar, 0, false), isPatternString);
+ makeKey("thickspace|medspace|thinspace", KeyInfo(KeyInfo::isChar, 0, false), isPatternString);
// Skip
// makeKey("enskip|smallskip|medskip|bigskip|vfill", KeyInfo(KeyInfo::isChar, 0, false), isPatternString);
// Custom space/skip, remove the content (== length value)
// handle like standard keys with 1 parameter.
makeKey("url|href|vref|thanks", KeyInfo(KeyInfo::isStandard, 1, false), isPatternString);
+ // Ignore deleted text
+ makeKey("lyxdeleted", KeyInfo(KeyInfo::doRemove, 3, false), isPatternString);
+ // but preserve added text
+ makeKey("lyxadded", KeyInfo(KeyInfo::doRemove, 2, false), isPatternString);
+
// Macros to remove, but let the parameter survive
// No split
makeKey("menuitem|textmd|textrm", KeyInfo(KeyInfo::isStandard, 1, true), isPatternString);
makeKey("footnotesize|tiny|scriptsize|small|large|Large|LARGE|huge|Huge", KeyInfo(KeyInfo::isSize, 0, false), isPatternString);
// Survives, like known character
- makeKey("lyx|LyX|latex|LaTeX|latexe|LaTeXe|tex|TeX", KeyInfo(KeyInfo::isChar, 0, false), isPatternString);
+ // makeKey("lyx|LyX|latex|LaTeX|latexe|LaTeXe|tex|TeX", KeyInfo(KeyInfo::isChar, 0, false), isPatternString);
+ makeKey("tableofcontents", KeyInfo(KeyInfo::isChar, 0, false), isPatternString);
makeKey("item|listitem", KeyInfo(KeyInfo::isList, 1, false), isPatternString);
makeKey("begin|end", KeyInfo(KeyInfo::isMath, 1, false), isPatternString);
if (lastpos > i) {
s += par.substr(i, lastpos-i);
}
- return (s);
+ return s;
}
#endif
printed += lastpos-i;
}
handleParentheses(lastpos, false);
- for (int i = actualdeptindex; i > 0; --i) {
+ int startindex;
+ if (keys["foreignlanguage"].disabled)
+ startindex = actualdeptindex-langcount;
+ else
+ startindex = actualdeptindex;
+ for (int i = startindex; i > 0; --i) {
os << "}";
}
if (hasTitle && (printed > 0))
os << "}";
- if (! isPatternString)
+ if (! isPatternString_)
os << "\n";
handleParentheses(lastpos, true); /* extra closings '}' allowed here */
}
void LatexInfo::processRegion(int start, int region_end)
{
while (start < region_end) { /* Let {[} and {]} survive */
- int cnt = interval.isOpeningPar(start);
+ int cnt = interval_.isOpeningPar(start);
if (cnt == 1) {
// Closing is allowed past the region
- int closing = interval.findclosing(start+1, interval.par.length());
- interval.addIntervall(start, start+1);
- interval.addIntervall(closing, closing+1);
+ int closing = interval_.findclosing(start+1, interval_.par.length());
+ interval_.addIntervall(start, start+1);
+ interval_.addIntervall(closing, closing+1);
}
else if (cnt == 3)
start += 2;
- start = interval.nextNotIgnored(start+1);
+ start = interval_.nextNotIgnored(start+1);
}
}
-void LatexInfo::removeHead(KeyInfo &actual, int count)
+void LatexInfo::removeHead(KeyInfo const & actual, int count)
{
if (actual.parenthesiscount == 0) {
// "{\tiny{} ...}" ==> "{{} ...}"
- interval.addIntervall(actual._tokenstart-count, actual._tokenstart + actual._tokensize);
+ interval_.addIntervall(actual._tokenstart-count, actual._tokenstart + actual._tokensize);
}
else {
// Remove header hull, that is "\url{abcd}" ==> "abcd"
- interval.addIntervall(actual._tokenstart - count, actual._dataStart);
- interval.addIntervall(actual._dataEnd, actual._dataEnd+1);
+ interval_.addIntervall(actual._tokenstart - count, actual._dataStart);
+ interval_.addIntervall(actual._dataEnd, actual._dataEnd+1);
}
}
int tmpIdx = find(nextKeyIdx, KeyInfo::endArguments);
if (tmpIdx > 0) {
for (int i = nextKeyIdx; i <= tmpIdx; i++) {
- entries[i].disabled = true;
+ entries_[i].disabled = true;
}
- actual._dataEnd = entries[tmpIdx]._dataEnd;
+ actual._dataEnd = entries_[tmpIdx]._dataEnd;
}
- while (interval.par[actual._dataEnd] == ' ')
+ while (interval_.par[actual._dataEnd] == ' ')
actual._dataEnd++;
- interval.addIntervall(0, actual._dataEnd+1);
- interval.actualdeptindex = 0;
- interval.depts[0] = actual._dataEnd+1;
- interval.closes[0] = -1;
+ interval_.addIntervall(0, actual._dataEnd+1);
+ interval_.actualdeptindex = 0;
+ interval_.depts[0] = actual._dataEnd+1;
+ interval_.closes[0] = -1;
break;
}
+ case KeyInfo::isText:
+ interval_.par[actual._tokenstart] = '#';
+ //interval_.addIntervall(actual._tokenstart, actual._tokenstart+1);
+ nextKeyIdx = getNextKey();
+ break;
case KeyInfo::noContent: { /* char like "\hspace{2cm}" */
if (actual.disabled)
- interval.addIntervall(actual._tokenstart, actual._dataEnd);
+ interval_.addIntervall(actual._tokenstart, actual._dataEnd);
else
- interval.addIntervall(actual._dataStart, actual._dataEnd);
+ interval_.addIntervall(actual._dataStart, actual._dataEnd);
}
// fall through
case KeyInfo::isChar: {
break;
}
case KeyInfo::isSize: {
- if (actual.disabled || (interval.par[actual._dataStart] != '{') || (interval.par[actual._dataStart-1] == ' ')) {
- processRegion(actual._dataEnd, actual._dataEnd+1); /* remove possibly following {} */
- interval.addIntervall(actual._tokenstart, actual._dataEnd+1);
+ if (actual.disabled || (interval_.par[actual._dataStart] != '{') || (interval_.par[actual._dataStart-1] == ' ')) {
+ if (actual.parenthesiscount == 0)
+ interval_.addIntervall(actual._tokenstart, actual._dataEnd);
+ else {
+ interval_.addIntervall(actual._tokenstart, actual._dataEnd+1);
+ }
nextKeyIdx = getNextKey();
} else {
// Here _dataStart points to '{', so correct it
actual._dataStart += 1;
actual._tokensize += 1;
actual.parenthesiscount = 1;
- if (interval.par[actual._dataStart] == '}') {
+ if (interval_.par[actual._dataStart] == '}') {
// Determine the end if used like '{\tiny{}...}'
- actual._dataEnd = interval.findclosing(actual._dataStart+1, interval.par.length()) + 1;
- interval.addIntervall(actual._dataStart, actual._dataStart+1);
+ actual._dataEnd = interval_.findclosing(actual._dataStart+1, interval_.par.length()) + 1;
+ interval_.addIntervall(actual._dataStart, actual._dataStart+1);
}
else {
// Determine the end if used like '\tiny{...}'
- actual._dataEnd = interval.findclosing(actual._dataStart, interval.par.length()) + 1;
+ actual._dataEnd = interval_.findclosing(actual._dataStart, interval_.par.length()) + 1;
}
// Split on this key if not at start
- int start = interval.nextNotIgnored(previousStart);
+ int start = interval_.nextNotIgnored(previousStart);
if (start < actual._tokenstart) {
- interval.output(os, actual._tokenstart);
- interval.addIntervall(start, actual._tokenstart);
+ interval_.output(os, actual._tokenstart);
+ interval_.addIntervall(start, actual._tokenstart);
}
// discard entry if at end of actual
nextKeyIdx = process(os, actual);
}
break;
}
- case KeyInfo::endArguments:
+ case KeyInfo::endArguments: {
// Remove trailing '{}' too
actual._dataStart += 1;
actual._dataEnd += 1;
- interval.addIntervall(actual._tokenstart, actual._dataEnd+1);
+ interval_.addIntervall(actual._tokenstart, actual._dataEnd+1);
nextKeyIdx = getNextKey();
break;
+ }
case KeyInfo::noMain:
// fall through
case KeyInfo::isStandard: {
nextKeyIdx = getNextKey();
} else {
// Split on this key if not at datastart of calling entry
- int start = interval.nextNotIgnored(previousStart);
+ int start = interval_.nextNotIgnored(previousStart);
if (start < actual._tokenstart) {
- interval.output(os, actual._tokenstart);
- interval.addIntervall(start, actual._tokenstart);
+ interval_.output(os, actual._tokenstart);
+ interval_.addIntervall(start, actual._tokenstart);
}
// discard entry if at end of actual
nextKeyIdx = process(os, actual);
int tmpIdx = find(nextKeyIdx, KeyInfo::endArguments);
if (tmpIdx > 0) {
for (int i = nextKeyIdx; i <= tmpIdx; i++) {
- entries[i].disabled = true;
+ entries_[i].disabled = true;
}
- actual._dataEnd = entries[tmpIdx]._dataEnd;
+ actual._dataEnd = entries_[tmpIdx]._dataEnd;
}
- interval.addIntervall(actual._tokenstart, actual._dataEnd+1);
+ interval_.addIntervall(actual._tokenstart, actual._dataEnd+1);
break;
}
case KeyInfo::doRemove: {
// Remove the key with all parameters and following spaces
size_t pos;
- for (pos = actual._dataEnd+1; pos < interval.par.length(); pos++) {
- if ((interval.par[pos] != ' ') && (interval.par[pos] != '%'))
+ for (pos = actual._dataEnd+1; pos < interval_.par.length(); pos++) {
+ if ((interval_.par[pos] != ' ') && (interval_.par[pos] != '%'))
break;
}
- interval.addIntervall(actual._tokenstart, pos);
+ // Remove also enclosing parentheses [] and {}
+ int numpars = 0;
+ int spaces = 0;
+ while (actual._tokenstart > numpars) {
+ if (pos+numpars >= interval_.par.size())
+ break;
+ else if (interval_.par[pos+numpars] == ']' && interval_.par[actual._tokenstart-numpars-1] == '[')
+ numpars++;
+ else if (interval_.par[pos+numpars] == '}' && interval_.par[actual._tokenstart-numpars-1] == '{')
+ numpars++;
+ else
+ break;
+ }
+ if (numpars > 0) {
+ if (interval_.par[pos+numpars] == ' ')
+ spaces++;
+ }
+
+ interval_.addIntervall(actual._tokenstart-numpars, pos+numpars+spaces);
nextKeyIdx = getNextKey();
break;
}
// Discard space before _tokenstart
int count;
for (count = 0; count < actual._tokenstart; count++) {
- if (interval.par[actual._tokenstart-count-1] != ' ')
+ if (interval_.par[actual._tokenstart-count-1] != ' ')
break;
}
nextKeyIdx = getNextKey();
// with arguments
// How else can we catch this one?
for (int i = nextKeyIdx; i <= tmpIdx; i++) {
- entries[i].disabled = true;
+ entries_[i].disabled = true;
}
- actual._dataEnd = entries[tmpIdx]._dataEnd;
+ actual._dataEnd = entries_[tmpIdx]._dataEnd;
}
else if (nextKeyIdx > 0) {
// Ignore any lang entries inside data region
- for (int i = nextKeyIdx; i < int(entries.size()) && entries[i]._tokenstart < actual._dataEnd; i++) {
- if (entries[i].keytype == KeyInfo::isMain)
- entries[i].disabled = true;
+ for (int i = nextKeyIdx; i < int(entries_.size()) && entries_[i]._tokenstart < actual._dataEnd; i++) {
+ if (entries_[i].keytype == KeyInfo::isMain)
+ entries_[i].disabled = true;
}
}
if (actual.disabled) {
- interval.addIntervall(actual._tokenstart-count, actual._dataEnd+1);
+ interval_.addIntervall(actual._tokenstart-count, actual._dataEnd+1);
}
else {
- interval.addIntervall(actual._tokenstart-count, actual._tokenstart);
+ interval_.addIntervall(actual._tokenstart-count, actual._tokenstart);
}
- if (interval.par[actual._dataEnd+1] == '[') {
- int posdown = interval.findclosing(actual._dataEnd+2, interval.par.length(), '[', ']');
- if ((interval.par[actual._dataEnd+2] == '{') &&
- (interval.par[posdown-1] == '}')) {
- interval.addIntervall(actual._dataEnd+1,actual._dataEnd+3);
- interval.addIntervall(posdown-1, posdown+1);
+ if (interval_.par[actual._dataEnd+1] == '[') {
+ int posdown = interval_.findclosing(actual._dataEnd+2, interval_.par.length(), '[', ']');
+ if ((interval_.par[actual._dataEnd+2] == '{') &&
+ (interval_.par[posdown-1] == '}')) {
+ interval_.addIntervall(actual._dataEnd+1,actual._dataEnd+3);
+ interval_.addIntervall(posdown-1, posdown+1);
}
else {
- interval.addIntervall(actual._dataEnd+1, actual._dataEnd+2);
- interval.addIntervall(posdown, posdown+1);
+ interval_.addIntervall(actual._dataEnd+1, actual._dataEnd+2);
+ interval_.addIntervall(posdown, posdown+1);
}
- int blk = interval.nextNotIgnored(actual._dataEnd+1);
+ int blk = interval_.nextNotIgnored(actual._dataEnd+1);
if (blk > posdown) {
// Discard at most 1 space after empty item
int count;
for (count = 0; count < 1; count++) {
- if (interval.par[blk+count] != ' ')
+ if (interval_.par[blk+count] != ' ')
break;
}
if (count > 0)
- interval.addIntervall(blk, blk+count);
+ interval_.addIntervall(blk, blk+count);
}
}
break;
int count;
int val = actual._tokenstart;
for (count = 0; count < actual._tokenstart;) {
- val = interval.previousNotIgnored(val-1);
- if (interval.par[val] != ' ')
+ val = interval_.previousNotIgnored(val-1);
+ if (val < 0 || interval_.par[val] != ' ')
break;
else {
count = actual._tokenstart - val;
removeHead(actual, count);
nextKeyIdx = getNextKey();
} else {
- interval.addIntervall(actual._tokenstart-count, actual._tokenstart);
+ interval_.addIntervall(actual._tokenstart-count, actual._tokenstart);
nextKeyIdx = process(os, actual);
}
break;
break;
}
case KeyInfo::isMain: {
- if (interval.par.substr(actual._dataStart, 2) == "% ")
- interval.addIntervall(actual._dataStart, actual._dataStart+2);
+ if (interval_.par.substr(actual._dataStart, 2) == "% ")
+ interval_.addIntervall(actual._dataStart, actual._dataStart+2);
if (actual._tokenstart > 0) {
- int prev = interval.previousNotIgnored(actual._tokenstart - 1);
- if ((prev >= 0) && interval.par[prev] == '%')
- interval.addIntervall(prev, prev+1);
+ int prev = interval_.previousNotIgnored(actual._tokenstart - 1);
+ if ((prev >= 0) && interval_.par[prev] == '%')
+ interval_.addIntervall(prev, prev+1);
}
if (actual.disabled) {
removeHead(actual);
- if ((interval.par.substr(actual._dataStart, 3) == " \\[") ||
- (interval.par.substr(actual._dataStart, 8) == " \\begin{")) {
+ interval_.langcount++;
+ if ((interval_.par.substr(actual._dataStart, 3) == " \\[") ||
+ (interval_.par.substr(actual._dataStart, 8) == " \\begin{")) {
// Discard also the space before math-equation
- interval.addIntervall(actual._dataStart, actual._dataStart+1);
+ interval_.addIntervall(actual._dataStart, actual._dataStart+1);
}
nextKeyIdx = getNextKey();
// interval.resetOpenedP(actual._dataStart-1);
else {
if (actual._tokenstart < 26) {
// for the first (and maybe dummy) language
- interval.setForDefaultLang(actual);
+ interval_.setForDefaultLang(actual);
}
- interval.resetOpenedP(actual._dataStart-1);
+ interval_.resetOpenedP(actual._dataStart-1);
}
break;
}
case KeyInfo::invalid:
- // This cannot happen, already handled
+ case KeyInfo::headRemove:
+ // These two cases cannot happen, already handled
// fall through
default: {
- // LYXERR0("Unhandled keytype");
+ // LYXERR(Debug::INFO, "Unhandled keytype");
nextKeyIdx = getNextKey();
break;
}
return nextKeyIdx;
}
-int LatexInfo::process(ostringstream &os, KeyInfo &actual )
+int LatexInfo::process(ostringstream & os, KeyInfo const & actual )
{
- int end = interval.nextNotIgnored(actual._dataEnd);
+ int end = interval_.nextNotIgnored(actual._dataEnd);
int oldStart = actual._dataStart;
int nextKeyIdx = getNextKey();
while (true) {
if ((nextKeyIdx < 0) ||
- (entries[nextKeyIdx]._tokenstart >= actual._dataEnd) ||
- (entries[nextKeyIdx].keytype == KeyInfo::invalid)) {
+ (entries_[nextKeyIdx]._tokenstart >= actual._dataEnd) ||
+ (entries_[nextKeyIdx].keytype == KeyInfo::invalid)) {
if (oldStart <= end) {
processRegion(oldStart, end);
oldStart = end+1;
if (oldStart <= end) {
processRegion(oldStart, end);
}
- if (interval.par[end] == '}') {
+ if (interval_.par.size() > (size_t) end && interval_.par[end] == '}') {
end += 1;
// This is the normal case.
// But if using the firstlanguage, the closing may be missing
// get minimum of 'end' and 'actual._dataEnd' in case that the nextKey.keytype was 'KeyInfo::isMain'
int output_end;
if (actual._dataEnd < end)
- output_end = interval.nextNotIgnored(actual._dataEnd);
+ output_end = interval_.nextNotIgnored(actual._dataEnd);
+ else if (interval_.par.size() > (size_t) end)
+ output_end = interval_.nextNotIgnored(end);
else
- output_end = interval.nextNotIgnored(end);
+ output_end = interval_.par.size();
if ((actual.keytype == KeyInfo::isMain) && actual.disabled) {
- interval.addIntervall(actual._tokenstart, actual._tokenstart+actual._tokensize);
+ interval_.addIntervall(actual._tokenstart, actual._tokenstart+actual._tokensize);
}
// Remove possible empty data
- int dstart = interval.nextNotIgnored(actual._dataStart);
- while (interval.isOpeningPar(dstart) == 1) {
- interval.addIntervall(dstart, dstart+1);
- int dend = interval.findclosing(dstart+1, output_end);
- interval.addIntervall(dend, dend+1);
- dstart = interval.nextNotIgnored(dstart+1);
+ int dstart = interval_.nextNotIgnored(actual._dataStart);
+ while (interval_.isOpeningPar(dstart) == 1) {
+ interval_.addIntervall(dstart, dstart+1);
+ int dend = interval_.findclosing(dstart+1, output_end);
+ interval_.addIntervall(dend, dend+1);
+ dstart = interval_.nextNotIgnored(dstart+1);
}
if (dstart < output_end)
- interval.output(os, output_end);
- interval.addIntervall(actual._tokenstart, end);
+ interval_.output(os, output_end);
+ interval_.addIntervall(actual._tokenstart, end);
return nextKeyIdx;
}
{
ostringstream os;
LatexInfo li(par, isPatternString);
- // LYXERR0("Berfore split: " << par);
+ // LYXERR(Debug::INFO, "Berfore split: " << par);
KeyInfo DummyKey = KeyInfo(KeyInfo::KeyType::isMain, 2, true);
DummyKey.head = "";
DummyKey._tokensize = 0;
}
else
s = par; /* no known macros found */
- // LYXERR0("After split: " << s);
+ // LYXERR(Debug::INFO, "After split: " << s);
return s;
}
string a = it->first;
regex_with_format = true;
features += " " + a;
- // LYXERR0("Identified regex format:" << a);
+ // LYXERR(Debug::INFO, "Identified regex format:" << a);
}
LYXERR(Debug::FIND, "Identified Features" << features);
if (b && ! info[a]) {
missed++;
LYXERR(Debug::FIND, "Missed(" << missed << " " << a <<", srclen = " << parlen );
- return("");
+ return "";
}
}
}
else {
- // LYXERR0("No regex formats");
+ // LYXERR(Debug::INFO, "No regex formats");
}
- return(result);
+ return result;
}
int open_braces = 0;
do {
LYXERR(Debug::FIND, "identifyClosing(): t now is '" << t << "'");
- if (regex_replace(t, t, "(.*[^\\\\])\\$" REGEX_EOS, "$1"))
+ if (regex_replace(t, t, "(.*[^\\\\])\\$$", "$1"))
continue;
- if (regex_replace(t, t, "(.*[^\\\\]) \\\\\\]" REGEX_EOS, "$1"))
+ if (regex_replace(t, t, "(.*[^\\\\])\\\\\\]$", "$1"))
continue;
- if (regex_replace(t, t, "(.*[^\\\\]) \\\\end\\{[a-zA-Z_]*\\*?\\}" REGEX_EOS, "$1"))
+ if (regex_replace(t, t, "(.*[^\\\\])\\\\end\\{[a-zA-Z_]*\\*?\\}$", "$1"))
continue;
- if (regex_replace(t, t, "(.*[^\\\\])\\}" REGEX_EOS, "$1")) {
+ if (regex_replace(t, t, "(.*[^\\\\])\\}$", "$1")) {
++open_braces;
continue;
}
string lead_as_regexp;
if (lead_size > 0) {
// @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);
+ static std::regex specialChars { R"([-[\]{}()*+?.,\^$|#\s\\])" };
+ lead_as_regexp = std::regex_replace(par_as_string.substr(0, lead_size), specialChars, R"(\$&)" );
+ // 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 << "'");
}
+ LYXERR(Debug::FIND, "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 << "'");
// TODO: Adapt '\[12345678]' in par_as_string to acount for the first '()
// Unfortunately is '\1', '\2', etc not working for strings with extra format
// so the convert has no effect in that case
- for (int i = 8; i > 0; --i) {
+ for (int i = 7; i > 0; --i) {
string orig = "\\\\" + std::to_string(i);
- string dest = "\\" + std::to_string(i+1);
+ string dest = "\\" + std::to_string(i+2);
while (regex_replace(par_as_string, par_as_string, orig, dest));
}
- regexp_str = "(" + lead_as_regexp + ")" + par_as_string;
- regexp2_str = "(" + lead_as_regexp + ").*?" + par_as_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 << "'");
- regexp = lyx::regex(regexp_str);
-
LYXERR(Debug::FIND, "Setting regexp2 to: '" << regexp2_str << "'");
- regexp2 = lyx::regex(regexp2_str);
+#if QTSEARCH
+ // Handle \w properly
+ QRegularExpression::PatternOptions popts = QRegularExpression::UseUnicodePropertiesOption | QRegularExpression::MultilineOption;
+ if (! opt.casesensitive) {
+ popts |= QRegularExpression::CaseInsensitiveOption;
+ }
+ regexp = QRegularExpression(QString::fromStdString(regexp_str), popts);
+ regexp2 = QRegularExpression(QString::fromStdString(regexp2_str), popts);
+ regexError = "";
+ if (regexp.isValid() && regexp2.isValid()) {
+ regexIsValid = true;
+ // Check '{', '}' pairs inside the regex
+ int balanced = 0;
+ int skip = 1;
+ for (unsigned i = 0; i < par_as_string.size(); i+= skip) {
+ char c = par_as_string[i];
+ if (c == '\\') {
+ skip = 2;
+ continue;
+ }
+ if (c == '{')
+ balanced++;
+ else if (c == '}') {
+ balanced--;
+ if (balanced < 0)
+ break;
+ }
+ skip = 1;
+ }
+ if (balanced != 0) {
+ regexIsValid = false;
+ regexError = "Unbalanced curly brackets in regexp \"" + regexp_str + "\"";
+ }
+ }
+ else {
+ regexIsValid = false;
+ if (!regexp.isValid())
+ regexError += "Invalid regexp \"" + regexp_str + "\", error = " + regexp.errorString().toStdString();
+ if (!regexp2.isValid())
+ regexError += "Invalid regexp2 \"" + regexp2_str + "\", error = " + regexp2.errorString().toStdString();
+ }
+#else
+ if (opt.casesensitive) {
+ regexp = regex(regexp_str);
+ regexp2 = regex(regexp2_str);
+ }
+ else {
+ regexp = regex(regexp_str, std::regex_constants::icase);
+ regexp2 = regex(regexp2_str, std::regex_constants::icase);
+ }
+#endif
}
}
-
+#if 0
// Count number of characters in string
// {]} ==> 1
// \& ==> 1
// --- ==> 1
// \\[a-zA-Z]+ ==> 1
+#if QTSEARCH
+static int computeSize(QStringRef s, int len)
+#define isLyxAlpha(arg) arg.isLetter()
+#else
static int computeSize(string s, int len)
+#define isLyxAlpha(arg) isalpha(arg)
+#endif
{
if (len == 0)
return 0;
int skip = 1;
int count = 0;
for (int i = 0; i < len; i += skip, count++) {
- if (s[i] == '\\') {
+ if (s.at(i) == '\\') {
skip = 2;
- if (isalpha(s[i+1])) {
+ if (i + 1 < len && isLyxAlpha(s.at(i+1))) {
for (int j = 2; i+j < len; j++) {
- if (! isalpha(s[i+j])) {
- if (s[i+j] == ' ')
- skip++;
- else if ((s[i+j] == '{') && s[i+j+1] == '}')
- skip += 2;
- else if ((s[i+j] == '{') && (i + j + 1 >= len))
+ if (! isLyxAlpha(s.at(i+j))) {
+ if (s.at(i+j) == ' ')
skip++;
+ else if (s.at(i+j) == '{') {
+ if (i+j+1 < len && s.at(i+j+1) == '}')
+ skip += 2;
+ else if (i + j + 1 >= len)
+ skip++;
+ }
break;
}
skip++;
}
}
}
- else if (s[i] == '{') {
- if (s[i+1] == '}')
+ else if (s.at(i) == '{') {
+ if (i + 1 < len && s.at(i+1) == '}')
skip = 2;
else
skip = 3;
}
- else if (s[i] == '-') {
- if (s[i+1] == '-') {
- if (s[i+2] == '-')
+ else if (s.at(i) == '-') {
+ if (i+1 < len && s.at(i+1) == '-') {
+ if (i + 2 < len && s.at(i+2) == '-')
skip = 3;
else
skip = 2;
}
return count;
}
+#endif
MatchResult MatchStringAdv::findAux(DocIterator const & cur, int len, bool at_begin) const
{
return mres;
docstring docstr = stringifyFromForSearch(opt, cur, len);
- string str = normalize(docstr, true);
+ string str;
+ if (use_regexp || opt.casesensitive)
+ str = normalize(docstr, true);
+ else
+ str = normalize(lowercase(docstr), true);
if (!opt.ignoreformat) {
str = correctlanguagesetting(str, false, !opt.ignoreformat);
}
if (use_regexp) {
LYXERR(Debug::FIND, "Searching in regexp mode: at_begin=" << at_begin);
+#if QTSEARCH
+ QString qstr = QString::fromStdString(str);
+ QRegularExpression const *p_regexp;
+ QRegularExpression::MatchType flags = QRegularExpression::NormalMatch;
+ if (at_begin) {
+ p_regexp = ®exp;
+ } else {
+ p_regexp = ®exp2;
+ }
+ QRegularExpressionMatch match = p_regexp->match(qstr, 0, flags);
+ if (!match.hasMatch())
+ return mres;
+ // Check braces on segments that matched all (.*?) subexpressions,
+ // except the last "padding" one inserted by lyx.
+ for (int i = 3; i < match.lastCapturedIndex(); ++i)
+ if (!braces_match(match.captured(i), open_braces))
+ return mres;
+#else
regex const *p_regexp;
regex_constants::match_flag_type flags;
if (at_begin) {
if (re_it == sregex_iterator())
return mres;
match_results<string::const_iterator> const & m = *re_it;
-
- if (0) { // Kornel Benko: DO NOT CHECKK
- // 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 mres;
- }
-
// 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, open_braces))
+ for (size_t i = 3; i < m.size() - 1; ++i)
+ if (!braces_match(m[i], open_braces))
return mres;
-
+#endif
// Exclude from the returned match length any length
// due to close wildcards added at end of regexp
// and also the length of the leading (e.g. '\emph{}')
// Whole found string, including the leading: m[0].second - m[0].first
// Size of the leading string: m[1].second - m[1].first
int leadingsize = 0;
- if (m.size() > 1)
- leadingsize = m[1].second - m[1].first;
int result;
- for (size_t i = 0; i < m.size(); i++) {
- LYXERR(Debug::FIND, "Match " << i << " is " << m[i].second - m[i].first << " long");
- }
+#if QTSEARCH
+ if (match.lastCapturedIndex() > 0) {
+ leadingsize = match.capturedEnd(1) - match.capturedStart(1);
+ }
+ int lastidx = match.lastCapturedIndex();
+ for (int i = 0; i <= lastidx; i++) {
+ LYXERR(Debug::FIND, "Match " << i << " is " << match.capturedEnd(i) - match.capturedStart(i) << " long");
+ }
if (close_wildcards == 0)
- result = m[0].second - m[0].first;
-
+ result = match.capturedEnd(0) - match.capturedStart(0);
else
- result = m[m.size() - close_wildcards].first - m[0].first;
+ result = match.capturedStart(lastidx + 1 - close_wildcards) - match.capturedStart(0);
- size_t pos = m.position(size_t(0));
- // Ignore last closing characters
- while (result > 0) {
- if (str[pos+result-1] == '}')
- --result;
- else
- break;
+#else
+ if (m.size() > 2) {
+ leadingsize = m[1].second - m[1].first;
}
+ for (size_t i = 0; i < m.size(); i++) {
+ LYXERR(Debug::FIND, "Match " << i << " is " << m[i].second - m[i].first << " long");
+ }
+ if (close_wildcards == 0)
+ result = m[0].second - m[0].first;
+ else
+ result = m[m.size() - close_wildcards].first - m[0].first;
+#endif
if (result > leadingsize)
result -= leadingsize;
else
result = 0;
- mres.match_len = computeSize(str.substr(pos+leadingsize,result), result);
- mres.match2end = str.size() - pos - leadingsize;
- mres.pos = pos+leadingsize;
+#if QTSEARCH
+ mres.match_prefix = match.capturedEnd(2) - match.capturedStart(2);
+ mres.match_len = match.capturedEnd(0) - match.capturedEnd(2);
+ // because of different number of closing at end of string
+ // we have to 'unify' the length of the post-match.
+ // Done by ignoring closing parenthesis and linefeeds at string end
+ int matchend = match.capturedEnd(0);
+ while (mres.match_len > 0) {
+ QChar c = qstr.at(matchend - 1);
+ if ((c == '\n') || (c == '}') || (c == '{')) {
+ mres.match_len--;
+ matchend--;
+ }
+ else
+ break;
+ }
+ size_t strsize = qstr.size();
+ while (strsize > (size_t) match.capturedEnd(0)) {
+ QChar c = qstr.at(strsize-1);
+ if ((c == '\n') || (c == '}')) {
+ --strsize;
+ }
+ else
+ break;
+ }
+ // LYXERR0(qstr.toStdString());
+ mres.match2end = strsize - matchend;
+ mres.pos = match.capturedStart(2);
+#else
+ mres.match_prefix = m[2].second - m[2].first;
+ mres.match_len = m[0].second - m[2].second;
+ // ignore closing parenthesis and linefeeds at string end
+ size_t strend = m[0].second - m[0].first;
+ int matchend = strend;
+ while (mres.match_len > 0) {
+ char c = str.at(matchend - 1);
+ if ((c == '\n') || (c == '}') || (c == '{')) {
+ mres.match_len--;
+ matchend--;
+ }
+ else
+ break;
+ }
+ size_t strsize = str.size();
+ while (strsize > strend) {
+ if ((str.at(strsize-1) == '}') || (str.at(strsize-1) == '\n')) {
+ --strsize;
+ }
+ else
+ break;
+ }
+ // LYXERR0(str);
+ mres.match2end = strsize - matchend;
+ mres.pos = m[2].first - m[0].first;;
+#endif
+ if (mres.match2end < 0)
+ mres.match_len = 0;
+ mres.leadsize = leadingsize;
return mres;
}
<< ", inTexted=" << cur.inTexted());
if (res == 0 || !at_begin || !opt.matchword || !cur.inTexted())
return mres;
- if ((len > 0) && (res < len)) {
+ if ((len > 0) && (res < len)) {
mres.match_len = 0;
- return mres;
+ return mres;
}
Paragraph const & par = cur.paragraph();
bool ws_left = (cur.pos() > 0)
? par.isWordSeparator(cur.pos() - 1)
: true;
- bool ws_right = (cur.pos() + len < par.size())
+ bool ws_right;
+ if (len < 0)
+ ws_right = true;
+ else {
+ ws_right = (cur.pos() + len < par.size())
? par.isWordSeparator(cur.pos() + len)
: true;
+ }
LYXERR(Debug::FIND,
"cur.pos()=" << cur.pos() << ", res=" << res
<< ", separ: " << ws_left << ", " << ws_right
- << ", len: " << len
+ << ", len: " << len
<< endl);
if (ws_left && ws_right) {
- // Check for word separators inside the found 'word'
- for (int i = 0; i < len; i++) {
- if (par.isWordSeparator(cur.pos() + i)) {
+ // Check for word separators inside the found 'word'
+ for (int i = 0; i < len; i++) {
+ if (par.isWordSeparator(cur.pos() + i)) {
mres.match_len = 0;
- return mres;
+ return mres;
}
- }
- return mres;
- }
+ }
+ return mres;
+ }
mres.match_len = 0;
return mres;
}
string MatchStringAdv::normalize(docstring const & s, bool hack_braces) const
{
string t;
- if (! opt.casesensitive)
- t = lyx::to_utf8(lowercase(s));
- else
- t = lyx::to_utf8(s);
+ t = lyx::to_utf8(s);
// Remove \n at begin
while (!t.empty() && t[0] == '\n')
t = t.substr(1);
LYXERR(Debug::FIND, " 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);
-
while (regex_replace(t, t, "\\\\(foreignlanguage|textcolor|item)\\{[a-z]+\\}(\\{(\\{\\})?\\})+", ""));
// FIXME - check what preceeds the brace
if (hack_braces) {
// OutputParams runparams(&cur.buffer()->params().encoding());
OutputParams runparams(encodings.fromLyXName("utf8"));
runparams.nice = true;
- runparams.flavor = OutputParams::XETEX;
+ runparams.flavor = Flavor::XeTeX;
runparams.linelen = 10000; //lyxrc.plaintext_linelen;
// No side effect of file copying and image conversion
runparams.dryrun = true;
//OutputParams runparams(&buf.params().encoding());
OutputParams runparams(encodings.fromLyXName("utf8"));
runparams.nice = false;
- runparams.flavor = OutputParams::XETEX;
+ runparams.flavor = Flavor::XeTeX;
runparams.linelen = 8000; //lyxrc.plaintext_linelen;
// No side effect of file copying and image conversion
runparams.dryrun = true;
for (int s = cur.depth() - 1; s >= 0; --s) {
CursorSlice const & cs = cur[s];
if (cs.asInsetMath() && cs.asInsetMath()->asHullInset()) {
- WriteStream ws(os);
+ TeXMathStream ws(os);
cs.asInsetMath()->asHullInset()->header_write(ws);
break;
}
CursorSlice const & cs2 = cur[s];
InsetMath * inset = cs2.asInsetMath();
if (inset && inset->asHullInset()) {
- WriteStream ws(os);
+ TeXMathStream ws(os);
inset->asHullInset()->footer_write(ws);
break;
}
return ods.str();
}
+#if 0
+// Debugging output
+static void displayMResult(MatchResult &mres, int increment)
+{
+ LYXERR0( "pos: " << mres.pos << " increment " << increment);
+ LYXERR0( "leadsize: " << mres.leadsize);
+ LYXERR0( "match_len: " << mres.match_len);
+ LYXERR0( "match_prefix: " << mres.match_prefix);
+ LYXERR0( "match2end: " << mres.match2end);
+}
+ #define displayMres(s,i) displayMResult(s,i);
+#else
+ #define displayMres(s,i)
+#endif
-/** Finalize an advanced find operation, advancing the cursor to the innermost
- ** position that matches, plus computing the length of the matching text to
- ** be selected
- **/
-int findAdvFinalize(DocIterator & cur, MatchStringAdv const & match)
+static bool findAdvForwardInnermost(DocIterator & cur)
{
- // Search the foremost position that matches (avoids find of entire math
- // inset when match at start of it)
size_t d;
DocIterator old_cur(cur.buffer());
+ int forwardCount = 0;
do {
- 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).match_len > 0);
+ if (!cur) {
+ break;
+ }
+ if (cur.depth() > d) {
+ forwardCount++;
+ continue;
+ }
+ if (cur.depth() == d)
+ break;
+ } while(1);
cur = old_cur;
- int max_match = match(cur).match_len; /* match valid only if not searching whole words */
+ if (forwardCount > 0) {
+ LYXERR(Debug::FIND, "Forwarded " << forwardCount << " step(s) (searching for innermost match)");
+ return true;;
+ }
+ else
+ return false;
+}
+
+/** Finalize an advanced find operation, advancing the cursor to the innermost
+ ** position that matches, plus computing the length of the matching text to
+ ** be selected
+ **/
+int findAdvFinalize(DocIterator & cur, MatchStringAdv const & match, int expected_len, int prefix_len = 0)
+{
+ // Search the foremost position that matches (avoids find of entire math
+ // inset when match at start of it)
+ DocIterator old_cur(cur.buffer());
+ MatchResult mres;
+ int max_match;
+ // If (prefix_len > 0) means that forwarding 1 position will remove the complete entry
+ // Happens with e.g. hyperlinks
+ // either one sees "http://www.bla.bla" or nothing
+ // so the search for "www" gives prefix_len = 7 (== sizeof("http://")
+ // and although we search for only 3 chars, we find the whole hyperlink inset
+ bool at_begin = (prefix_len == 0);
+ if (findAdvForwardInnermost(cur)) {
+ mres = match(cur, -1, at_begin);
+ displayMres(mres, 0);
+ if (expected_len > 0) {
+ if (mres.match_len < expected_len)
+ return 0;
+ }
+ else {
+ if (mres.match_len <= 0)
+ return 0;
+ }
+ max_match = mres.match_len;
+ }
+ else if (expected_len < 0) {
+ mres = match(cur); /* match valid only if not searching whole words */
+ displayMres(mres, 0);
+ max_match = mres.match_len;
+ }
+ else {
+ max_match = expected_len;
+ }
if (max_match <= 0) return 0;
LYXERR(Debug::FIND, "Ok");
int len = 1;
if (cur.pos() + len > cur.lastpos())
return 0;
- if (match.opt.matchword) {
+ // regexp should use \w+, \S+, or \b(some string)\b
+ // to search for whole words
+ if (match.opt.matchword && !match.use_regexp) {
LYXERR(Debug::FIND, "verifying unmatch with len = " << len);
while (cur.pos() + len <= cur.lastpos() && match(cur, len).match_len <= 0) {
++len;
LYXERR(Debug::FIND, "verifying unmatch with len = " << len);
}
// Length of matched text (different from len param)
- int old_match = match(cur, len).match_len;
+ int old_match = match(cur, len, at_begin).match_len;
if (old_match < 0)
old_match = 0;
int new_match;
// Greedy behaviour while matching regexps
- while ((new_match = match(cur, len + 1).match_len) > old_match) {
+ while ((new_match = match(cur, len + 1, at_begin).match_len) > old_match) {
++len;
old_match = new_match;
LYXERR(Debug::FIND, "verifying match with len = " << len);
if (old_match == 0)
len = 0;
}
- else {
- int minl = 1;
- int maxl = cur.lastpos() - cur.pos();
- // Greedy behaviour while matching regexps
- while (maxl > minl) {
- int actual_match = match(cur, len).match_len;
- if (actual_match >= max_match) {
- // actual_match > max_match _can_ happen,
- // if the search area splits
- // some following word so that the regex
- // (e.g. 'r.*r\b' matches 'r' from the middle of the
- // splitted word)
- // This means, the len value is too big
- maxl = len;
- len = (int)((maxl + minl)/2);
- }
- else {
- // (actual_match < max_match)
- minl = len + 1;
- len = (int)((maxl + minl)/2);
- }
- }
+ else {
+ int minl = 1;
+ int maxl = cur.lastpos() - cur.pos();
+ // Greedy behaviour while matching regexps
+ while (maxl > minl) {
+ MatchResult mres2;
+ mres2 = match(cur, len, at_begin);
+ displayMres(mres2, len);
+ int actual_match = mres2.match_len;
+ if (actual_match >= max_match) {
+ // actual_match > max_match _can_ happen,
+ // if the search area splits
+ // some following word so that the regex
+ // (e.g. 'r.*r\b' matches 'r' from the middle of the
+ // splitted word)
+ // This means, the len value is too big
+ maxl = len;
+ if (maxl - minl < 4)
+ len = (int)((maxl + minl)/2);
+ else
+ len = (int)(minl + (maxl - minl + 3)/4);
+ }
+ else {
+ // (actual_match < max_match)
+ minl = len + 1;
+ len = (int)((maxl + minl)/2);
+ }
+ }
old_cur = cur;
// Search for real start of matched characters
while (len > 1) {
} while (cur.depth() > old_cur.depth()); /* Skip inner insets */
if (cur.depth() < old_cur.depth()) {
// Outer inset?
- LYXERR0("cur.depth() < old_cur.depth(), this should never happen");
+ LYXERR(Debug::INFO, "cur.depth() < old_cur.depth(), this should never happen");
break;
}
if (cur.pos() != old_cur.pos()) {
// OK, forwarded 1 pos in actual inset
- actual_match = match(cur, len-1).match_len;
+ actual_match = match(cur, len-1, at_begin).match_len;
if (actual_match == max_match) {
// Ha, got it! The shorter selection has the same match length
len--;
}
}
else {
- LYXERR0("cur.pos() == old_cur.pos(), this should never happen");
- actual_match = match(cur, len).match_len;
+ LYXERR(Debug::INFO, "cur.pos() == old_cur.pos(), this should never happen");
+ actual_match = match(cur, len, at_begin).match_len;
if (actual_match == max_match)
old_cur = cur;
}
return len;
}
-
/// Finds forward
-int findForwardAdv(DocIterator & cur, MatchStringAdv & match)
+int findForwardAdv(DocIterator & cur, MatchStringAdv const & match)
{
if (!cur)
return 0;
while (!theApp()->longOperationCancelled() && cur) {
+ (void) findAdvForwardInnermost(cur);
LYXERR(Debug::FIND, "findForwardAdv() cur: " << cur);
MatchResult mres = match(cur, -1, false);
+ displayMres(mres,-1)
int match_len = mres.match_len;
- LYXERR(Debug::FIND, "match_len: " << match_len);
if ((mres.pos > 100000) || (mres.match2end > 100000) || (match_len > 100000)) {
- LYXERR0("BIG LENGTHS: " << mres.pos << ", " << match_len << ", " << mres.match2end);
+ LYXERR(Debug::INFO, "BIG LENGTHS: " << mres.pos << ", " << match_len << ", " << mres.match2end);
match_len = 0;
}
if (match_len > 0) {
// Try to find the begin of searched string
- int increment = mres.pos/2;
- while (mres.pos > 5 && (increment > 5)) {
+ int increment;
+ int firstInvalid = 100000;
+ if (mres.match_prefix + mres.pos - mres.leadsize > 1)
+ increment = (mres.match_prefix + mres.pos - mres.leadsize + 1)*3/4;
+ else
+ increment = 10;
+ LYXERR(Debug::FIND, "Set increment to " << increment);
+ while (increment > 0) {
DocIterator old_cur = cur;
for (int i = 0; i < increment && cur; cur.forwardPos(), i++) {
}
}
else {
MatchResult mres2 = match(cur, -1, false);
- if ((mres2.match2end < mres.match2end) ||
- (mres2.match_len < mres.match_len)) {
- cur = old_cur;
- increment /= 2;
- }
- else {
- mres = mres2;
- increment -= 2;
- if (increment > mres.pos/2)
- increment = mres.pos/2;
+ displayMres(mres2,increment)
+ switch (interpretMatch(mres, mres2)) {
+ case MatchResult::newIsTooFar:
+ // behind the expected match
+ firstInvalid = increment;
+ cur = old_cur;
+ increment /= 2;
+ break;
+ case MatchResult::newIsBetter:
+ // not reached ye, but cur.pos()+increment is bettert
+ mres = mres2;
+ firstInvalid -= increment;
+ if (increment > firstInvalid*3/4)
+ increment = firstInvalid*3/4;
+ if ((mres2.pos == mres2.leadsize) && (increment >= mres2.match_prefix)) {
+ if (increment >= mres2.match_prefix)
+ increment = (mres2.match_prefix+1)*3/4;
+ }
+ break;
+ default:
+ // Todo@
+ // Handle not like MatchResult::newIsTooFar
+ // LYXERR0( "Something is wrong: Increment = " << increment << " match_prefix = " << mres.match_prefix);
+ firstInvalid--;
+ increment = increment*3/4;
+ cur = old_cur;
+ break;
}
}
}
+ // LYXERR0("Leaving first loop");
+ {
+ LYXERR(Debug::FIND, "Finalizing 1");
+ int len = findAdvFinalize(cur, match, mres.match_len, mres.match_prefix);
+ if (len > 0)
+ return len;
+ else {
+ // try next possible match
+ cur.forwardPos();
+ continue;
+ }
+ }
+ // The following code is newer reached
+ // but parts of it may be needed in future
int match_len_zero_count = 0;
+ MatchResult mres3;
for (int i = 0; !theApp()->longOperationCancelled() && cur; cur.forwardPos()) {
- if (i++ > 10) {
- int remaining_len = match(cur, -1, false).match_len;
+ if (i++ > 3) {
+ mres3 = match(cur, -1, false);
+ displayMres(mres3, 1)
+ int remaining_len = mres3.match_len;
if (remaining_len <= 0) {
// Apparently the searched string is not in the remaining part
break;
}
}
LYXERR(Debug::FIND, "Advancing cur: " << cur);
- int match_len3 = match(cur, 1).match_len;
+ mres3 = match(cur, 1);
+ displayMres(mres3, 1)
+ int match_len3 = mres3.match_len;
if (match_len3 < 0)
continue;
- int match_len2 = match(cur).match_len;
+ mres3 = match(cur);
+ displayMres(mres3, 1)
+ int match_len2 = mres3.match_len;
LYXERR(Debug::FIND, "match_len2: " << match_len2);
if (match_len2 > 0) {
// Sometimes in finalize we understand it wasn't a match
// and we need to continue the outest loop
- int len = findAdvFinalize(cur, match);
+ LYXERR(Debug::FIND, "Finalizing 2");
+ int len = findAdvFinalize(cur, match, mres.match_len);
if (len > 0) {
return len;
}
}
- if (match_len2 >= 0) {
- if (match_len2 == 0)
- match_len_zero_count++;
- else
- match_len_zero_count = 0;
- }
- else {
- if (++match_len_zero_count > 3) {
- LYXERR(Debug::FIND, "match_len2_zero_count: " << match_len_zero_count << ", match_len was " << match_len);
- match_len_zero_count = 0;
- }
+ if (match_len2 > 0)
+ match_len_zero_count = 0;
+ else if (match_len2 == 0)
+ match_len_zero_count++;
+ if (match_len2 < 0) {
+ if (++match_len_zero_count > 3) {
+ LYXERR(Debug::FIND, "match_len2_zero_count: " << match_len_zero_count << ", match_len was " << match_len);
+ }
break;
}
}
{
DocIterator cur_begin = doc_iterator_begin(cur.buffer());
DocIterator tmp_cur = cur;
- int len = findAdvFinalize(tmp_cur, match);
+ int len = findAdvFinalize(tmp_cur, match, -1);
Inset & inset = cur.inset();
for (; cur != cur_begin; cur.backwardPos()) {
LYXERR(Debug::FIND, "findMostBackwards(): cur=" << cur);
new_cur.backwardPos();
if (new_cur == cur || &new_cur.inset() != &inset || !match(new_cur).match_len)
break;
- int new_len = findAdvFinalize(new_cur, match);
+ int new_len = findAdvFinalize(new_cur, match, -1);
if (new_len == len)
break;
len = new_len;
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, SearchRestriction restr, bool replace_all)
- : 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), restr(restr), replace_all(replace_all)
+ 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, SearchRestriction _restr, bool _replace_all)
+ : 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), restr(_restr), replace_all(_replace_all)
{
}
static void changeFirstCase(Buffer & buffer, TextCase first_case, TextCase others_case)
{
ParagraphList::iterator pit = buffer.paragraphs().begin();
- LASSERT(pit->size() >= 1, /**/);
+ LASSERT(!pit->empty(), /**/);
pos_type right = pos_type(1);
pit->changeCase(buffer.params(), pos_type(0), right, first_case);
right = pit->size();
static int findAdvReplace(BufferView * bv, FindAndReplaceOptions const & opt, MatchStringAdv & matchAdv)
{
Cursor & cur = bv->cursor();
- if (opt.repl_buf_name == docstring()
+ if (opt.repl_buf_name.empty()
|| theBufferList().getBuffer(FileName(to_utf8(opt.repl_buf_name)), true) == 0
|| theBufferList().getBuffer(FileName(to_utf8(opt.find_buf_name)), true) == 0)
return 0;
return 0;
// Build a copy of the replace buffer, adapted to the KeepCase option
- Buffer & repl_buffer_orig = *theBufferList().getBuffer(FileName(to_utf8(opt.repl_buf_name)), true);
+ Buffer const & repl_buffer_orig = *theBufferList().getBuffer(FileName(to_utf8(opt.repl_buf_name)), true);
ostringstream oss;
repl_buffer_orig.write(oss);
string lyx = oss.str();
// OutputParams runparams(&repl_buffer.params().encoding());
OutputParams runparams(encodings.fromLyXName("utf8"));
runparams.nice = false;
- runparams.flavor = OutputParams::XETEX;
+ runparams.flavor = Flavor::XeTeX;
runparams.linelen = 8000; //lyxrc.plaintext_linelen;
runparams.dryrun = true;
TeXOnePar(repl_buffer, repl_buffer.text(), 0, os, runparams);
try {
MatchStringAdv matchAdv(bv->buffer(), opt);
+#if QTSEARCH
+ if (!matchAdv.regexIsValid) {
+ bv->message(lyx::from_utf8(matchAdv.regexError));
+ return(false);
+ }
+#endif
int length = bv->cursor().selectionEnd().pos() - bv->cursor().selectionBegin().pos();
if (length > 0)
bv->putSelectionAt(bv->cursor().selectionBegin(), length, !opt.forward);
match_len = findForwardAdv(cur, matchAdv);
else
match_len = findBackwardsAdv(cur, matchAdv);
- } catch (...) {
- // This may only be raised by lyx::regex()
- bv->message(_("Invalid regular expression!"));
+ } catch (exception & ex) {
+ bv->message(from_utf8(ex.what()));
return false;
}
projects / lyx.git / blobdiff