+/**
+ * \file math_extern.C
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
+ *
+ * \author André Pönitz
+ *
+ * Full author contact details are available in file CREDITS.
+ */
// This file contains most of the magic that extracts "context
// information" from the unstructered layout-oriented stuff in an
#include <config.h>
-#include "math_amsarrayinset.h"
+#include "math_extern.h"
#include "math_arrayinset.h"
#include "math_charinset.h"
#include "math_deliminset.h"
+#include "math_data.h"
#include "math_diffinset.h"
#include "math_exfuncinset.h"
#include "math_exintinset.h"
#include "math_scriptinset.h"
#include "math_stringinset.h"
#include "math_symbolinset.h"
-#include "math_unknowninset.h"
#include "math_parser.h"
-#include "Lsstream.h"
#include "debug.h"
-#include "support/lyxlib.h"
-#include "support/systemcall.h"
#include "support/filetools.h"
#include "support/lstrings.h"
#include <algorithm>
+#include <sstream>
-using std::ostream;
-using std::istringstream;
-using std::find_if;
+using lyx::support::cmd_ret;
+using lyx::support::getVectorFromString;
+using lyx::support::LibFileSearch;
+using lyx::support::RunCommand;
+using lyx::support::subst;
+
+using std::string;
using std::endl;
+using std::find_if;
+using std::auto_ptr;
+using std::istringstream;
+using std::ostream;
+using std::ostringstream;
+using std::swap;
+using std::vector;
ostream & operator<<(ostream & os, MathArray const & ar)
void extractStrings(MathArray & ar)
{
- //lyxerr << "\nStrings from: " << ar << "\n";
- for (MathArray::size_type i = 0; i < ar.size(); ++i) {
+ //lyxerr << "\nStrings from: " << ar << endl;
+ for (size_t i = 0; i < ar.size(); ++i) {
if (!ar[i]->asCharInset())
continue;
string s = charSequence(ar.begin() + i, ar.end());
ar[i] = MathAtom(new MathStringInset(s));
ar.erase(i + 1, i + s.size());
}
- //lyxerr << "\nStrings to: " << ar << "\n";
+ //lyxerr << "\nStrings to: " << ar << endl;
}
void extractMatrices(MathArray & ar)
{
- //lyxerr << "\nMatrices from: " << ar << "\n";
+ //lyxerr << "\nMatrices from: " << ar << endl;
// first pass for explicitly delimited stuff
- for (MathArray::size_type i = 0; i < ar.size(); ++i) {
+ for (size_t i = 0; i < ar.size(); ++i) {
if (!ar[i]->asDelimInset())
continue;
MathArray const & arr = ar[i]->asDelimInset()->cell(0);
}
// second pass for AMS "pmatrix" etc
- for (MathArray::size_type i = 0; i < ar.size(); ++i)
+ for (size_t i = 0; i < ar.size(); ++i)
if (ar[i]->asAMSArrayInset())
ar[i] = MathAtom(new MathMatrixInset(*(ar[i]->asGridInset())));
- //lyxerr << "\nMatrices to: " << ar << "\n";
+ //lyxerr << "\nMatrices to: " << ar << endl;
}
// convert this inset somehow to a number
bool extractNumber(MathArray const & ar, int & i)
{
- istringstream is(charSequence(ar.begin(), ar.end()).c_str());
+ istringstream is(charSequence(ar.begin(), ar.end()));
is >> i;
return is;
}
bool extractNumber(MathArray const & ar, double & d)
{
- istringstream is(charSequence(ar.begin(), ar.end()).c_str());
+ istringstream is(charSequence(ar.begin(), ar.end()));
is >> d;
return is;
}
-bool testString(MathAtom const & at, const string & str)
+bool testString(MathAtom const & at, string const & str)
{
string s;
return extractString(at, s) && str == s;
{
// use indices rather than iterators for the loop because we are going
// to modify the array.
- for (MathArray::size_type i = 0; i < ar.size(); ++i) {
+ for (size_t i = 0; i < ar.size(); ++i) {
// check whether this is the begin of the sequence
if (!testOpen(ar[i]))
continue;
void splitScripts(MathArray & ar)
{
- //lyxerr << "\nScripts from: " << ar << "\n";
- for (MathArray::size_type i = 0; i < ar.size(); ++i) {
+ //lyxerr << "\nScripts from: " << ar << endl;
+ for (size_t i = 0; i < ar.size(); ++i) {
// is this script inset?
if (!ar[i]->asScriptInset())
continue;
// create extra script inset and move superscript over
MathScriptInset * p = ar[i].nucleus()->asScriptInset();
- MathScriptInset * q = new MathScriptInset(true);
- std::swap(q->up(), p->up());
+ auto_ptr<MathScriptInset> q(new MathScriptInset(true));
+ swap(q->up(), p->up());
p->removeScript(true);
// insert new inset behind
++i;
- ar.insert(i, MathAtom(q));
+ ar.insert(i, MathAtom(q.release()));
}
- //lyxerr << "\nScripts to: " << ar << "\n";
+ //lyxerr << "\nScripts to: " << ar << endl;
}
void extractExps(MathArray & ar)
{
- //lyxerr << "\nExps from: " << ar << "\n";
- for (MathArray::size_type i = 0; i + 1 < ar.size(); ++i) {
+ //lyxerr << "\nExps from: " << ar << endl;
+ for (size_t i = 0; i + 1 < ar.size(); ++i) {
// is this 'e'?
if (ar[i]->getChar() != 'e')
continue;
ar[i] = MathAtom(new MathExFuncInset("exp", sup->cell(1)));
ar.erase(i + 1);
}
- //lyxerr << "\nExps to: " << ar << "\n";
+ //lyxerr << "\nExps to: " << ar << endl;
}
//
void extractDets(MathArray & ar)
{
- //lyxerr << "\ndet from: " << ar << "\n";
+ //lyxerr << "\ndet from: " << ar << endl;
for (MathArray::iterator it = ar.begin(); it != ar.end(); ++it) {
MathDelimInset const * del = (*it)->asDelimInset();
if (!del)
continue;
*it = MathAtom(new MathExFuncInset("det", del->cell(0)));
}
- //lyxerr << "\ndet to: " << ar << "\n";
+ //lyxerr << "\ndet to: " << ar << endl;
}
void extractNumbers(MathArray & ar)
{
- //lyxerr << "\nNumbers from: " << ar << "\n";
- for (MathArray::size_type i = 0; i < ar.size(); ++i) {
+ //lyxerr << "\nNumbers from: " << ar << endl;
+ for (size_t i = 0; i < ar.size(); ++i) {
if (!ar[i]->asCharInset())
continue;
if (!isDigitOrSimilar(ar[i]->asCharInset()->getChar()))
ar[i] = MathAtom(new MathNumberInset(s));
ar.erase(i + 1, i + s.size());
}
- //lyxerr << "\nNumbers to: " << ar << "\n";
+ //lyxerr << "\nNumbers to: " << ar << endl;
}
// replace '('...')' sequences by a real MathDelimInset
void extractDelims(MathArray & ar)
{
- //lyxerr << "\nDelims from: " << ar << "\n";
+ //lyxerr << "\nDelims from: " << ar << endl;
replaceNested(ar, testOpenParan, testCloseParan, replaceDelims);
- //lyxerr << "\nDelims to: " << ar << "\n";
+ //lyxerr << "\nDelims to: " << ar << endl;
}
if (ar.size() < 2)
return;
- //lyxerr << "\nFunctions from: " << ar << "\n";
- for (MathArray::size_type i = 0; i + 1 < ar.size(); ++i) {
+ //lyxerr << "\nFunctions from: " << ar << endl;
+ for (size_t i = 0; i + 1 < ar.size(); ++i) {
MathArray::iterator it = ar.begin() + i;
MathArray::iterator jt = it + 1;
extractScript(exp, jt, ar.end());
// create a proper inset as replacement
- MathExFuncInset * p = new MathExFuncInset(name);
+ auto_ptr<MathExFuncInset> p(new MathExFuncInset(name));
// jt points to the "argument". Get hold of this.
MathArray::iterator st = extractArgument(p->cell(0), jt, ar.end());
// replace the function name by a real function inset
- *it = MathAtom(p);
+ *it = MathAtom(p.release());
// remove the source of the argument from the array
ar.erase(it + 1, st);
// re-insert exponent
ar.insert(i + 1, exp);
- //lyxerr << "\nFunctions to: " << ar << "\n";
+ //lyxerr << "\nFunctions to: " << ar << endl;
}
}
if (ar.size() < 3)
return;
- //lyxerr << "\nIntegrals from: " << ar << "\n";
- for (MathArray::size_type i = 0; i + 1 < ar.size(); ++i) {
+ //lyxerr << "\nIntegrals from: " << ar << endl;
+ for (size_t i = 0; i + 1 < ar.size(); ++i) {
MathArray::iterator it = ar.begin() + i;
// search 'd'
continue;
// core ist part from behind the scripts to the 'd'
- MathExIntInset * p = new MathExIntInset("int");
+ auto_ptr<MathExIntInset> p(new MathExIntInset("int"));
// handle scripts if available
if (!testIntSymbol(*it)) {
// remove used parts
ar.erase(it + 1, tt);
- *it = MathAtom(p);
+ *it = MathAtom(p.release());
}
- //lyxerr << "\nIntegrals to: " << ar << "\n";
+ //lyxerr << "\nIntegrals to: " << ar << endl;
}
if (ar.size() < 2)
return;
- //lyxerr << "\nSums from: " << ar << "\n";
- for (MathArray::size_type i = 0; i + 1 < ar.size(); ++i) {
+ //lyxerr << "\nSums from: " << ar << endl;
+ for (size_t i = 0; i + 1 < ar.size(); ++i) {
MathArray::iterator it = ar.begin() + i;
// is this a sum name?
continue;
// create a proper inset as replacement
- MathExIntInset * p = new MathExIntInset("sum");
+ auto_ptr<MathExIntInset> p(new MathExIntInset("sum"));
// collect lower bound and summation index
MathScriptInset const * sub = ar[i]->asScriptInset();
// cleanup
ar.erase(it + 1, tt);
- *it = MathAtom(p);
+ *it = MathAtom(p.release());
}
- //lyxerr << "\nSums to: " << ar << "\n";
+ //lyxerr << "\nSums to: " << ar << endl;
}
void extractDiff(MathArray & ar)
{
- //lyxerr << "\nDiffs from: " << ar << "\n";
- for (MathArray::size_type i = 0; i < ar.size(); ++i) {
+ //lyxerr << "\nDiffs from: " << ar << endl;
+ for (size_t i = 0; i < ar.size(); ++i) {
MathArray::iterator it = ar.begin() + i;
// is this a "differential fraction"?
MathFracInset const * f = (*it)->asFracInset();
if (!f) {
- lyxerr << "should not happen\n";
+ lyxerr << "should not happen" << endl;
continue;
}
// create a proper diff inset
- MathDiffInset * diff = new MathDiffInset;
+ auto_ptr<MathDiffInset> diff(new MathDiffInset);
// collect function, let jt point behind last used item
MathArray::iterator jt = it + 1;
// cleanup
ar.erase(it + 1, jt);
- *it = MathAtom(diff);
+ *it = MathAtom(diff.release());
}
- //lyxerr << "\nDiffs to: " << ar << "\n";
+ //lyxerr << "\nDiffs to: " << ar << endl;
}
if (ar.size() < 3)
return;
- //lyxerr << "\nLimits from: " << ar << "\n";
- for (MathArray::size_type i = 0; i + 2 < ar.size(); ++i) {
+ //lyxerr << "\nLimits from: " << ar << endl;
+ for (size_t i = 0; i + 2 < ar.size(); ++i) {
MathArray::iterator it = ar.begin() + i;
// is this a limit function?
// create a proper inset as replacement
*it = MathAtom(new MathLimInset(f, x, x0));
}
- //lyxerr << "\nLimits to: " << ar << "\n";
+ //lyxerr << "\nLimits to: " << ar << endl;
}
void extractStructure(MathArray & ar)
{
- //lyxerr << "\nStructure from: " << ar << "\n";
+ //lyxerr << "\nStructure from: " << ar << endl;
extractIntegrals(ar);
extractSums(ar);
splitScripts(ar);
extractExps(ar);
extractLims(ar);
extractStrings(ar);
- //lyxerr << "\nStructure to: " << ar << "\n";
+ //lyxerr << "\nStructure to: " << ar << endl;
}
ostringstream os;
MaximaStream ms(os);
ms << ar;
- string expr = STRCONV(os.str());
+ string expr = os.str();
string const header = "SIMPSUM:true;";
string out;
// 2x;
// ^
//
- lyxerr << "checking expr: '" << expr << "'\n";
+ lyxerr << "checking expr: '" << expr << "'" << endl;
string full = header + "tex(" + expr + ");";
out = captureOutput("maxima", full);
break;
// search line with "Incorrect syntax"
- istringstream is(out.c_str());
+ istringstream is(out);
string line;
while (is) {
getline(is, line);
getline(is, line);
getline(is, line);
string::size_type pos = line.find('^');
- lyxerr << "found caret at pos: '" << pos << "'\n";
+ lyxerr << "found caret at pos: '" << pos << "'" << endl;
if (pos == string::npos || pos < 4)
break; // caret position not found
pos -= 4; // skip the "tex(" part
expr.insert(pos, "*");
}
- std::vector<string> tmp = getVectorFromString(out, "$$");
+ vector<string> tmp = getVectorFromString(out, "$$");
if (tmp.size() < 2)
return MathArray();
out = subst(tmp[1],"\\>", "");
- lyxerr << "out: '" << out << "'\n";
+ lyxerr << "out: '" << out << "'" << endl;
// Ugly code that tries to make the result prettier
ostringstream os;
MapleStream ms(os);
ms << ar;
- string expr = STRCONV(os.str());
- lyxerr << "ar: '" << ar << "'\n";
- lyxerr << "ms: '" << os.str() << "'\n";
+ string expr = os.str();
+ lyxerr << "ar: '" << ar << "'\n"
+ << "ms: '" << os.str() << "'" << endl;
for (int i = 0; i < 100; ++i) { // at most 100 attempts
// try to fix missing '*' the hard way by using mint
// ^ syntax error -
// Probably missing an operator such as * p
//
- lyxerr << "checking expr: '" << expr << "'\n";
+ lyxerr << "checking expr: '" << expr << "'" << endl;
string out = captureOutput("mint -i 1 -S -s -q -q", expr + ';');
if (out.empty())
break; // expression syntax is ok
- istringstream is(out.c_str());
+ istringstream is(out);
string line;
getline(is, line);
if (line.find("on line") != 0)
ostringstream os;
OctaveStream vs(os);
vs << ar;
- string expr = STRCONV(os.str());
+ string expr = os.str();
string out;
- lyxerr << "pipe: ar: '" << ar << "'\n";
- lyxerr << "pipe: expr: '" << expr << "'\n";
+ lyxerr << "pipe: ar: '" << ar << "'\n"
+ << "pipe: expr: '" << expr << "'" << endl;
for (int i = 0; i < 100; ++i) { // at most 100 attempts
//
// >>> ([[1 2 3 ];[2 3 1 ];[3 1 2 ]])([[1 2 3 ];[2 3 1 ];[3 1 2 ]])
// ^
//
- lyxerr << "checking expr: '" << expr << "'\n";
+ lyxerr << "checking expr: '" << expr << "'" << endl;
out = captureOutput("octave -q 2>&1", expr);
- lyxerr << "checking out: '" << out << "'\n";
+ lyxerr << "checking out: '" << out << "'" << endl;
// leave loop if expression syntax is probably ok
if (out.find("parse error:") == string::npos)
break;
// search line with single caret
- istringstream is(out.c_str());
+ istringstream is(out);
string line;
while (is) {
getline(is, line);
- lyxerr << "skipping line: '" << line << "'\n";
+ lyxerr << "skipping line: '" << line << "'" << endl;
if (line.find(">>> ") != string::npos)
break;
}
// found line with error, next line is the one with caret
getline(is, line);
string::size_type pos = line.find('^');
- lyxerr << "caret line: '" << line << "'\n";
- lyxerr << "found caret at pos: '" << pos << "'\n";
+ lyxerr << "caret line: '" << line << "'" << endl;
+ lyxerr << "found caret at pos: '" << pos << "'" << endl;
if (pos == string::npos || pos < 4)
break; // caret position not found
pos -= 4; // skip the ">>> " part
os << '[' << extra << ' ';
ns << ar;
os << ']';
- string data = STRCONV(os.str());
+ string data = os.str();
// search external script
string file = LibFileSearch("mathed", "extern_" + lang);