X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2Fmath_extern.C;h=f595b1b1686d040165163cac6a3640b5f3fa61db;hb=254272868f1d891b9d0a778f871afb23cce84081;hp=e3064c107ee41ff4ef0deab3772d01e9d2f95117;hpb=fb16a10b8e271032f8d674b4250ae969556ee349;p=lyx.git

diff --git a/src/mathed/math_extern.C b/src/mathed/math_extern.C
index e3064c107e..f595b1b168 100644
--- a/src/mathed/math_extern.C
+++ b/src/mathed/math_extern.C
@@ -1,33 +1,121 @@
-
 // This file contains most of the magic that extracts "context
 // information" from the unstructered layout-oriented stuff in an
 // MathArray.
 
-#include <algorithm>
+#include <config.h>
 
+#include "math_amsarrayinset.h"
+#include "math_arrayinset.h"
 #include "math_charinset.h"
 #include "math_deliminset.h"
+#include "math_diffinset.h"
 #include "math_exfuncinset.h"
 #include "math_exintinset.h"
-#include "math_funcinset.h"
+#include "math_fracinset.h"
 #include "math_matrixinset.h"
 #include "math_mathmlstream.h"
+#include "math_numberinset.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 <algorithm>
 
+using std::ostream;
+using std::istringstream;
+using std::find_if;
+using std::endl;
 
-std::ostream & operator<<(std::ostream & os, MathArray const & ar)
+
+ostream & operator<<(ostream & os, MathArray const & ar)
 {
-	NormalStream ns(os);	
+	NormalStream ns(os);
 	ns << ar;
 	return os;
 }
 
 
