#include "MathParser.h"
#include "MathStream.h"
+#include "Encoding.h"
+
#include "support/debug.h"
#include "support/docstream.h"
#include "support/FileName.h"
#include "support/filetools.h"
+#include "support/gettext.h"
#include "support/lstrings.h"
#include "support/TempFile.h"
+#include "support/textutils.h"
+#include "support/unique_ptr.h"
#include <algorithm>
#include <sstream>
"det", "dim", "exp", "gcd", "hom", "inf", "ker",
"lg", "lim", "liminf", "limsup", "ln", "log",
"max", "min", "sec", "sin", "sinh", "sup",
- "tan", "tanh", "Pr", 0
+ "tan", "tanh", "Pr", nullptr
};
static size_t const npos = lyx::docstring::npos;
// try to extract an "argument" to some function.
// returns position behind the argument
MathData::iterator extractArgument(MathData & ar,
- MathData::iterator pos, MathData::iterator last,
+ MathData::iterator pos, MathData::iterator last,
ExternalMath kind, bool function = false)
{
// nothing to get here
if (!ar[i]->asCharInset())
continue;
docstring s = charSequence(ar.begin() + i, ar.end());
- ar[i] = MathAtom(new InsetMathString(s));
+ ar[i] = MathAtom(new InsetMathString(ar.buffer(), s));
ar.erase(i + 1, i + s.size());
}
//lyxerr << "\nStrings to: " << ar << endl;
continue;
if (!arr.front()->asGridInset())
continue;
- ar[i] = MathAtom(new InsetMathMatrix(*(arr.front()->asGridInset()),
+ ar[i] = MathAtom(new InsetMathMatrix(*(arr.front()->asGridInset()),
inset->left_, inset->right_));
}
return testString(at, from_ascii(str));
}
+
+bool testSymbol(MathAtom const & at, docstring const & name)
+{
+ return at->asSymbolInset() && at->asSymbolInset()->name() == name;
+}
+
+
+bool testSymbol(MathAtom const & at, char const * const name)
+{
+ return testSymbol(at, from_ascii(name));
+}
+
+
// search end of nested sequence
MathData::iterator endNestSearch(
MathData::iterator it,
- MathData::iterator last,
+ const MathData::iterator& last,
TestItemFunc testOpen,
TestItemFunc testClose
)
//
-// split scripts into seperate super- and subscript insets. sub goes in
+// split scripts into separate super- and subscript insets. sub goes in
// front of super...
//
// create extra script inset and move superscript over
InsetMathScript * p = ar[i].nucleus()->asScriptInset();
- auto_ptr<InsetMathScript> q(new InsetMathScript(buf, true));
+ auto q = make_unique<InsetMathScript>(buf, true);
swap(q->up(), p->up());
p->removeScript(true);
docstring s = digitSequence(ar.begin() + i, ar.end());
- ar[i] = MathAtom(new InsetMathNumber(s));
+ ar[i] = MathAtom(new InsetMathNumber(ar.buffer(), s));
ar.erase(i + 1, i + s.size());
}
//lyxerr << "\nNumbers to: " << ar << endl;
MathAtom replaceParenDelims(const MathData & ar)
{
return MathAtom(new InsetMathDelim(const_cast<Buffer *>(ar.buffer()),
- from_ascii("("), from_ascii(")"), ar));
+ from_ascii("("), from_ascii(")"), ar, true));
}
MathAtom replaceBracketDelims(const MathData & ar)
{
return MathAtom(new InsetMathDelim(const_cast<Buffer *>(ar.buffer()),
- from_ascii("["), from_ascii("]"), ar));
+ from_ascii("["), from_ascii("]"), ar, true));
+}
+
+
+bool testOpenVert(MathAtom const & at)
+{
+ return testSymbol(at, "lvert");
+}
+
+
+bool testCloseVert(MathAtom const & at)
+{
+ return testSymbol(at, "rvert");
}
-// replace '('...')' and '['...']' sequences by a real InsetMathDelim
+MathAtom replaceVertDelims(const MathData & ar)
+{
+ return MathAtom(new InsetMathDelim(const_cast<Buffer *>(ar.buffer()),
+ from_ascii("lvert"), from_ascii("rvert"), ar, true));
+}
+
+
+bool testOpenAngled(MathAtom const & at)
+{
+ return testSymbol(at, "langle");
+}
+
+
+bool testCloseAngled(MathAtom const & at)
+{
+ return testSymbol(at, "rangle");
+}
+
+
+MathAtom replaceAngledDelims(const MathData & ar)
+{
+ return MathAtom(new InsetMathDelim(const_cast<Buffer *>(ar.buffer()),
+ from_ascii("langle"), from_ascii("rangle"), ar, true));
+}
+
+
+// replace '('...')', '['...']', '|'...'|', and '<'...'>' sequences by a real InsetMathDelim
void extractDelims(MathData & ar)
{
//lyxerr << "\nDelims from: " << ar << endl;
replaceNested(ar, testOpenParen, testCloseParen, replaceParenDelims);
replaceNested(ar, testOpenBracket, testCloseBracket, replaceBracketDelims);
+ replaceNested(ar, testOpenVert, testCloseVert, replaceVertDelims);
+ replaceNested(ar, testOpenAngled, testCloseAngled, replaceAngledDelims);
//lyxerr << "\nDelims to: " << ar << endl;
}
// do we have an exponent like in
// 'sin' '^2' 'x' -> 'sin(x)' '^2'
- MathData exp;
+ MathData exp(buf);
extractScript(exp, jt, ar.end(), true);
// create a proper inset as replacement
- auto_ptr<InsetMathExFunc> p(new InsetMathExFunc(buf, name));
+ auto p = lyx::make_unique<InsetMathExFunc>(buf, name);
// jt points to the "argument". Get hold of this.
- MathData::iterator st =
+ MathData::iterator st =
extractArgument(p->cell(0), jt, ar.end(), kind, true);
// replace the function name by a real function inset
// search integrals
//
-bool testSymbol(MathAtom const & at, docstring const & name)
-{
- return at->asSymbolInset() && at->asSymbolInset()->name() == name;
-}
-
-
-bool testSymbol(MathAtom const & at, char const * const name)
-{
- return at->asSymbolInset() && at->asSymbolInset()->name() == from_ascii(name);
-}
-
-
bool testIntSymbol(MathAtom const & at)
{
return testSymbol(at, from_ascii("int"));
if (!testIntegral(*it))
continue;
- // core ist part from behind the scripts to the 'd'
- auto_ptr<InsetMathExInt> p(new InsetMathExInt(buf, from_ascii("int")));
+ // core is part from behind the scripts to the 'd'
+ auto p = lyx::make_unique<InsetMathExInt>(buf, from_ascii("int"));
// handle scripts if available
if (!testIntSymbol(*it)) {
continue;
// create a proper inset as replacement
- auto_ptr<InsetMathExInt> p(new InsetMathExInt(buf, from_ascii("sum")));
+ auto p = lyx::make_unique<InsetMathExInt>(buf, from_ascii("sum"));
// collect lower bound and summation index
InsetMathScript const * sub = ar[i]->asScriptInset();
if (sub && sub->hasDown()) {
// try to figure out the summation index from the subscript
- MathData const & ar = sub->down();
+ MathData const & md = sub->down();
MathData::const_iterator xt =
- find_if(ar.begin(), ar.end(), &testEqualSign);
- if (xt != ar.end()) {
+ find_if(md.begin(), md.end(), &testEqualSign);
+ if (xt != md.end()) {
// we found a '=', use everything in front of that as index,
// and everything behind as lower index
- p->cell(1) = MathData(buf, ar.begin(), xt);
- p->cell(2) = MathData(buf, xt + 1, ar.end());
+ p->cell(1) = MathData(buf, md.begin(), xt);
+ p->cell(2) = MathData(buf, xt + 1, md.end());
} else {
// use everything as summation index, don't use scripts.
- p->cell(1) = ar;
+ p->cell(1) = md;
}
}
}
// create a proper diff inset
- auto_ptr<InsetMathDiff> diff(new InsetMathDiff(buf));
+ auto diff = lyx::make_unique<InsetMathDiff>(buf);
// collect function, let jt point behind last used item
MathData::iterator jt = it + 1;
int mult = 1;
if (extractNumber(script->up(), mult)) {
//lyxerr << "mult: " << mult << endl;
- for (int i = 0; i < mult; ++i)
+ if (mult < 0 || mult > 1000) {
+ lyxerr << "Cannot differentiate less than 0 or more than 1000 times !" << endl;
+ continue;
+ }
+ for (int ii = 0; ii < mult; ++ii)
diff->addDer(MathData(buf, dt + 1, st));
}
} else {
MathData x0 = MathData(buf, st + 1, s.end());
// use something behind the script as core
- MathData f;
+ MathData f(buf);
MathData::iterator tt = extractTerm(f, it + 1, ar.end());
// cleanup
{
// In order to avoid parsing problems with command interpreters
// we pass input data through a file
- TempFile tempfile("casinput");
- FileName const cas_tmpfile = tempfile.name();
+ // Since the CAS is supposed to read the temp file we need
+ // to unlock it on windows (bug 10262).
+ unique_ptr<TempFile> tempfile(new TempFile("casinput"));
+ tempfile->setAutoRemove(false);
+ FileName const cas_tmpfile = tempfile->name();
+ tempfile.reset();
+
if (cas_tmpfile.empty()) {
lyxerr << "Warning: cannot create temporary file."
<< endl;
lyxerr << "calling: " << cmd
<< "\ninput: '" << data << "'" << endl;
cmd_ret const ret = runCommand(command);
- return ret.second;
+ cas_tmpfile.removeFile();
+ return ret.result;
}
size_t get_matching_brace(string const & str, size_t i)
vector<string> tmp = getVectorFromString(out, "$$");
if (tmp.size() < 2)
- return MathData();
+ return MathData(nullptr);
- out = subst(tmp[1], "\\>", string());
+ out = subst(subst(tmp[1], "\\>", string()), "{\\it ", "\\mathit{");
lyxerr << "output: '" << out << "'" << endl;
// Ugly code that tries to make the result prettier
+ out.substr(k + 1);
//lyxerr << "output: " << out << endl;
i = out.find("\\mathchoice", i);
- break;
}
i = out.find("\\over");
//lyxerr << "output: " << out << endl;
i = out.find("\\over", i + 4);
}
- MathData res;
+ MathData res(nullptr);
mathed_parse_cell(res, from_utf8(out));
return res;
}
// change \_ into _
//
- MathData res;
+ MathData res(nullptr);
mathed_parse_cell(res, from_utf8(out));
return res;
}
// ansi control sequence before, such as '\033[?1034hans = '
size_t i = out.find("ans = ");
if (i == string::npos)
- return MathData();
+ return MathData(nullptr);
out = out.substr(i + 6);
// parse output as matrix or single number
size_t pos2 = out.find("In[2]:=");
if (pos1 == string::npos || pos2 == string::npos)
- return MathData();
+ return MathData(nullptr);
// get everything from pos1+17 to pos2
out = out.substr(pos1 + 17, pos2 - pos1 - 17);
prettifyMathematicaOutput(out, "Muserfunction", true, false);
prettifyMathematicaOutput(out, "Mvariable", false, false);
- MathData res;
+ MathData res(nullptr);
mathed_parse_cell(res, from_utf8(out));
return res;
}
-}
+} // namespace
-} // anon namespace
+} // namespace
-void write(MathData const & dat, WriteStream & wi)
+void write(MathData const & dat, TeXMathStream & wi)
{
- MathData ar = dat;
- extractStrings(ar);
wi.firstitem() = true;
- for (MathData::const_iterator it = ar.begin(); it != ar.end(); ++it) {
- (*it)->write(wi);
+ docstring s;
+ for (MathData::const_iterator it = dat.begin(); it != dat.end(); ++it) {
+ InsetMathChar const * const c = (*it)->asCharInset();
+ if (c)
+ s += c->getChar();
+ else {
+ if (!s.empty()) {
+ writeString(s, wi);
+ s.clear();
+ }
+ (*it)->write(wi);
+ wi.firstitem() = false;
+ }
+ }
+ if (!s.empty()) {
+ writeString(s, wi);
wi.firstitem() = false;
}
}
+void writeString(docstring const & s, TeXMathStream & os)
+{
+ if (!os.latex()) {
+ os << s;
+ return;
+ }
+
+ docstring str = s;
+ if (os.asciiOnly())
+ str = escape(s);
+
+ if (os.output() == TeXMathStream::wsSearchAdv) {
+ os << str;
+ return;
+ }
+
+ if (os.lockedMode()) {
+ bool space;
+ docstring cmd;
+ for (char_type c : str) {
+ try {
+ Encodings::latexMathChar(c, true, os.encoding(), cmd, space);
+ os << cmd;
+ os.pendingSpace(space);
+ } catch (EncodingException const & e) {
+ switch (os.output()) {
+ case TeXMathStream::wsDryrun: {
+ os << "<" << _("LyX Warning: ")
+ << _("uncodable character") << " '";
+ os << docstring(1, e.failed_char);
+ os << "'>";
+ break;
+ }
+ case TeXMathStream::wsPreview: {
+ // indicate the encoding error by a boxed '?'
+ os << "{\\fboxsep=1pt\\fbox{?}}";
+ LYXERR0("Uncodable character" << " '"
+ << docstring(1, e.failed_char)
+ << "'");
+ break;
+ }
+ case TeXMathStream::wsDefault:
+ default:
+ // throw again
+ throw;
+ }
+ }
+ }
+ return;
+ }
+
+ // We may already be inside an \ensuremath command.
+ bool in_forced_mode = os.pendingBrace();
+
+ // We will take care of matching braces.
+ os.pendingBrace(false);
+
+ for (char_type const c : str) {
+ bool mathmode = in_forced_mode ? os.textMode() : !os.textMode();
+ docstring command(1, c);
+ try {
+ bool termination = false;
+ if (isASCII(c) ||
+ Encodings::latexMathChar(c, mathmode, os.encoding(), command, termination)) {
+ if (os.textMode()) {
+ if (in_forced_mode) {
+ // we were inside \lyxmathsym
+ os << '}';
+ os.textMode(false);
+ in_forced_mode = false;
+ }
+ if (!isASCII(c) && os.textMode()) {
+ os << "\\ensuremath{";
+ os.textMode(false);
+ in_forced_mode = true;
+ }
+ } else if (isASCII(c) && in_forced_mode) {
+ // we were inside \ensuremath
+ os << '}';
+ os.textMode(true);
+ in_forced_mode = false;
+ }
+ } else if (!os.textMode()) {
+ if (in_forced_mode) {
+ // we were inside \ensuremath
+ os << '}';
+ in_forced_mode = false;
+ } else {
+ os << "\\lyxmathsym{";
+ in_forced_mode = true;
+ }
+ os.textMode(true);
+ }
+ os << command;
+ // We may need a space if the command contains a macro
+ // and the last char is ASCII.
+ if (termination)
+ os.pendingSpace(true);
+ } catch (EncodingException const & e) {
+ switch (os.output()) {
+ case TeXMathStream::wsDryrun: {
+ os << "<" << _("LyX Warning: ")
+ << _("uncodable character") << " '";
+ os << docstring(1, e.failed_char);
+ os << "'>";
+ break;
+ }
+ case TeXMathStream::wsPreview: {
+ // indicate the encoding error by a boxed '?'
+ os << "{\\fboxsep=1pt\\fbox{?}}";
+ LYXERR0("Uncodable character" << " '"
+ << docstring(1, e.failed_char)
+ << "'");
+ break;
+ }
+ case TeXMathStream::wsDefault:
+ default:
+ // throw again
+ throw;
+ }
+ }
+ }
+
+ if (in_forced_mode && os.textMode()) {
+ // We have to care for closing \lyxmathsym
+ os << '}';
+ os.textMode(false);
+ } else {
+ os.pendingBrace(in_forced_mode);
+ }
+}
+
+
void normalize(MathData const & ar, NormalStream & os)
{
for (MathData::const_iterator it = ar.begin(); it != ar.end(); ++it)
}
-void mathmlize(MathData const & dat, MathStream & os)
+void mathmlize(MathData const & dat, MathMLStream & ms)
{
MathData ar = dat;
extractStructure(ar, MATHML);
- if (ar.empty())
- os << "<mrow/>";
- else if (ar.size() == 1)
- os << ar.front();
- else {
- os << MTag("mrow");
+ if (ar.empty()) {
+ if (!ms.inText())
+ ms << CTag("mrow");
+ } else if (ar.size() == 1) {
+ ms << ar.front();
+ } else {
+ if (!ms.inText())
+ ms << MTag("mrow");
for (MathData::const_iterator it = ar.begin(); it != ar.end(); ++it)
- (*it)->mathmlize(os);
- os << ETag("mrow");
+ (*it)->mathmlize(ms);
+ if (!ms.inText())
+ ms << ETag("mrow");
}
}
FileName const file = libFileSearch("mathed", "extern_" + lang);
if (file.empty()) {
lyxerr << "converter to '" << lang << "' not found" << endl;
- return MathData();
+ return MathData(nullptr);
}
// run external sript
string out = captureOutput(file.absFileName(), data);
- MathData res;
+ MathData res(nullptr);
mathed_parse_cell(res, from_utf8(out));
return res;
}
projects / lyx.git / blobdiff