mirror of
https://git.lyx.org/repos/lyx.git
synced 2024-09-22 07:57:22 +00:00
310 lines
6.7 KiB
C++
310 lines
6.7 KiB
C++
|
|
||
|
// This file contains most of the magic that extracts "context
|
||
|
// information" from the unstructered layout-oriented stuff in an
|
||
|
// MathArray.
|
||
|
|
||
|
|
||
|
#include "math_charinset.h"
|
||
|
#include "math_deliminset.h"
|
||
|
#include "math_exfuncinset.h"
|
||
|
#include "math_funcinset.h"
|
||
|
#include "math_matrixinset.h"
|
||
|
#include "math_mathmlstream.h"
|
||
|
#include "math_scriptinset.h"
|
||
|
#include "math_stringinset.h"
|
||
|
#include "debug.h"
|
||
|
|
||
|
|
||
|
std::ostream & operator<<(ostream & os, MathArray const & ar)
|
||
|
{
|
||
|
NormalStream ws(os);
|
||
|
ws << ar;
|
||
|
return os;
|
||
|
}
|
||
|
|
||
|
|
||
|
MathScriptInset const * asScript(MathArray::const_iterator it)
|
||
|
{
|
||
|
if (it->nucleus()->asScriptInset())
|
||
|
return 0;
|
||
|
++it;
|
||
|
if (!it->nucleus())
|
||
|
return 0;
|
||
|
return it->nucleus()->asScriptInset();
|
||
|
}
|
||
|
|
||
|
|
||
|
|
||
|
// 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 s;
|
||
|
MathCharInset const * p = it->nucleus()->asCharInset();
|
||
|
if (p) {
|
||
|
for (MathTextCodes c = p->code(); it != end; ++it) {
|
||
|
if (!it->nucleus())
|
||
|
break;
|
||
|
p = it->nucleus()->asCharInset();
|
||
|
if (!p || p->code() != c)
|
||
|
break;
|
||
|
s += p->getChar();
|
||
|
}
|
||
|
}
|
||
|
return s;
|
||
|
}
|
||
|
|
||
|
|
||
|
void glueChars(MathArray & dat)
|
||
|
{
|
||
|
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;
|
||
|
}
|
||
|
}
|
||
|
ar.swap(dat);
|
||
|
}
|
||
|
|
||
|
|
||
|
bool needAsterisk(MathAtom const &, MathAtom const &)
|
||
|
{
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
|
||
|
void guessAsterisks(MathArray & dat)
|
||
|
{
|
||
|
if (dat.size() <= 1)
|
||
|
return;
|
||
|
MathArray ar;
|
||
|
ar.push_back(*dat.begin());
|
||
|
MathArray::const_iterator it = dat.begin();
|
||
|
MathArray::const_iterator jt = it + 1;
|
||
|
for (; jt != dat.end(); ++it, ++jt) {
|
||
|
if (needAsterisk(*it, *jt))
|
||
|
ar.push_back(MathAtom(new MathCharInset('*')));
|
||
|
ar.push_back(*it);
|
||
|
}
|
||
|
ar.push_back(*dat.end());
|
||
|
ar.swap(dat);
|
||
|
}
|
||
|
|
||
|
|
||
|
MathInset * singleItem(MathArray & ar)
|
||
|
{
|
||
|
lyxerr << "ar.size: " << ar.size() << "\n";
|
||
|
//lyxerr << "ar.begin: " << ar.begin() << "\n";
|
||
|
//lyxerr << "ar.nuc: " << ar.begin()->nucleus() << "\n";
|
||
|
lyxerr << "ar.nuc: " << *ar.begin()->nucleus() << "\n";
|
||
|
return ar.size() == 1 ? ar.begin()->nucleus() : 0;
|
||
|
}
|
||
|
|
||
|
|
||
|
void extractMatrices(MathArray & ar)
|
||
|
{
|
||
|
for (MathArray::iterator it = ar.begin(); it != ar.end(); ++it) {
|
||
|
if (!it->nucleus())
|
||
|
continue;
|
||
|
MathDelimInset * del = it->nucleus()->asDelimInset();
|
||
|
if (!del)
|
||
|
continue;
|
||
|
MathInset * arr = singleItem(del->cell(0));
|
||
|
if (!arr || !arr->asArrayInset())
|
||
|
continue;
|
||
|
*it = MathAtom(new MathMatrixInset(*(arr->asArrayInset())));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void extractDelims(MathArray & ar) {
|
||
|
// 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) {
|
||
|
MathArray::iterator it = ar.begin() + i;
|
||
|
if (!it->nucleus())
|
||
|
continue;
|
||
|
if ((*it)->getChar() != '(')
|
||
|
continue;
|
||
|
|
||
|
// search last closing paranthesis
|
||
|
MathArray::iterator et = ar.end();
|
||
|
for (MathArray::iterator jt = it + 1; jt != ar.end(); ++jt)
|
||
|
if ((*jt)->getChar() == ')')
|
||
|
et = jt;
|
||
|
if (et == ar.end())
|
||
|
continue;
|
||
|
|
||
|
// create a proper deliminset
|
||
|
MathAtom at(new MathDelimInset("(", ")"));
|
||
|
at->cell(0) = MathArray(it + 1, et);
|
||
|
|
||
|
// replace the original stuff by the new inset
|
||
|
ar.erase(it + 1, et + 1);
|
||
|
*it = at;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
// assume 'extractDelims' ran before
|
||
|
void extractFunctions(MathArray & ar)
|
||
|
{
|
||
|
// we need at least two items...
|
||
|
if (ar.size() <= 1)
|
||
|
return;
|
||
|
|
||
|
for (MathArray::size_type i = 0; i < ar.size() - 1; ++i) {
|
||
|
MathArray::iterator it = ar.begin() + i;
|
||
|
|
||
|
// is this a function name?
|
||
|
if (!it->nucleus())
|
||
|
continue;
|
||
|
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())
|
||
|
continue;
|
||
|
++jt;
|
||
|
if (jt == ar.end())
|
||
|
continue;
|
||
|
}
|
||
|
|
||
|
// 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);
|
||
|
|
||
|
// replace the function name by a real function inset
|
||
|
(*it).reset(new MathExFuncInset(func->name(), arg));
|
||
|
|
||
|
// remove the source of the argument from the array
|
||
|
ar.erase(jt);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void extractStructure(MathArray & ar)
|
||
|
{
|
||
|
glueChars(ar);
|
||
|
extractMatrices(ar);
|
||
|
extractDelims(ar);
|
||
|
extractFunctions(ar);
|
||
|
}
|
||
|
|
||
|
|
||
|
void write(MathArray const & dat, WriteStream & wi)
|
||
|
{
|
||
|
MathArray ar = dat;
|
||
|
glueChars(ar);
|
||
|
for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it) {
|
||
|
MathInset const * p = it->nucleus();
|
||
|
if (it + 1 != ar.end()) {
|
||
|
if (MathScriptInset const * q = asScript(it)) {
|
||
|
q->write(p, wi);
|
||
|
++it;
|
||
|
continue;
|
||
|
}
|
||
|
}
|
||
|
p->write(wi);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void normalize(MathArray const & dat, NormalStream & os)
|
||
|
{
|
||
|
MathArray ar = dat;
|
||
|
glueChars(ar);
|
||
|
for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it) {
|
||
|
MathInset const * p = it->nucleus();
|
||
|
if (it + 1 != ar.end()) {
|
||
|
if (MathScriptInset const * q = asScript(it)) {
|
||
|
q->normalize(p, os);
|
||
|
++it;
|
||
|
continue;
|
||
|
}
|
||
|
}
|
||
|
p->normalize(os);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void octavize(MathArray const & dat, OctaveStream & os)
|
||
|
{
|
||
|
MathArray ar = dat;
|
||
|
extractStructure(ar);
|
||
|
for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it) {
|
||
|
MathInset const * p = it->nucleus();
|
||
|
if (it + 1 != ar.end()) {
|
||
|
if (MathScriptInset const * q = asScript(it)) {
|
||
|
q->octavize(p, os);
|
||
|
++it;
|
||
|
continue;
|
||
|
}
|
||
|
}
|
||
|
p->octavize(os);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void maplize(MathArray const & dat, MapleStream & os)
|
||
|
{
|
||
|
MathArray ar = dat;
|
||
|
extractStructure(ar);
|
||
|
for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it) {
|
||
|
MathInset const * p = it->nucleus();
|
||
|
if (it + 1 != ar.end()) {
|
||
|
if (MathScriptInset const * q = asScript(it)) {
|
||
|
q->maplize(p, os);
|
||
|
++it;
|
||
|
continue;
|
||
|
}
|
||
|
}
|
||
|
p->maplize(os);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void mathmlize(MathArray const & dat, MathMLStream & os)
|
||
|
{
|
||
|
MathArray ar = dat;
|
||
|
extractStructure(ar);
|
||
|
if (ar.size() == 0)
|
||
|
os << "<mrow/>";
|
||
|
else if (ar.size() == 1)
|
||
|
os << ar.begin()->nucleus();
|
||
|
else {
|
||
|
os << MTag("mrow");
|
||
|
for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it) {
|
||
|
MathInset const * p = it->nucleus();
|
||
|
if (it + 1 != ar.end()) {
|
||
|
if (MathScriptInset const * q = asScript(it)) {
|
||
|
q->mathmlize(p, os);
|
||
|
++it;
|
||
|
continue;
|
||
|
}
|
||
|
}
|
||
|
p->mathmlize(os);
|
||
|
}
|
||
|
os << ETag("mrow");
|
||
|
}
|
||
|
}
|
||
|
|