+// define a function for tests
+typedef bool TestItemFunc(MathInset *);
+
+// define a function for replacing subexpressions
+typedef MathInset * ReplaceArgumentFunc(const MathArray & ar);
+
+
+
+// try to extract a super/subscript
+// modify iterator position to point behind the thing
+bool extractScript(MathArray & ar,
+	MathArray::iterator & pos, MathArray::iterator last)
+{
+	// nothing to get here
+	if (pos == last)
+		return false;
+
+	// is this a scriptinset?
+	if (!(*pos)->asScriptInset())
+		return false;
+
+	// it is a scriptinset, use it.
+	ar.push_back(*pos);
+	++pos;
+	return true;
+}
+
+
+// try to extract an "argument" to some function.
+// returns position behind the argument
+MathArray::iterator extractArgument(MathArray & ar,
+	MathArray::iterator pos, MathArray::iterator last, string const & = "")
+{
+	// nothing to get here
+	if (pos == last)
+		return pos;
+
+	// something deliminited _is_ an argument
+	if ((*pos)->asDelimInset()) {
+		ar.push_back(*pos);
+		return pos + 1;
+	}
+
+	// always take the first thing, no matter what it is
+	ar.push_back(*pos);
+
+	// go ahead if possible
+	++pos;
+	if (pos == last)
+		return pos;
+
+	// if the next item is a subscript, it most certainly belongs to the
+	// thing we have
+	extractScript(ar, pos, last);
+	if (pos == last)
+		return pos;
+
+	// but it might be more than that.
+	// FIXME: not implemented
+	//for (MathArray::iterator it = pos + 1; it != last; ++it) {
+	//	// always take the first thing, no matter
+	//	if (it == pos) {
+	//		ar.push_back(*it);
+	//		continue;
+	//	}
+	//}
+	return pos;
+}
+
+
 MathScriptInset const * asScript(MathArray::const_iterator it)
 {
+	if (!it->nucleus())
+		return 0;
 	if (it->nucleus()->asScriptInset())
 		return 0;
 	++it;
@@ -40,39 +128,26 @@ MathScriptInset const * asScript(MathArray::const_iterator it)
 
 // returns sequence of char with same code starting at it up to end
 // it might be less, though...
-string charSequence(MathArray::const_iterator it, MathArray::const_iterator end)
+string charSequence
+	(MathArray::const_iterator it, MathArray::const_iterator end)
 {
 	string s;
-	MathCharInset const * p = it->nucleus()->asCharInset();
-	if (p) {
-		for (MathTextCodes c = p->code(); it != end; ++it) {
-			p = it->nucleus()->asCharInset();
-			if (!p || p->code() != c)
-				break;
-			s += p->getChar();
-		}
-	}
+	for (; it != end && (*it)->asCharInset(); ++it)
+		s += (*it)->getChar();
 	return s;
 }
 
 
-void extractStrings(MathArray & dat)
+void extractStrings(MathArray & ar)
 {
 	//lyxerr << "\nStrings from: " << ar << "\n";
-	MathArray ar;
-	MathArray::const_iterator it = dat.begin();
-	while (it != dat.end()) {
-		if (it->nucleus() && it->nucleus()->asCharInset()) {
-			string s = charSequence(it, dat.end());
-			MathTextCodes c = it->nucleus()->asCharInset()->code();
-			ar.push_back(MathAtom(new MathStringInset(s, c)));
-			it += s.size();
-		} else {
-			ar.push_back(*it);
-			++it;
-		}
+	for (MathArray::size_type i = 0; i < ar.size(); ++i) {
+		if (!ar[i]->asCharInset())
+			continue;
+		string s = charSequence(ar.begin() + i, ar.end());
+		ar[i].reset(new MathStringInset(s));
+		ar.erase(i + 1, i + s.size());
 	}
-	ar.swap(dat);
 	//lyxerr << "\nStrings to: " << ar << "\n";
 }
 
@@ -85,35 +160,68 @@ MathInset * singleItem(MathArray & ar)
 
 void extractMatrices(MathArray & ar)
 {
-	lyxerr << "\nMatrices from: " << ar << "\n";
+	//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)
 			continue;
 		MathInset * arr = singleItem(del->cell(0));
-		if (!arr || !arr->asArrayInset())
+		if (!arr || !arr->asGridInset())
+			continue;
+		*it = MathAtom(new MathMatrixInset(*(arr->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(*(arr->asArrayInset())));
-		lyxerr << "\nMatrices to: " << ar << "\n";
+		*it = MathAtom(new MathMatrixInset(*ams));
 	}
-} 
+	//lyxerr << "\nMatrices to: " << ar << "\n";
+}
+
 
 // convert this inset somehow to a string
-string extractString(MathInset * p)
+bool extractString(MathInset * p, string & str)
 {
-	if (p && p->getChar())
-		return string(1, p->getChar());
-	if (p && p->asStringInset())
-		return p->asStringInset()->str();
-	return string();
+	if (!p)
+		return false;
+	if (p->getChar()) {
+		str = string(1, p->getChar());
+		return true;
+	}
+	if (p->asStringInset()) {
+		str = p->asStringInset()->str();
+		return true;
+	}
+	return false;
 }
 
 
-// define a function for tests
-typedef bool TestItemFunc(MathInset *);
+// convert this inset somehow to a number
+bool extractNumber(MathArray const & ar, int & i)
+{
+	istringstream is(charSequence(ar.begin(), ar.end()).c_str());
+	is >> i;
+	return is;
+}
 
-// define a function for replacing subexpressions
-typedef MathInset * ReplaceArgumentFunc(const MathArray & ar);
+
+bool extractNumber(MathArray const & ar, double & d)
+{
+	istringstream is(charSequence(ar.begin(), ar.end()).c_str());
+	is >> d;
+	return is;
+}
+
+
+bool testString(MathInset * p, const string & str)
+{
+	string s;
+	return extractString(p, s) && str == s;
+}
 
 
 // search end of nested sequence
@@ -164,38 +272,162 @@ void replaceNested(
 		ar.erase(it + 1, jt + 1);
 		(*it).reset(p);
 	}
-} 
+}
+
+
+
+//
+// split scripts into seperate super- and subscript insets. sub goes in
+// front of super...
+//
+
+void splitScripts(MathArray & ar)
+{
+	//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)
+			continue;
+
+		// no problem if we don't have both...
+		if (!p->hasUp() || !p->hasDown())
+			continue;
+
+		// create extra script inset and move superscript over
+		MathScriptInset * q = new MathScriptInset;
+		q->ensure(true);
+		q->up().data_.swap(p->up().data_);
+		p->removeScript(true);
+
+		// insert new inset behind
+		++i;
+		ar.insert(i, MathAtom(q));
+	}
+	//lyxerr << "\nScripts to: " << ar << "\n";
+}
+
+
+//
+// extract exp(...)
+//
+
+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')
+			continue;
+
+		// we need an exponent but no subscript
+		MathScriptInset * sup = (*(it + 1))->asScriptInset();
+		if (!sup || sup->hasDown())
+			continue;
+
+		// create a proper exp-inset as replacement 
+		*it = new MathExFuncInset("exp", sup->cell(1));
+		ar.erase(it + 1);
+	}
+	//lyxerr << "\nExps to: " << ar << "\n";
+}
+
+
+//
+// extract det(...)  from |matrix|
+//
+void extractDets(MathArray & ar)
+{
+	//lyxerr << "\ndet from: " << ar << "\n";
+	for (MathArray::iterator it = ar.begin(); it != ar.end(); ++it) {
+		MathDelimInset * del = (*it)->asDelimInset();
+		if (!del)
+			continue;
+		if (!del->isAbs())
+			continue;
+		*it = new MathExFuncInset("det", del->cell(0));
+	}
+	//lyxerr << "\ndet to: " << ar << "\n";
+}
+
+
+//
+// search numbers
+//
+
+bool isDigitOrSimilar(char c)
+{
+	return ('0' <= c && c <= '9') || c == '.';
+}
+
+
+// returns sequence of digits
+string digitSequence
+	(MathArray::const_iterator it, MathArray::const_iterator end)
+{
+	string s;
+	for (; it != end && (*it)->asCharInset(); ++it) {
+		if (!isDigitOrSimilar((*it)->getChar()))
+			break;
+		s += (*it)->getChar();
+	}
+	return s;
+}
+
+
+void extractNumbers(MathArray & ar)
+{
+	//lyxerr << "\nNumbers from: " << ar << "\n";
+	for (MathArray::size_type i = 0; i < ar.size(); ++i) {
+		if (!ar[i]->asCharInset())
+			continue;
+		if (!isDigitOrSimilar(ar[i]->asCharInset()->getChar()))
+			continue;
+
+		string s = digitSequence(ar.begin() + i, ar.end());
+
+		ar[i].reset(new MathNumberInset(s));
+		ar.erase(i + 1, i + s.size());
+	}
+	//lyxerr << "\nNumbers to: " << ar << "\n";
+}
+
 
 
 //
 // search deliminiters
 //
 
