///
bool getLanguage() { return ignoreLanguage_; };
///
- void setIgnoreFormat(string type, bool value);
+ void setIgnoreFormat(string const & type, bool value);
private:
///
};
-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>
{
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
}
}
}
- return(info);
+ return info;
}
/*
#define MAXOPENED 30
class Intervall {
- bool isPatternString;
+ bool isPatternString_;
public:
explicit Intervall(bool isPattern, string const & p) :
- isPatternString(isPattern), par(p), ignoreidx(-1), actualdeptindex(0),
- hasTitle(false)
+ isPatternString_(isPattern), par(p), ignoreidx(-1), actualdeptindex(0),
+ hasTitle(false), langcount(0)
{
depts[0] = 0;
closes[0] = 0;
int findclosing(int start, int end, char up, char down, int repeat);
void handleParentheses(int lastpos, bool closingAllowed);
bool hasTitle;
+ int langcount; // Number of disabled language specs up to current position in actual interval
int isOpeningPar(int pos);
string titleValue;
void output(ostringstream &os, int lastpos);
accents["lyxmathsym{ß}"] = "ß";
accents["text{ß}"] = "ß";
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
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|dgrave|textdoublegrave|rcap|textroundcap)\\{[^\\{\\}]+\\}|(i|imath|jmath)(?![a-zA-Z]))");
+ 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|dgrave|textdoublegrave|rcap|textroundcap|slashed)\\{[^\\{\\}]+\\}|(i|imath|jmath)(?![a-zA-Z]))");
smatch sub;
for (sregex_iterator itacc(par.begin(), par.end(), accre), end; itacc != end; ++itacc) {
sub = *itacc;
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 removeHead(KeyInfo&, int count=0);
public:
- LatexInfo(string par, bool isPatternString) : entidx(-1), interval(isPatternString, par)
+ 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);
+ 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;
+ if (entries_[0].keytype == KeyInfo::isTitle) {
+ if (! entries_[0].disabled) {
+ interval_.hasTitle = true;
+ interval_.titleValue = entries_[0].head;
}
else {
- interval.hasTitle = false;
- interval.titleValue = "";
+ interval_.hasTitle = false;
+ 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
};
int find(int start, KeyInfo::KeyType keytype) {
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);
// 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 &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(); };
+ bool empty() { return entries_.empty(); };
size_t getEndPos() {
- if (entries.empty() || (actualIdx >= entries.size())) {
+ 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())) {
+ 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())) {
+ 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)
size_t math_pos = 10000;
string math_end;
- 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;
}
}
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;
}
}
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;
}
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;
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;
}
}
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) {
+ int endpar = 2 + interval_.findclosing(found._dataStart, interval_.par.length(), '{', '}', closings);
+ found._dataStart = endpar;
+ found._tokensize = found._dataStart - found._tokenstart;
+ 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 == 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);
}
}
// 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);
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);
}
}
{
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::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] == ' ')) {
+ 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);
+ 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);
// 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:
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;
+ }
+ // Remove also enclosing parentheses [] and {}
+ int numpars = 0;
+ int spaces = 0;
+ while (actual._tokenstart > numpars) {
+ 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;
}
- interval.addIntervall(actual._tokenstart, pos);
+ 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 (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;
}
int LatexInfo::process(ostringstream &os, KeyInfo &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[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
- output_end = interval.nextNotIgnored(end);
+ output_end = interval_.nextNotIgnored(end);
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;
}
if (b && ! info[a]) {
missed++;
LYXERR(Debug::FIND, "Missed(" << missed << " " << a <<", srclen = " << parlen );
- return("");
+ return "";
}
}
}
else {
// LYXERR0("No regex formats");
}
- return(result);
+ return result;
}
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");
- }
+ 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 {
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;
}
break;
}
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)
{
}
projects / lyx.git / blobdiff