replace = "\\";
else if (sub.str(4) == "mathcircumflex")
replace = "^";
+ else if (sub.str(3) == "{")
+ replace = "\\braceleft";
+ else if (sub.str(3) == "}")
+ replace = "\\braceright";
else
replace = sub.str(3);
}
int pos;
int leadsize;
int pos_len;
+ int searched_size;
vector <string> result = vector <string>();
- MatchResult(int len = 0): match_len(len),match_prefix(0),match2end(0), pos(0),leadsize(0),pos_len(-1) {};
+ MatchResult(int len = 0): match_len(len),match_prefix(0),match2end(0), pos(0),leadsize(0),pos_len(-1),searched_size(0) {};
};
static MatchResult::range interpretMatch(MatchResult &oldres, MatchResult &newres)
{
int range = oldres.match_len;
- if (range < 2) range = 2;
+ if (range > 0) range--;
if (newres.match2end < oldres.match2end - oldres.match_len)
return MatchResult::newIsTooFar;
if (newres.match_len < oldres.match_len)
key += interval_.par.substr(params, optend-params);
evaluatingOptional = true;
optionalEnd = optend;
+ if (found.keytype == KeyInfo::isSectioning) {
+ // Remove optional values (but still keep in header)
+ interval_.addIntervall(params, optend);
+ }
}
string token = sub.str(7);
int closings;
// Known charaters
// No split
makeKey("backslash|textbackslash|slash", KeyInfo(KeyInfo::isChar, 0, false), isPatternString);
+ makeKey("braceleft|braceright", KeyInfo(KeyInfo::isChar, 0, false), 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);
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++) {
+ size_t start;
+ if (interval_.par[actual._dataEnd-1] == ' ')
+ start = actual._dataEnd;
+ else
+ start = actual._dataEnd+1;
+ for (pos = start; pos < interval_.par.length(); pos++) {
if ((interval_.par[pos] != ' ') && (interval_.par[pos] != '%'))
break;
}
return "";
}
}
+
}
else {
// LYXERR(Debug::INFO, "No regex formats");
s += "\\S";
lastpos = sub.position(2) + sub.length(2);
}
- if (lastpos == 0)
+ if (lastpos == 0) {
+ s = "\\b" + t + "\\b";
+ t = s;
return;
+ }
else if (lastpos < t.length())
s += t.substr(lastpos, t.length() - lastpos);
t = "\\b" + s + "\\b";
LYXERR(Debug::FIND, "par_as_string now is '" << par_as_string << "'");
LYXERR(Debug::FIND, "par_as_string after correctRegex is '" << par_as_string << "'");
++close_wildcards;
- /*
- if (
- // Insert .* before trailing '\$' ('$' has been escaped by escape_for_regex)
- regex_replace(par_as_string, par_as_string, "(.*[^\\\\])(\\\\\\$)\\'", "$1(.*?)$2")
- // Insert .* before trailing '\\\]' ('\]' has been escaped by escape_for_regex)
- || regex_replace(par_as_string, par_as_string, "(.*[^\\\\])( \\\\\\\\\\\\\\])\\'", "$1(.*?)$2")
- // Insert .* before trailing '\\end\{...}' ('\end{...}' has been escaped by escape_for_regex)
- || regex_replace(par_as_string, par_as_string,
- "(.*[^\\\\])( \\\\\\\\end\\\\\\{[a-zA-Z_]*)(\\\\\\*)?(\\\\\\})\\'", "$1(.*?)$2$3$4")
- // Insert .* before trailing '\}' ('}' has been escaped by escape_for_regex)
- || regex_replace(par_as_string, par_as_string, "(.*[^\\\\])(\\\\\\})\\'", "$1(.*?)$2")
- ) {
- ++close_wildcards;
- }
- */
size_t lng = par_as_string.size();
if (!opt.ignoreformat) {
// Remove extra '\}' at end if not part of \{\.\}
string dest = "\\" + std::to_string(i+2);
while (regex_replace(par_as_string, par_as_string, orig, dest));
}
- /* opt.matchword is ignored if using regex
- so expanding par_as_string with "\\b" seems appropriate here
- if regex contains for instance '.*' or '.+'
- 1.) Nothing to do, if 'par_as_string' contains "\\b" already.
- (Means, that the user knows how to handle whole words
- 2.) else replace '.' with "\\S" and wrap the regex with "\\b"
- */
if (opt.matchword) {
modifyRegexForMatchWord(par_as_string);
opt.matchword = false;
{
MatchResult mres;
+ mres.searched_size = len;
if (at_begin &&
(opt.restr == FindAndReplaceOptions::R_ONLY_MATHS && !cur.inMathed()) )
return mres;
int matchend = match.capturedEnd(0);
while (mres.match_len > 0) {
QChar c = qstr.at(matchend - 1);
- if ((c == '\n') || (c == '}') || (c == '{')) {
+ if (c == '\n') {
mres.match_len--;
matchend--;
}
}
else
return mres;
- /* DEAD CODE follows
- if (res == 0 || !at_begin || !opt.matchword || !cur.inTexted())
- return mres;
- if ((len > 0) && (res < len)) {
- mres.match_len = 0;
- return mres;
- }
- Paragraph const & par = cur.paragraph();
- bool ws_left = (cur.pos() > 0)
- ? par.isWordSeparator(cur.pos() - 1)
- : true;
- 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
- << 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)) {
- mres.match_len = 0;
- return mres;
- }
- }
- return mres;
- }
- mres.match_len = 0;
- return mres;
- */
}
#if 0
#if defined(ResultsDebug)
// 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);
- LYXERR0( "pos_len: " << mres.pos_len); // Set in finalize
- for (size_t i = 0; i < mres.result.size(); i++)
- LYXERR0( "Match " << i << " = \"" << mres.result[i] << "\"");
-}
- #define displayMres(s,i) displayMResult(s,i);
-#else
- #define displayMres(s,i)
-#endif
-
-/*
- * Not good, we miss possible matches containing also characters not found in
- * the innermost depth.
-static bool findAdvForwardInnermost(DocIterator & cur)
+static void displayMResult(MatchResult &mres, string from, DocIterator & cur)
{
- size_t d;
- DocIterator old_cur = cur;
- int forwardCount = 0;
- do {
- d = cur.depth();
- old_cur = cur;
- cur.forwardPos();
- if (!cur) {
- break;
- }
- if (cur.depth() > d) {
- forwardCount++;
- continue;
+ LYXERR0( "from:\t\t\t" << from);
+ string status;
+ if (mres.pos_len > 0) {
+ // Set in finalize
+ status = "FINALSEARCH";
+ }
+ else {
+ if (mres.match_len > 0) {
+ if ((mres.match_prefix == 0) && (mres.pos == mres.leadsize))
+ status = "Good Match";
+ else
+ status = "Matched in";
}
- if (cur.depth() == d)
- break;
- } while(1);
- cur = old_cur;
- if (forwardCount > 0) {
- LYXERR(Debug::FIND, "Forwarded " << forwardCount << " step(s) (searching for innermost match)");
- return true;;
+ else
+ status = "MissedSearch";
}
- else
- return false;
+
+ LYXERR0( status << "(" << cur.pos() << " ... " << mres.searched_size + cur.pos() << ") cur.lastpos(" << cur.lastpos() << ")");
+ if ((mres.leadsize > 0) || (mres.match_len > 0) || (mres.match2end > 0))
+ LYXERR0( "leadsize(" << mres.leadsize << ") match_len(" << mres.match_len << ") match2end(" << mres.match2end << ")");
+ if ((mres.pos > 0) || (mres.match_prefix > 0))
+ LYXERR0( "pos(" << mres.pos << ") match_prefix(" << mres.match_prefix << ")");
+ for (size_t i = 0; i < mres.result.size(); i++)
+ LYXERR0( "Match " << i << " = \"" << mres.result[i] << "\"");
}
-*/
+ #define displayMres(s, txt, cur) displayMResult(s, txt, cur);
+#else
+ #define displayMres(s, txt, cur)
+#endif
/** Finalize an advanced find operation, advancing the cursor to the innermost
** position that matches, plus computing the length of the matching text to
// 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 = (expected.match_prefix == 0);
- //if (findAdvForwardInnermost(cur)) {
- if (0) {
- mres = match(cur, -1, at_begin);
- displayMres(mres, 0);
- if (expected.match_len > 0) {
+ LASSERT(at_begin, /**/);
+ if (expected.match_len > 0 && at_begin) {
+ // Search for deepest match
+ old_cur = cur;
+ max_match = expected;
+ do {
+ size_t d = cur.depth();
+ cur.forwardPos();
+ if (!cur)
+ break;
+ if (cur.depth() < d)
+ break;
+ if (cur.depth() == d)
+ break;
+ size_t lastd = d;
+ while (cur && cur.depth() > lastd) {
+ lastd = cur.depth();
+ mres = match(cur, -1, at_begin);
+ displayMres(mres, "Checking innermost", cur);
+ if (mres.match_len > 0)
+ break;
+ // maybe deeper?
+ cur.forwardPos();
+ }
if (mres.match_len < expected.match_len)
- return fail;
- }
- else {
- if (mres.match_len <= 0)
- return fail;
- }
- max_match = mres;
+ break;
+ max_match = mres;
+ old_cur = cur;;
+ } while(1);
+ cur = old_cur;
}
- else if (expected.match_len < 0) {
+ else {
+ // (expected.match_len <= 0)
mres = match(cur); /* match valid only if not searching whole words */
- displayMres(mres, 0);
+ displayMres(mres, "Start with negative match", cur);
max_match = mres;
}
- else {
- max_match = expected;
- }
if (max_match.match_len <= 0) return fail;
LYXERR(Debug::FIND, "Ok");
old_match = new_match;
LYXERR(Debug::FIND, "verifying match with len = " << len);
}
+ displayMres(old_match, "SEARCH RESULT", cur)
return old_match;
}
else {
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.match_len) {
- // actual_match > max_match _can_ happen,
+ displayMres(mres2, "Finalize loop", cur);
+ int actual_match_len = mres2.match_len;
+ if (actual_match_len >= max_match.match_len) {
+ // actual_match_len > 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
+ actual_match_len = max_match.match_len;
+ max_match = mres2;
+ max_match.match_len = actual_match_len;
maxl = len;
if (maxl - minl < 4)
len = (int)((maxl + minl)/2);
len = (int)(minl + (maxl - minl + 3)/4);
}
else {
- // (actual_match < max_match)
+ // (actual_match_len < max_match.match_len)
minl = len + 1;
len = (int)((maxl + minl)/2);
}
}
+ len = minl;
old_cur = cur;
// Search for real start of matched characters
while (len > 1) {
// Ha, got it! The shorter selection has the same match length
len--;
old_cur = cur;
+ max_match = actual_match;
}
else {
// OK, the shorter selection matches less chars, revert to previous value
return fail;
else {
max_match.pos_len = len;
+ displayMres(max_match, "SEARCH RESULT", cur)
return max_match;
}
}
{
if (!cur)
return 0;
+ bool repeat = false;
while (!theApp()->longOperationCancelled() && cur) {
//(void) findAdvForwardInnermost(cur);
LYXERR(Debug::FIND, "findForwardAdv() cur: " << cur);
MatchResult mres = match(cur, -1, false);
- displayMres(mres,-1)
+ string msg = "Starting";
+ if (repeat)
+ msg = "Repeated";
+ displayMres(mres, msg + " findForwardAdv", cur)
int match_len = mres.match_len;
if ((mres.pos > 100000) || (mres.match2end > 100000) || (match_len > 100000)) {
LYXERR(Debug::INFO, "BIG LENGTHS: " << mres.pos << ", " << match_len << ", " << mres.match2end);
match_len = 0;
}
- if (match_len > 0) {
+ 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);
+ cur.forwardPos();
+ }
+ else { // match_len > 0
// Try to find the begin of searched string
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;
+ {
+ int incrmatch = (mres.match_prefix + mres.pos - mres.leadsize + 1)*3/4;
+ int incrcur = (cur.lastpos() - cur.pos() + 1 )*3/4;
+ if (incrcur < incrmatch)
+ increment = incrcur;
+ else
+ increment = incrmatch;
+ if (increment < 1)
+ increment = 1;
+ }
LYXERR(Debug::FIND, "Set increment to " << increment);
while (increment > 0) {
DocIterator old_cur = cur;
- for (int i = 0; i < increment && cur; cur.forwardPos(), i++) {
+ size_t skipping = cur.depth();
+ for (int i = 0; i < increment && cur; i++) {
+ cur.forwardPos();
+ while (cur && cur.depth() > skipping) {
+ cur.pos() = cur.lastpos();
+ cur.forwardPos();
+ }
}
if (! cur || (cur.pit() > old_cur.pit())) {
// Are we outside of the paragraph?
}
else {
MatchResult mres2 = match(cur, -1, false);
- displayMres(mres2,increment)
+ displayMres(mres2, "findForwardAdv loop", cur)
switch (interpretMatch(mres, mres2)) {
case MatchResult::newIsTooFar:
// behind the expected match
increment /= 2;
break;
case MatchResult::newIsBetter:
- // not reached ye, but cur.pos()+increment is bettert
+ // not reached yet, but cur.pos()+increment is bettert
mres = mres2;
firstInvalid -= increment;
if (increment > firstInvalid*3/4)
default:
// Todo@
// Handle not like MatchResult::newIsTooFar
- // LYXERR0( "Something is wrong: Increment = " << increment << " match_prefix = " << mres.match_prefix);
+ LYXERR0( "Something is wrong: Increment = " << increment << " match_prefix = " << mres.match_prefix);
firstInvalid--;
increment = increment*3/4;
cur = old_cur;
}
}
}
+ if (mres.match_len > 0 && mres.match_prefix + mres.pos - mres.leadsize > 0) {
+ repeat = true;
+ cur.forwardPos();
+ continue;
+ }
// LYXERR0("Leaving first loop");
- {
- LYXERR(Debug::FIND, "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;
- }
- else {
- // try next possible match
- cur.forwardPos();
- continue;
- }
+ LYXERR(Debug::FIND, "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;
}
- // 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++ > 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;
- }
- else {
- i = 0;
- }
- }
- LYXERR(Debug::FIND, "Advancing cur: " << cur);
- mres3 = match(cur, 1);
- displayMres(mres3, 1)
- int match_len3 = mres3.match_len;
- if (match_len3 < 0)
- continue;
- 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
- LYXERR(Debug::FIND, "Finalizing 2");
- MatchResult mres4 = findAdvFinalize(cur, match, mres.match_len);
- if (mres4.match_len > 0) {
- match.FillResults(mres4);
- LASSERT(mres4.pos_len > 0, /**/);
- return mres4.pos_len;
- }
- }
- 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;
- }
+ else {
+ // try next possible match
+ cur.forwardPos();
+ repeat = false;
+ continue;
}
- if (!cur)
- return 0;
- }
- if (match_len >= 0 && cur.pit() < cur.lastpit()) {
- LYXERR(Debug::FIND, "Advancing par: cur=" << cur);
- cur.forwardPar();
- } else {
- // This should exit nested insets, if any, or otherwise undefine the currsor.
- cur.pos() = cur.lastpos();
- LYXERR(Debug::FIND, "Advancing pos: cur=" << cur);
- cur.forwardPos();
}
}
return 0;
projects / lyx.git / blobdiff