-bool openParanTest(MathInset * p)
+bool testOpenParan(MathInset * p)
 {
-	return extractString(p) == "(";
+	return testString(p, "(");
 }
 
 
-bool closeParanTest(MathInset * p)
+bool testCloseParan(MathInset * p)
 {
-	return extractString(p) == ")";
+	return testString(p, ")");
 }
 
 
-MathInset * delimReplacement(const MathArray & ar)
+MathInset * replaceDelims(const MathArray & ar)
 {
-	MathDelimInset * del = new MathDelimInset("(", ")");
-	del->cell(0) = ar;
-	return del;
+	return new MathDelimInset("(", ")", ar);
 }
 
 
 // replace '('...')' sequences by a real MathDelimInset
-void extractDelims(MathArray & ar) {
-	lyxerr << "\nDelims from: " << ar << "\n";
-	replaceNested(ar, openParanTest, closeParanTest, delimReplacement);
-	lyxerr << "\nDelims to: " << ar << "\n";
+void extractDelims(MathArray & ar)
+{
+	//lyxerr << "\nDelims from: " << ar << "\n";
+	replaceNested(ar, testOpenParan, testCloseParan, replaceDelims);
+	//lyxerr << "\nDelims to: " << ar << "\n";
 }
 
 
@@ -213,60 +445,75 @@ void extractFunctions(MathArray & ar)
 	if (ar.size() <= 1)
 		return;
 
-	lyxerr << "\nFunctions from: " << ar << "\n";
-	for (MathArray::size_type i = 0; i < ar.size() - 1; ++i) {
+	//lyxerr << "\nFunctions from: " << ar << "\n";
+	for (MathArray::size_type i = 0; i + 1 < ar.size(); ++i) {
 		MathArray::iterator it = ar.begin() + i;
-
-		// is this a function name?
-		MathFuncInset * func = (*it)->asFuncInset();
-		if (!func)
-			continue;
-
-		// do we have an exponent?
-		// simply skippping the postion does the right thing:
-		// 'sin' '^2' 'x' -> 'sin(x)' '^2'
 		MathArray::iterator jt = it + 1;
-		if (MathScriptInset * script = (*jt)->asScriptInset()) {
-			// allow superscripts only
-			if (script->hasDown())
+
+		string name;
+		// is it a function?
+		if ((*it)->asUnknownInset()) {
+			// it certainly is if it is well known...
+			name = (*it)->asUnknownInset()->name();
+		} else {
+			// is this a user defined function?
+			// it it probably not, if it doesn't have a name.
+			if (!extractString((*it).nucleus(), name))
 				continue;
-			++jt;
+			// it is not if it has no argument
 			if (jt == ar.end())
 				continue;
+			// guess so, if this is followed by
+			// a DelimInset with a single item in the cell
+			MathDelimInset * del = (*jt)->asDelimInset();
+			if (!del || del->cell(0).size() != 1)
+				continue;
+			// fall trough into main branch
 		}
 
-		// jt points now to the "argument". Since we had run "extractDelims"
-		// before, this could be a single argument only. Get hold of this.
-		MathArray arg;
-		MathDelimInset * del = (*jt)->asDelimInset();
-		if (del && del->isParanthesis()) 
-			arg = del->cell(0);
-		else
-			arg.push_back(*jt);
+		// do we have an exponent like in
+		// 'sin' '^2' 'x' -> 'sin(x)' '^2'
+		MathArray exp;
+		extractScript(exp, jt, ar.end());
+
+		// create a proper inset as replacement
+		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).reset(new MathExFuncInset(func->name(), arg));
-		
+		(*it).reset(p);
+
 		// remove the source of the argument from the array
-		ar.erase(jt);
-		lyxerr << "\nFunctions to: " << ar << "\n";
+		ar.erase(it + 1, st);
+
+		// re-insert exponent
+		ar.insert(i + 1, exp);
+		//lyxerr << "\nFunctions to: " << ar << "\n";
 	}
-} 
+}
 
 
 //
 // search integrals
 //
 
