+#ifdef __GNUG__
+#pragma implementation
+#endif
+
// This file contains most of the magic that extracts "context
// information" from the unstructered layout-oriented stuff in an
// MathArray.
#include "support/lyxlib.h"
#include "support/systemcall.h"
#include "support/filetools.h"
+#include "support/lstrings.h"
#include <algorithm>
typedef bool TestItemFunc(MathAtom const &);
// define a function for replacing subexpressions
-typedef MathInset * ReplaceArgumentFunc(const MathArray & ar);
+typedef MathAtom ReplaceArgumentFunc(const MathArray & ar);
}
-MathInset const * singleItem(MathArray const & ar)
-{
- return ar.size() == 1 ? ar.begin()->nucleus() : 0;
-}
-
-
void extractMatrices(MathArray & ar)
{
//lyxerr << "\nMatrices from: " << ar << "\n";
// first pass for explicitly delimited stuff
- for (MathArray::iterator it = ar.begin(); it != ar.end(); ++it) {
- MathDelimInset * del = (*it)->asDelimInset();
- if (!del)
+ for (MathArray::size_type i = 0; i < ar.size(); ++i) {
+ if (!ar[i]->asDelimInset())
+ continue;
+ MathArray const & arr = ar[i]->asDelimInset()->cell(0);
+ if (arr.size() != 1)
continue;
- MathInset const * arr = singleItem(del->cell(0));
- if (!arr || !arr->asGridInset())
+ if (!arr.front()->asGridInset())
continue;
- *it = MathAtom(new MathMatrixInset(*(arr->asGridInset())));
+ ar[i] = MathAtom(new MathMatrixInset(*(arr.front()->asGridInset())));
}
// second pass for AMS "pmatrix" etc
- for (MathArray::iterator it = ar.begin(); it != ar.end(); ++it) {
- MathAMSArrayInset * ams = (*it)->asAMSArrayInset();
- if (!ams)
- continue;
- *it = MathAtom(new MathMatrixInset(*ams));
- }
+ for (MathArray::size_type i = 0; i < ar.size(); ++i)
+ if (ar[i]->asAMSArrayInset())
+ ar[i] = MathAtom(new MathMatrixInset(*(ar[i]->asGridInset())));
//lyxerr << "\nMatrices to: " << ar << "\n";
}
// to modify the array.
for (MathArray::size_type i = 0; i < ar.size(); ++i) {
// check whether this is the begin of the sequence
- MathArray::iterator it = ar.begin() + i;
- if (!testOpen(*it))
+ if (!testOpen(ar[i]))
continue;
// search end of sequence
+ MathArray::iterator it = ar.begin() + i;
MathArray::iterator jt = endNestSearch(it, ar.end(), testOpen, testClose);
if (jt == ar.end())
continue;
- // create a proper inset as replacement
- MathInset * p = replaceArg(MathArray(it + 1, jt));
-
// replace the original stuff by the new inset
+ ar[i] = replaceArg(MathArray(it + 1, jt));
ar.erase(it + 1, jt + 1);
- *it = MathAtom(p);
}
}
{
//lyxerr << "\nScripts from: " << ar << "\n";
for (MathArray::size_type i = 0; i < ar.size(); ++i) {
- MathArray::iterator it = ar.begin() + i;
-
// is this script inset?
- MathScriptInset * p = (*it)->asScriptInset();
- if (!p)
+ if (!ar[i]->asScriptInset())
continue;
// no problem if we don't have both...
- if (!p->hasUp() || !p->hasDown())
+ if (!ar[i]->asScriptInset()->hasUp())
+ continue;
+ if (!ar[i]->asScriptInset()->hasDown())
continue;
// create extra script inset and move superscript over
- MathScriptInset * q = new MathScriptInset;
- q->ensure(true);
+ MathScriptInset * p = ar[i].nucleus()->asScriptInset();
+ MathScriptInset * q = new MathScriptInset(true);
std::swap(q->up(), p->up());
p->removeScript(true);
void extractExps(MathArray & ar)
{
//lyxerr << "\nExps from: " << ar << "\n";
-
for (MathArray::size_type i = 0; i + 1 < ar.size(); ++i) {
- MathArray::iterator it = ar.begin() + i;
-
// is this 'e'?
- MathCharInset const * p = (*it)->asCharInset();
- if (!p || p->getChar() != 'e')
+ if (ar[i]->getChar() != 'e')
continue;
// we need an exponent but no subscript
- MathScriptInset * sup = (*(it + 1))->asScriptInset();
+ MathScriptInset const * sup = ar[i + 1]->asScriptInset();
if (!sup || sup->hasDown())
continue;
- // create a proper exp-inset as replacement
- *it = MathAtom(new MathExFuncInset("exp", sup->cell(1)));
- ar.erase(it + 1);
+ // create a proper exp-inset as replacement
+ ar[i] = MathAtom(new MathExFuncInset("exp", sup->cell(1)));
+ ar.erase(i + 1);
}
//lyxerr << "\nExps to: " << ar << "\n";
}
{
//lyxerr << "\ndet from: " << ar << "\n";
for (MathArray::iterator it = ar.begin(); it != ar.end(); ++it) {
- MathDelimInset * del = (*it)->asDelimInset();
+ MathDelimInset const * del = (*it)->asDelimInset();
if (!del)
continue;
if (!del->isAbs())
}
-MathInset * replaceDelims(const MathArray & ar)
+MathAtom replaceDelims(const MathArray & ar)
{
- return new MathDelimInset("(", ")", ar);
+ return MathAtom(new MathDelimInset("(", ")", ar));
}
continue;
// guess so, if this is followed by
// a DelimInset with a single item in the cell
- MathDelimInset * del = (*jt)->asDelimInset();
+ MathDelimInset const * del = (*jt)->asDelimInset();
if (!del || del->cell(0).size() != 1)
continue;
// fall trough into main branch
{
return
testIntSymbol(at) ||
- ( at->asScriptInset()
+ ( at->asScriptInset()
&& at->asScriptInset()->nuc().size()
&& testIntSymbol(at->asScriptInset()->nuc().back()) );
}
{
return
testSumSymbol(at) ||
- ( at->asScriptInset()
+ ( at->asScriptInset()
&& at->asScriptInset()->nuc().size()
&& testSumSymbol(at->asScriptInset()->nuc().back()) );
}
MathArray::iterator it = ar.begin() + i;
// is this a sum name?
- if (!testSum(*it))
+ if (!testSum(ar[i]))
continue;
// create a proper inset as replacement
MathExIntInset * p = new MathExIntInset("sum");
// collect lower bound and summation index
- MathScriptInset * sub = (*it)->asScriptInset();
+ MathScriptInset const * sub = ar[i]->asScriptInset();
if (sub && sub->hasDown()) {
// try to figure out the summation index from the subscript
- MathArray & ar = sub->down();
- MathArray::iterator xt =
+ MathArray const & ar = sub->down();
+ MathArray::const_iterator xt =
find_if(ar.begin(), ar.end(), &testEqualSign);
if (xt != ar.end()) {
// we found a '=', use everything in front of that as index,
if (!testDiffFrac(*it))
continue;
- MathFracInset * f = (*it)->asFracInset();
+ MathFracInset const * f = (*it)->asFracInset();
if (!f) {
lyxerr << "should not happen\n";
continue;
// collect function, let jt point behind last used item
MathArray::iterator jt = it + 1;
//int n = 1;
- MathArray & numer = f->cell(0);
+ MathArray const & numer = f->cell(0);
if (numer.size() > 1 && numer[1]->asScriptInset()) {
// this is something like d^n f(x) / d... or d^n / d...
// FIXME
}
// collect denominator parts
- MathArray & denom = f->cell(1);
- for (MathArray::iterator dt = denom.begin(); dt != denom.end();) {
+ MathArray const & denom = f->cell(1);
+ for (MathArray::const_iterator dt = denom.begin(); dt != denom.end();) {
// find the next 'd'
- MathArray::iterator et = find_if(dt + 1, denom.end(), &testDiffItem);
+ MathArray::const_iterator et
+ = find_if(dt + 1, denom.end(), &testDiffItem);
// point before this
- MathArray::iterator st = et - 1;
- MathScriptInset * script = (*st)->asScriptInset();
+ MathArray::const_iterator st = et - 1;
+ MathScriptInset const * script = (*st)->asScriptInset();
if (script && script->hasUp()) {
// things like d.../dx^n
int mult = 1;
MathArray::iterator it = ar.begin() + i;
// is this a limit function?
- if (!testSymbol(*it, "lim"))
+ if (!testSymbol(*it, "lim"))
continue;
// the next one must be a subscript (without superscript)
- MathScriptInset * sub = (*(it + 1))->asScriptInset();
+ MathScriptInset const * sub = (*(it + 1))->asScriptInset();
if (!sub || !sub->hasDown() || sub->hasUp())
continue;
// and it must contain a -> symbol
- MathArray & s = sub->down();
- MathArray::iterator st = find_if(s.begin(), s.end(), &testRightArrow);
+ MathArray const & s = sub->down();
+ MathArray::const_iterator st = find_if(s.begin(), s.end(), &testRightArrow);
if (st == s.end())
continue;
// the -> splits the subscript int x and x0
MathArray x = MathArray(s.begin(), st);
MathArray x0 = MathArray(st + 1, s.end());
-
+
// use something behind the script as core
MathArray f;
MathArray::iterator tt = extractArgument(f, it + 2, ar.end());
void extractStructure(MathArray & ar)
{
+ //lyxerr << "\nStructure from: " << ar << "\n";
extractIntegrals(ar);
extractSums(ar);
splitScripts(ar);
extractExps(ar);
extractLims(ar);
extractStrings(ar);
+ //lyxerr << "\nStructure to: " << ar << "\n";
}
}
+void maximize(MathArray const & dat, MaximaStream & os)
+{
+ MathArray ar = dat;
+ extractStructure(ar);
+ for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it)
+ (*it)->maximize(os);
+}
+
+
void mathematicize(MathArray const & dat, MathematicaStream & os)
{
MathArray ar = dat;
if (ar.size() == 0)
os << "<mrow/>";
else if (ar.size() == 1)
- os << ar.begin()->nucleus();
+ os << ar.front();
else {
os << MTag("mrow");
for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it)
string captureOutput(string const & cmd, string const & data)
{
- string outfile = lyx::tempName(string(), "mathextern");
- string full = "echo '" + data + "' | (" + cmd + ") > " + outfile;
- lyxerr << "calling: " << full << endl;
- Systemcall dummy;
- dummy.startscript(Systemcall::Wait, full);
- string out = GetFileContents(outfile);
- lyx::unlink(outfile);
- lyxerr << "result: '" << out << "'" << endl;
- return out;
+ string command = "echo '" + data + "' | " + cmd;
+ lyxerr << "calling: " << command << endl;
+ cmd_ret const ret = RunCommand(command);
+ return ret.second;
+ }
+
+ string::size_type get_matching_brace(string const & str, string::size_type i)
+ {
+ int count = 1;
+ string::size_type n = str.size();
+ while (i < n) {
+ i = str.find_first_of("{}", i+1);
+ if (i == string::npos) return i;
+ if (str[i] == '{')
+ ++count;
+ else
+ --count;
+ if (count == 0)
+ return i;
+ }
+ return string::npos;
+ }
+
+ string::size_type get_matching_brace_back(string const & str, string::size_type i)
+ {
+ int count = 1;
+ while (i > 0) {
+ i = str.find_last_of("{}", i-1);
+ if (i == string::npos) return i;
+ if (str[i] == '}')
+ ++count;
+ else
+ --count;
+ if (count == 0)
+ return i;
+ }
+ return string::npos;
+ }
+
+ MathArray pipeThroughMaxima(string const &, MathArray const & ar)
+ {
+ ostringstream os;
+ MaximaStream ms(os);
+ ms << ar;
+ string expr = STRCONV(os.str());
+ string const header = "SIMPSUM:true;";
+
+ string out;
+ for (int i = 0; i < 100; ++i) { // at most 100 attempts
+ // try to fix missing '*' the hard way
+ //
+ // > echo "2x;" | maxima
+ // ...
+ // (C1) Incorrect syntax: x is not an infix operator
+ // 2x;
+ // ^
+ //
+ lyxerr << "checking expr: '" << expr << "'\n";
+ string full = header + "tex(" + expr + ");";
+ out = captureOutput("maxima", full);
+
+ // leave loop if expression syntax is probably ok
+ if (out.find("Incorrect syntax") == string::npos)
+ break;
+
+ // search line with "Incorrect syntax"
+ istringstream is(out.c_str());
+ string line;
+ while (is) {
+ getline(is, line);
+ if (line.find("Incorrect syntax") != string::npos)
+ break;
+ }
+
+ // 2nd next line is the one with caret
+ getline(is, line);
+ getline(is, line);
+ string::size_type pos = line.find('^');
+ lyxerr << "found caret at pos: '" << pos << "'\n";
+ if (pos == string::npos || pos < 4)
+ break; // caret position not found
+ pos -= 4; // skip the "tex(" part
+ if (expr[pos] == '*')
+ break; // two '*' in a row are definitely bad
+ expr.insert(pos, "*");
+ }
+
+ std::vector<string> tmp = getVectorFromString(out, "$$");
+ if (tmp.size() < 2)
+ return MathArray();
+
+ out = subst(tmp[1],"\\>", "");
+ lyxerr << "out: '" << out << "'\n";
+
+ // Ugly code that tries to make the result prettier
+
+ string::size_type i = out.find("\\mathchoice");
+ while (i != string::npos) {
+ string::size_type j = get_matching_brace(out, i + 12);
+ string::size_type k = get_matching_brace(out, j + 1);
+ k = get_matching_brace(out, k + 1);
+ k = get_matching_brace(out, k + 1);
+ string mid = out.substr(i + 13,j - i - 13);
+ if (mid.find("\\over") != string::npos)
+ mid = '{' + mid + '}';
+ out = out.substr(0,i)
+ + mid
+ + out.substr(k + 1);
+ //lyxerr << "out: " << out << endl;
+ i = out.find("\\mathchoice", i);
+ break;
+ }
+
+ i = out.find("\\over");
+ while (i != string::npos) {
+ string::size_type j = get_matching_brace_back(out, i - 1);
+ if (j == string::npos || j == 0) break;
+ string::size_type k = get_matching_brace(out, i + 5);
+ if (k == string::npos || k + 1 == out.size()) break;
+ out = out.substr(0,j - 1)
+ + "\\frac"
+ + out.substr(j,i - j)
+ + out.substr(i + 5,k - i - 4)
+ + out.substr(k + 2);
+ //lyxerr << "out: " << out << endl;
+ i = out.find("\\over", i + 4);
+ }
+ MathArray res;
+ mathed_parse_cell(res, out);
+ return res;
}
ostringstream os;
MapleStream ms(os);
ms << ar;
- string expr = os.str().c_str();
+ string expr = STRCONV(os.str());
lyxerr << "ar: '" << ar << "'\n";
lyxerr << "ms: '" << os.str() << "'\n";
// Probably missing an operator such as * p
//
lyxerr << "checking expr: '" << expr << "'\n";
- string out = captureOutput("mint -i 1 -S -s -q -q", expr + ";");
+ string out = captureOutput("mint -i 1 -S -s -q -q", expr + ';');
if (out.empty())
break; // expression syntax is ok
istringstream is(out.c_str());
pos -= 15; // skip the "on line ..." part
if (expr[pos] == '*' || (pos > 0 && expr[pos - 1] == '*'))
break; // two '*' in a row are definitely bad
- expr.insert(pos, "*");
+ expr.insert(pos, 1, '*');
}
string full = "latex(" + extra + '(' + expr + "));";
ostringstream os;
OctaveStream vs(os);
vs << ar;
- string expr = os.str().c_str();
+ string expr = STRCONV(os.str());
string out;
lyxerr << "pipe: ar: '" << ar << "'\n";
pos -= 4; // skip the ">>> " part
if (expr[pos] == '*')
break; // two '*' in a row are definitely bad
- expr.insert(pos, "*");
+ expr.insert(pos, 1, '*');
}
if (out.size() < 6)
// parse output as matrix or single number
MathAtom at(new MathArrayInset("array", out));
- MathArrayInset const * mat = at.nucleus()->asArrayInset();
+ MathArrayInset const * mat = at->asArrayInset();
MathArray res;
if (mat->ncols() == 1 && mat->nrows() == 1)
res.append(mat->cell(0));
else {
res.push_back(MathAtom(new MathDelimInset("(", ")")));
- res.back()->cell(0).push_back(at);
+ res.back().nucleus()->cell(0).push_back(at);
}
return res;
}
if (lang == "octave")
return pipeThroughOctave(extra, ar);
+ if (lang == "maxima")
+ return pipeThroughMaxima(extra, ar);
+
if (lang == "maple")
return pipeThroughMaple(extra, ar);
// create normalized expression
ostringstream os;
NormalStream ns(os);
- os << "[" << extra << ' ';
+ os << '[' << extra << ' ';
ns << ar;
- os << "]";
- string data = os.str().c_str();
+ os << ']';
+ string data = STRCONV(os.str());
// search external script
string file = LibFileSearch("mathed", "extern_" + lang);
if (file.empty()) {
- lyxerr << "converter to '" << lang << "' not found\n";
+ lyxerr << "converter to '" << lang << "' not found" << endl;
return MathArray();
}