-bool intSymbolTest(MathInset * p)
+bool testSymbol(MathInset * p, string const & name)
+{
+	return p->asSymbolInset() && p->asSymbolInset()->name() == name;
+}
+
+
+bool testIntSymbol(MathInset * p)
 {
-	return p->asSymbolInset() && p->asSymbolInset()->name() == "int";
+	return testSymbol(p, "int");
 }
 
 
-bool differentialTest(MathInset * p)
+bool testIntDiff(MathInset * p)
 {
-	return extractString(p) == "d";
+	return testString(p, "d");
 }
 
 
@@ -278,17 +525,17 @@ void extractIntegrals(MathArray & ar)
 	if (ar.size() <= 2)
 		return;
 
-	lyxerr << "\nIntegrals from: " << ar << "\n";
-	for (MathArray::size_type i = 0; i < ar.size() - 1; ++i) {
+	//lyxerr << "\nIntegrals from: " << ar << "\n";
+	for (MathArray::size_type i = 0; i + 1 < ar.size(); ++i) {
 		MathArray::iterator it = ar.begin() + i;
 
 		// is this a integral name?
-		if (!intSymbolTest(it->nucleus()))
+		if (!testIntSymbol(it->nucleus()))
 			continue;
 
 		// search 'd'
 		MathArray::iterator jt =
-			endNestSearch(it, ar.end(), intSymbolTest, differentialTest);
+			endNestSearch(it, ar.end(), testIntSymbol, testIntDiff);
 
 		// something sensible found?
 		if (jt == ar.end())
@@ -297,27 +544,34 @@ void extractIntegrals(MathArray & ar)
 		// create a proper inset as replacement
 		MathExIntInset * p = new MathExIntInset("int");
 
-		// collect scripts
+		// collect subscript if any
 		MathArray::iterator st = it + 1;
-		if ((*st)->asScriptInset()) {
-			p->scripts(*st);
-			p->core(MathArray(st + 1, jt));
-		} else {
-			p->core(MathArray(st, jt));
-		}
+		if (st != ar.end())
+			if (MathScriptInset * sub = (*st)->asScriptInset())
+				if (sub->hasDown()) {
+					p->cell(2) = sub->down().data_;
+					++st;
+				}
 
-		// use the atom behind the 'd' as differential
-		MathArray ind;
-		if (jt + 1 != ar.end()) {
-			ind.push_back(*(jt + 1));
-			++jt;
-		}
-		ar.erase(it + 1, jt + 1);
+		// collect superscript if any
+		if (st != ar.end())
+			if (MathScriptInset * sup = (*st)->asScriptInset())
+				if (sup->hasUp()) {
+					p->cell(3) = sup->up().data_;
+					++st;
+				}
+
+		// core ist part from behind the scripts to the 'd'
+		p->cell(0) = MathArray(st, jt);
+
+		// use the "thing" behind the 'd' as differential
+		MathArray::iterator tt = extractArgument(p->cell(1), jt + 1, ar.end());
 
-		p->index(ind);
+		// remove used parts
+		ar.erase(it + 1, tt);
 		(*it).reset(p);
 	}
-	lyxerr << "\nIntegrals to: " << ar << "\n";
+	//lyxerr << "\nIntegrals to: " << ar << "\n";
 }
 
 
@@ -325,21 +579,15 @@ void extractIntegrals(MathArray & ar)
 // search sums
 //
 
-bool sumSymbolTest(MathInset * p)
+bool testSumSymbol(MathInset * p)
 {
-	return p->asSymbolInset() && p->asSymbolInset()->name() == "sum";
+	return testSymbol(p, "sum");
 }
 
 
-bool equalSign(MathInset * p)
+bool testEqualSign(MathAtom const & at)
 {
-	return extractString(p) == "=";
-}
-
-
-bool equalSign1(MathAtom const & at)
-{
-	return equalSign(at.nucleus());
+	return testString(at.nucleus(), "=");
 }
 
 
@@ -352,64 +600,184 @@ void extractSums(MathArray & ar)
 	if (ar.size() <= 1)
 		return;
 
-	lyxerr << "\nSums from: " << ar << "\n";
-	for (MathArray::size_type i = 0; i < ar.size() - 1; ++i) {
+	//lyxerr << "\nSums from: " << ar << "\n";
+	for (MathArray::size_type i = 0; i + 1< ar.size(); ++i) {
 		MathArray::iterator it = ar.begin() + i;
 
 		// is this a sum name?
-		if (!sumSymbolTest(it->nucleus()))
+		if (!testSumSymbol(it->nucleus()))
 			continue;
 
 		// create a proper inset as replacement
 		MathExIntInset * p = new MathExIntInset("sum");
 
-		// collect scripts
+		// collect lower bound and summation index
 		MathArray::iterator st = it + 1;
-		if (st != ar.end() && (*st)->asScriptInset()) {
-			p->scripts(*st);
-			++st;
-
-			// try to figure out the summation index from the subscript
-			MathScriptInset * script = p->scripts()->asScriptInset();
-			if (script->hasDown()) {
-				MathArray & ar = script->down().data_;
-				MathArray::iterator it =
-					std::find_if(ar.begin(), ar.end(), &equalSign1);
-				if (it != ar.end()) {
-					// we found a '=', use everything in front of that as index,
-					// and everything behind as start value
-					p->index(MathArray(ar.begin(), it));
-					ar.erase(ar.begin(), it + 1);
-				} else {
-					// use everything as summation index
-					p->index(ar);
-					p->scripts().reset(0);
+		if (st != ar.end())
+			if (MathScriptInset * sub = (*st)->asScriptInset())
+				if (sub->hasDown()) {
+					// try to figure out the summation index from the subscript
+					MathArray & ar = sub->down().data_;
+					MathArray::iterator it =
+						find_if(ar.begin(), ar.end(), &testEqualSign);
+					if (it != ar.end()) {
+						// we found a '=', use everything in front of that as index,
+						// and everything behind as lower index
+						p->cell(1) = MathArray(ar.begin(), it);
+						p->cell(2) = MathArray(it + 1, ar.end());
+					} else {
+						// use everything as summation index, don't use scripts.
+						p->cell(1) = ar;
+					}
+					++st;
 				}
-			}
+
+		// collect upper bound
+		if (st != ar.end())
+			if (MathScriptInset * sup = (*st)->asScriptInset())
+				if (sup->hasUp()) {
+					p->cell(3) = sup->up().data_;
+					++st;
+				}
+
+		// use some  behind the script as core
+		MathArray::iterator tt = extractArgument(p->cell(0), st, ar.end());
+
+		// cleanup
+		ar.erase(it + 1, tt);
+		(*it).reset(p);
+	}
+	//lyxerr << "\nSums to: " << ar << "\n";
+}
+
+
+//
+// search differential stuff
+//
+
+// tests for 'd' or '\partial'
+bool testDiffItem(MathAtom const & at)
+{
+	return testString(at.nucleus(), "d");
+}
+
+
+bool testDiffArray(MathArray const & ar)
+{
+	return ar.size() && testDiffItem(ar.front());
+}
+
+
+bool testDiffFrac(MathInset * p)
+{
+	MathFracInset * f = p->asFracInset();
+	return f && testDiffArray(f->cell(0)) && testDiffArray(f->cell(1));
+}
+
+
+// is this something like ^number?
+bool extractDiffExponent(MathArray::iterator it, int & i)
+{
+	if (!(*it)->asScriptInset())
+		return false;
+
+	string s;
+	if (!extractString((*it).nucleus(), s))
+		return false;
+	istringstream is(s.c_str());
+	is >> i;
+	return is;
+}
+
+
+void extractDiff(MathArray & ar)
+{
+	//lyxerr << "\nDiffs from: " << ar << "\n";
+	for (MathArray::size_type i = 0; i < ar.size(); ++i) {
+		MathArray::iterator it = ar.begin() + i;
+
+		// is this a "differential fraction"?
+		if (!testDiffFrac(it->nucleus()))
+			continue;
+
+		MathFracInset * f = (*it)->asFracInset();
+		if (!f) {
+			lyxerr << "should not happen\n";
+			continue;
 		}
 
-		// use the atom behind the script as core
-		MathArray ind;
-		if (st != ar.end()) {
-			MathArray core;
-			core.push_back(*st);
-			p->core(core);
-			++st;
+		// create a proper diff inset
+		MathDiffInset * diff = new MathDiffInset;
+
+		// collect function, let jt point behind last used item
+		MathArray::iterator jt = it + 1;
+		//int n = 1;
+		MathArray & 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
+			//n = 1;
+			if (numer.size() > 2)
+				diff->cell(0) = MathArray(numer.begin() + 2, numer.end());
+			else
+				jt = extractArgument(diff->cell(0), jt, ar.end());
+		} else {
+			// simply d f(x) / d... or  d/d...
+			if (numer.size() > 1)
+				diff->cell(0) = MathArray(numer.begin() + 1, numer.end());
+			else
+				jt = extractArgument(diff->cell(0), jt, ar.end());
 		}
-		ar.erase(it + 1, st);
-		(*it).reset(p);
+
+		// collect denominator parts
+		MathArray & denom = f->cell(1);
+		for (MathArray::iterator dt = denom.begin(); dt != denom.end();) {
+			// find the next 'd'
+			MathArray::iterator et = find_if(dt + 1, denom.end(), &testDiffItem);
+
+			// point before this
+			MathArray::iterator st = et - 1;
+			MathScriptInset * script = (*st)->asScriptInset();
+			if (script && script->hasUp()) {
+				// things like   d.../dx^n
+				int mult = 1;
+				if (extractNumber(script->up().data_, mult)) {
+					//lyxerr << "mult: " << mult << endl;
+					for (int i = 0; i < mult; ++i)
+						diff->addDer(MathArray(dt + 1, st));
+				}
+			} else {
+				// just  d.../dx
+				diff->addDer(MathArray(dt + 1, et));
+			}
+			dt = et;
+		}
+
+		// cleanup
+		ar.erase(it + 1, jt);
+		(*it).reset(diff);
 	}
-	lyxerr << "\nSums to: " << ar << "\n";
+	//lyxerr << "\nDiffs to: " << ar << "\n";
 }
 
 
+
+//
+// combine searches
+//
+
 void extractStructure(MathArray & ar)
 {
+	splitScripts(ar);
+	extractNumbers(ar);
 	extractMatrices(ar);
 	extractDelims(ar);
 	extractFunctions(ar);
+	extractDets(ar);
 	extractIntegrals(ar);
 	extractSums(ar);
+	extractDiff(ar);
+	extractExps(ar);
 	extractStrings(ar);
 }
 
@@ -419,13 +787,14 @@ void write(MathArray const & dat, WriteStream & wi)
 	MathArray ar = dat;
 	extractStrings(ar);
 	for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it) {
+		wi.firstitem() = (it == ar.begin());
 		MathInset const * p = it->nucleus();
 		if (it + 1 != ar.end()) {
 			if (MathScriptInset const * q = asScript(it)) {
-				q->write(p, wi);
+				q->write2(p, wi);
 				++it;
 				continue;
-			} 
+			}
 		}
 		p->write(wi);
 	}
@@ -447,8 +816,8 @@ void octavize(MathArray const & dat, OctaveStream & os)
 		MathInset const * p = it->nucleus();
 		if (it + 1 != ar.end()) {
 			if (MathScriptInset const * q = asScript(it)) {
-				q->octavize(p, os);
-				++it;	
+				q->octavize2(p, os);
+				++it;
 				continue;
 			}
 		}
@@ -465,8 +834,8 @@ void maplize(MathArray const & dat, MapleStream & os)
 		MathInset const * p = it->nucleus();
 		if (it + 1 != ar.end()) {
 			if (MathScriptInset const * q = asScript(it)) {
-				q->maplize(p, os);
-				++it;	
+				q->maplize2(p, os);
+				++it;
 				continue;
 			}
 		}
@@ -489,8 +858,8 @@ void mathmlize(MathArray const & dat, MathMLStream & os)
 			MathInset const * p = it->nucleus();
 			if (it + 1 != ar.end()) {
 				if (MathScriptInset const * q = asScript(it)) {
-					q->mathmlize(p, os);
-					++it;	
+					q->mathmlize2(p, os);
+					++it;
 					continue;
 				}
 			}
@@ -500,3 +869,200 @@ void mathmlize(MathArray const & dat, MathMLStream & os)
 	}
 }
 
+
+
+
+namespace {
+
+	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;
+	}
+
+
+	MathArray pipeThroughMaple(string const & extra, MathArray const & ar)
+	{
+		string header = "readlib(latex):\n";
+
+		// remove the \\it for variable names
+		//"#`latex/csname_font` := `\\it `:"
+		header +=
+			"`latex/csname_font` := ``:\n";
+
+		// export matrices in (...) instead of [...]
+		header +=
+			"`latex/latex/matrix` := "
+				"subs(`[`=`(`, `]`=`)`,"
+					"eval(`latex/latex/matrix`)):\n";
+
+		// replace \\cdots with proper '*'
+		header +=
+			"`latex/latex/*` := "
+				"subs(`\\,`=`\\cdot `,"
+					"eval(`latex/latex/*`)):\n";
+
+		// remove spurious \\noalign{\\medskip} in matrix output
+		header +=
+			"`latex/latex/matrix`:= "
+				"subs(`\\\\\\\\\\\\noalign{\\\\medskip}` = `\\\\\\\\`,"
+					"eval(`latex/latex/matrix`)):\n";
+
+		//"#`latex/latex/symbol` "
+		//	" := subs((\\'_\\' = \\'`\\_`\\',eval(`latex/latex/symbol`)): ";
+
+		string trailer = "quit;";
+		ostringstream os;
+		MapleStream ms(os);
+		ms << ar;
+		string expr = os.str().c_str();
+		lyxerr << "ar: '" << ar << "'\n";
+		lyxerr << "ms: '" << os.str() << "'\n";
+
+		for (int i = 0; i < 100; ++i) { // at most 100 attempts
+			// try to fix missing '*' the hard way by using mint
+			//
+			// ... > echo "1A;" | mint -i 1 -S -s -q
+			// on line     1: 1A;
+			//                 ^ syntax error -
+			//                   Probably missing an operator such as * p
+			//
+			lyxerr << "checking expr: '" << expr << "'\n";
+			string out = captureOutput("mint -i 1 -S -s -q -q", expr + ";");
+			if (out.empty())
+				break; // expression syntax is ok
+			istringstream is(out.c_str());
+			string line;
+			getline(is, line);
+			if (line.find("on line") != 0)
+				break; // error message not identified
+			getline(is, line);
+			string::size_type pos = line.find('^');
+			if (pos == string::npos || pos < 15)
+				break; // caret position not found
+			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,  "*");
+		}
+
+		string full = "latex(" +  extra + '(' + expr + "));";
+		string out = captureOutput("maple -q", header + full + trailer);
+
+		// change \_ into _
+
+		//
+		MathArray res;
+		mathed_parse_cell(res, out);
+		return res;
+	}
+
+
+	MathArray pipeThroughOctave(string const &, MathArray const & ar)
+	{
+		ostringstream os;
+		OctaveStream vs(os);
+		vs << ar;
+		string expr = os.str().c_str();
+		string out;
+
+		lyxerr << "pipe: ar: '" << ar << "'\n";
+		lyxerr << "pipe: expr: '" << expr << "'\n";
+
+		for (int i = 0; i < 100; ++i) { // at most 100 attempts
+			//
+			// try to fix missing '*' the hard way
+			// parse error:
+			// >>> ([[1 2 3 ];[2 3 1 ];[3 1 2 ]])([[1 2 3 ];[2 3 1 ];[3 1 2 ]])
+			//                                   ^
+			//
+			lyxerr << "checking expr: '" << expr << "'\n";
+			out = captureOutput("octave -q 2>&1", expr);
+			lyxerr << "checking out: '" << out << "'\n";
+
+			// 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());
+			string line;
+			while (is) {
+				getline(is, line);
+				lyxerr << "skipping line: '" << line << "'\n";
+				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";
+			if (pos == string::npos || pos < 4)
+				break; // caret position not found
+			pos -= 4; // skip the ">>> " part
+			if (expr[pos] == '*')
+				break; // two '*' in a row are definitely bad
+			expr.insert(pos,  "*");
+		}
+
+		if (out.size() < 6)
+			return MathArray();
+
+		// remove 'ans = '
+		out = out.substr(6);
+
+		// parse output as matrix or single number
+		MathAtom at(new MathArrayInset("array", out));
+		MathArrayInset const * mat = at.nucleus()->asArrayInset();
+		MathArray res;
+		if (mat->ncols() == 1 && mat->nrows() == 1)
+			res.push_back(mat->cell(0));
+		else {
+			res.push_back(MathAtom(new MathDelimInset("(", ")")));
+			res.back()->cell(0).push_back(at);
+		}
+		return res;
+	}
+
+}
+
+
+MathArray pipeThroughExtern(string const & lang, string const & extra,
+	MathArray const & ar)
+{
+	if (lang == "octave")
+		return pipeThroughOctave(extra, ar);
+
+	if (lang == "maple")
+		return pipeThroughMaple(extra, ar);
+
+	// create normalized expression
+	ostringstream os;
+	NormalStream ns(os);
+	os << "[" << extra << ' ';
+	ns << ar;
+	os << "]";
+	string data = os.str().c_str();
+
+	// search external script
+	string file = LibFileSearch("mathed", "extern_" + lang);
+	if (file.empty()) {
+		lyxerr << "converter to '" << lang << "' not found\n";
+		return MathArray();
+	}
+
+	// run external sript
+	string out = captureOutput(file, data);
+	MathArray res;
+	mathed_parse_cell(res, out);
+	return res;
+}