(( len == -1 || cs.pos() + len > int(md.size()))
? md.end()
: md.begin() + cs.pos() + len );
- MathData md2;
+ MathData md2(cur.buffer());
for (MathData::const_iterator it = md.begin() + cs.pos(); it != it_end; ++it)
md2.push_back(*it);
docstring res = from_utf8(latexNamesToUtf8(asString(md2), false));
((len == -1 || cs.pos() + len > int(md.size()))
? md.end()
: md.begin() + cs.pos() + len);
- MathData md2;
+ MathData md2(cur.buffer());
for (MathData::const_iterator it = md.begin() + cs.pos();
it != it_end; ++it)
md2.push_back(*it);
MathData md = cs.cell();
int len = -1;
MathData::const_iterator it_end = md.end();
- MathData md2;
+ MathData md2(cur.buffer());
// Start the check with one character before actual cursor position
for (MathData::const_iterator it = md.begin() + cs.pos() - 1;
it != it_end; ++it)
MathData const & InsetMath::cell(idx_type) const
{
- static MathData dummyCell;
+ static MathData dummyCell(const_cast<Buffer *>(&buffer()));
LYXERR0("I don't have any cell");
return dummyCell;
}
{
const col_type nc = ncols();
const row_type nr = nrows();
- cells_type new_cells((nc + 1) * nr);
+ cells_type new_cells((nc + 1) * nr, MathData(buffer_));
vector<CellInfo> new_cellinfo((nc + 1) * nr);
for (row_type row = 0; row < nr; ++row)
void InsetMathHull::glueall(HullType type)
{
- MathData ar;
+ MathData ar(buffer_);
for (idx_type i = 0; i < nargs(); ++i)
ar.append(cell(i));
InsetLabel * label = nullptr;
// replace selection with result of computation
if (reduceSelectionToOneCell(cur)) {
- MathData ar;
+ MathData ar(buffer_);
asArray(grabAndEraseSelection(cur), ar);
lyxerr << "use selection: " << ar << endl;
cur.insert(pipeThroughExtern(lang, extra, ar));
return;
}
- MathData eq;
+ MathData eq(buffer_);
eq.push_back(MathAtom(new InsetMathChar('=')));
// go to first item in line
if (getType() == hullSimple) {
size_type pos = cur.cell().find_last(eq);
- MathData ar;
+ MathData ar(buffer_);
if (pos == cur.cell().size()) {
ar = cur.cell();
lyxerr << "use whole cell: " << ar << endl;
public:
///
InsetArgumentProxy(InsetMathMacro * mathMacro, size_t idx)
- : mathMacro_(mathMacro), idx_(idx) {}
+ : mathMacro_(mathMacro), idx_(idx), def_(&mathMacro->buffer()) {}
///
InsetArgumentProxy(InsetMathMacro * mathMacro, size_t idx, docstring const & def)
- : mathMacro_(mathMacro), idx_(idx)
+ : mathMacro_(mathMacro), idx_(idx), def_(&mathMacro->buffer())
{
asArray(def, def_);
}
vector<docstring> const & defaults = d->macro_->defaults();
// create MathMacroArgumentValue objects pointing to the cells of the macro
- vector<MathData> values(nargs());
+ vector<MathData> values(nargs(), MathData(buffer_));
for (size_t i = 0; i < nargs(); ++i) {
InsetArgumentProxy * proxy;
if (i < defaults.size())
if (d->displayMode_ != mode) {
// transfer name if changing from or to DISPLAY_UNFOLDED
if (mode == DISPLAY_UNFOLDED) {
- cells_.resize(1);
+ cells_.resize(1, MathData(buffer_));
asArray(d->name_, cell(0));
} else if (d->displayMode_ == DISPLAY_UNFOLDED) {
d->name_ = asString(cell(0));
- cells_.resize(0);
+ cells_.clear();
}
d->displayMode_ = mode;
void InsetMathMacro::insertArgument(pos_type pos) {
if (d->displayMode_ == DISPLAY_NORMAL) {
LASSERT(size_t(pos) <= cells_.size(), return);
- cells_.insert(cells_.begin() + pos, MathData());
+ cells_.insert(cells_.begin() + pos, MathData(buffer_));
if (size_t(pos) < d->attachedArgsNum_)
++d->attachedArgsNum_;
if (size_t(pos) < d->optionals_)
size_t i;
for (i = cells_.size(); i > d->attachedArgsNum_; --i)
if (!cell(i - 1).empty()) break;
- args.resize(i);
+ args.erase(args.begin() + i, args.end());
}
d->attachedArgsNum_ = 0;
- d->expanded_ = MathData();
- cells_.resize(0);
+ d->expanded_ = MathData(buffer_);
+ cells_.clear();
d->needsUpdate_ = true;
}
LASSERT(d->displayMode_ == DISPLAY_NORMAL, return);
cells_ = args;
d->attachedArgsNum_ = args.size();
- cells_.resize(arity);
- d->expanded_ = MathData();
+ cells_.resize(arity, MathData(buffer_));
+ d->expanded_ = MathData(buffer_);
d->optionals_ = optionals;
d->needsUpdate_ = true;
}
+InsetMathMacroTemplate::InsetMathMacroTemplate(Buffer * buf, docstring const & name, int numargs,
+ int optionals, MacroType type)
+ : InsetMathMacroTemplate(buf, name, numargs, optionals, type,
+ vector<MathData>(), MathData(buf), MathData(buf))
+{
+}
+
+
InsetMathMacroTemplate::InsetMathMacroTemplate(Buffer * buf, docstring const & name, int numargs,
int optionals, MacroType type, vector<MathData> const & optionalValues,
MathData const & def, MathData const & display)
<< numargs_ << endl;
asArray(name, cell(0));
- optionalValues_.resize(9);
+ optionalValues_.resize(9, MathData(buffer_));
for (int i = 0; i < optionals_; ++i)
cell(optIdx(i)) = optionalValues_[i];
cell(defIdx()) = def;
look_.push_back(MathAtom(new InsetMathBrace(arg)));
}
for (; i < argsInLook_; ++i) {
- MathData arg;
+ MathData arg(buffer_);
arg.push_back(MathAtom(new InsetMathMacroArgument(i + 1)));
look_.push_back(MathAtom(new InsetColoredCell(buffer_,
Color_mathmacronewarg,
///
explicit InsetMathMacroTemplate(Buffer * buf);
///
+ InsetMathMacroTemplate(Buffer * buf, docstring const & name, int numargs,
+ int optionals, MacroType type);
+ ///
InsetMathMacroTemplate(Buffer * buf, docstring const & name, int numargs,
int optionals, MacroType type,
- std::vector<MathData> const & optionalValues = std::vector<MathData>(),
- MathData const & def = MathData(),
- MathData const & display = MathData());
+ std::vector<MathData> const & optionalValues,
+ MathData const & def, MathData const & display);
/// parses from string, returns false if failed
bool fromString (const docstring & str);
///
InsetMathNest::InsetMathNest(Buffer * buf, idx_type nargs)
- : InsetMath(buf), cells_(nargs), lock_(false)
+ : InsetMath(buf), cells_(nargs, MathData(buffer_)), lock_(false)
{
// FIXME This should not really be necessary, but when we are
// initializing the table of global macros, we create macros
MathData InsetMathNest::glue() const
{
- MathData ar;
+ MathData ar(buffer_);
for (size_t i = 0; i < nargs(); ++i)
ar.append(cell(i));
return ar;
cur.mathForward(false);
cur.setSelection();
cutSelection(cur, false);
- MathData ar;
+ MathData ar(buffer_);
if (!sel1.empty()) {
mathed_parse_cell(ar, beg + sel1 + end);
cur.insert(ar);
}
case LFUN_INSET_INSERT: {
- MathData ar;
+ MathData ar(buffer_);
if (createInsetMath_fromDialogStr(cmd.argument(), ar)) {
cur.recordUndoSelection();
cur.insert(ar);
cmd = FuncRequest(LFUN_PASTE, "0");
doDispatch(bv.cursor(), cmd);
} else {
- MathData ar;
+ MathData ar(buffer_);
asArray(theSelection().get(), ar);
bv.cursor().insert(ar);
}
cur.forceBufferUpdate();
break;
}
- MathData ar;
+ MathData ar(buffer_);
if (createInsetMath_fromDialogStr(cmd.argument(), ar)) {
cur.recordUndo();
Buffer & buf = buffer();
}
} else if (arg0 == "changetype") {
docstring const data = from_ascii(createDialogStr(arg1));
- MathData ar;
+ MathData ar(buffer_);
if (createInsetMath_fromDialogStr(data, ar)) {
cur.recordUndo();
Buffer & buf = buffer();
icp["reference"] = target;
if (!cell(1).empty())
icp["name"] = asString(cell(1));
- MathData ar;
+ MathData ar(buffer_);
Buffer & buf = buffer();
if (createInsetMath_fromDialogStr(
from_utf8(InsetCommand::params2string(icp)), ar)) {
{
if (nargs() == 1) {
// just nucleus so far
- cells_.push_back(MathData());
+ cells_.push_back(MathData(buffer_));
cell_1_is_up_ = up;
} else if (nargs() == 2 && !has(up)) {
if (up) {
cells_.push_back(cell(1));
cell(1).clear();
} else {
- cells_.push_back(MathData());
+ cells_.push_back(MathData(buffer_));
}
}
}
switch (cmd.action()) {
case LFUN_INSET_MODIFY:
if (cmd.getArg(0) == "mathspace") {
- MathData ar;
+ MathData ar(buffer_);
if (createInsetMath_fromDialogStr(cmd.argument(), ar)) {
Buffer * buf = buffer_;
cur.recordUndo();
public:
///
/// \brief Correction
- Correction() : from2_(0) {}
+ Correction() : from1_(nullptr), from2_(0), to_(nullptr) {}
///
bool correct(Cursor & cur, char_type c) const;
///
return false;
if (s2.size() != 1)
return false;
- MathData ar1, ar3;
+ MathData ar1(nullptr), ar3(nullptr);
mathed_parse_cell(ar1, s1);
mathed_parse_cell(ar3, s3);
from1_ = ar1;
}
// Otherwise we don't drop an empty optional, put it back normally
- MathData optarg;
+ MathData optarg(buffer_);
asArray(from_ascii("[]"), optarg);
MathData & arg = detachedArgs[j];
// In the math parser we remove empty braces in the base
// of a script inset, but we have to restore them here.
if (scriptInset->nuc().empty()) {
- MathData ar;
+ MathData ar(buffer_);
scriptInset->nuc().push_back(
MathAtom(new InsetMathBrace(ar)));
}
// fill up empty optional parameters
while (params.size() < numOptionalParams)
- params.push_back(MathData());
+ params.push_back(MathData(buffer_));
}
}
} else {
// the simplest case: plain inset
- MathData array;
+ MathData array(buffer_);
array.insert(0, cell);
params.push_back(array);
}
public:
///
- MathData() = default;
+ MathData() = delete;
///
explicit MathData(Buffer * buf) : buffer_(buf) {}
///
// 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
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
vector<string> tmp = getVectorFromString(out, "$$");
if (tmp.size() < 2)
- return MathData();
+ return MathData(nullptr);
out = subst(subst(tmp[1], "\\>", string()), "{\\it ", "\\mathit{");
lyxerr << "output: '" << out << "'" << endl;
//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;
}
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;
}
lyxerr << "unusual contents found: " << ar << endl;
at = MathAtom(new InsetMathPar(buffer_, ar));
//if (at->nargs() > 0)
- // at.nucleus()->cell(0) = ar;
+ // at.nucleus()->cell(0) = ar(buffer_);
//else
// lyxerr << "unusual contents found: " << ar << endl;
success_ = false;
if (flags & FLAG_OPTION) {
if (t.cat() == catOther && t.character() == '[') {
- MathData ar;
+ MathData ar(buf);
parse(ar, FLAG_BRACK_LAST, mode);
cell->append(ar);
} else {
cell->push_back(MathAtom(new InsetMathSpace(string(1, t.character()), "")));
else if (t.cat() == catBegin) {
- MathData ar;
+ MathData ar(buf);
parse(ar, FLAG_BRACE_LAST, mode);
// do not create a BraceInset if they were written by LyX
// this helps to keep the annoyance of "a choose b" to a minimum
nargs /= 2;
// read definition
- MathData def;
+ MathData def(buf);
parse(def, FLAG_ITEM, InsetMath::UNDECIDED_MODE);
// is a version for display attached?
skipSpaces();
- MathData display;
+ MathData display(buf);
if (nextToken().cat() == catBegin)
parse(display, FLAG_ITEM, InsetMath::MATH_MODE);
vector<MathData> optionalValues;
while (nextToken().character() == '[') {
getToken();
- optionalValues.push_back(MathData());
+ optionalValues.push_back(MathData(buf));
parse(optionalValues[optionals], FLAG_BRACK_LAST, mode);
++optionals;
}
- MathData def;
+ MathData def(buf);
parse(def, FLAG_ITEM, InsetMath::UNDECIDED_MODE);
// is a version for display attached?
skipSpaces();
- MathData display;
+ MathData display(buf);
if (nextToken().cat() == catBegin)
parse(display, FLAG_ITEM, InsetMath::MATH_MODE);
// get value
int optNum = max(size_t(n), optionalValues.size());
- optionalValues.resize(optNum);
+ optionalValues.resize(optNum, MathData(buf));
optionalValues[n - 1].clear();
while (nextToken().character() != ']'
&& nextToken().character() != ',') {
- MathData data;
+ MathData data(buf);
parse(data, FLAG_ITEM, InsetMath::UNDECIDED_MODE);
optionalValues[n - 1].append(data);
}
// value?
skipSpaces();
- MathData value;
+ MathData value(buf);
if (nextToken().character() == '=') {
getToken();
while (nextToken().character() != ']'
}
// get definition
- MathData def;
+ MathData def(buf);
parse(def, FLAG_ITEM, InsetMath::UNDECIDED_MODE);
// is a version for display attached?
skipSpaces();
- MathData display;
+ MathData display(buf);
if (nextToken().cat() == catBegin)
parse(display, FLAG_ITEM, InsetMath::MATH_MODE);
// if the columns are specified numerically,
// extract column count and insert dummy cells,
// otherwise parse it as an user macro
- MathData count;
+ MathData count(buf);
parse(count, FLAG_ITEM, mode);
int cols = 0;
// limit arbitrarily to 100 columns
InsetMathGrid::CELL_BEGIN_OF_MULTICOLUMN;
// read special alignment
- MathData align;
+ MathData align(buf);
parse(align, FLAG_ITEM, mode);
grid.cellinfo(first).align = asString(align);
}
else if (t.cs() == "sqrt") {
- MathData ar;
+ MathData ar(buf);
parse(ar, FLAG_OPTION, mode);
if (!ar.empty()) {
cell->push_back(MathAtom(new InsetMathRoot(buf)));
}
else if (t.cs() == "cancelto") {
- MathData ar;
+ MathData ar(buf);
parse(ar, FLAG_ITEM, mode);
cell->push_back(MathAtom(new InsetMathCancelto(buf)));
cell->back().nucleus()->cell(1) = ar;
else if (t.cs() == "unit") {
// Allowed formats \unit[val]{unit}
- MathData ar;
+ MathData ar(buf);
parse(ar, FLAG_OPTION, mode);
if (!ar.empty()) {
cell->push_back(MathAtom(new InsetMathFrac(buf, InsetMathFrac::UNIT)));
else if (t.cs() == "unitfrac") {
// Here allowed formats are \unitfrac[val]{num}{denom}
- MathData ar;
+ MathData ar(buf);
parse(ar, FLAG_OPTION, mode);
if (!ar.empty()) {
cell->push_back(MathAtom(new InsetMathFrac(buf, InsetMathFrac::UNITFRAC, 3)));
else if (t.cs() == "sideset") {
// Here allowed formats are \sideset{_{bl}^{tl}}{_{br}^{tr}}{operator}
- MathData ar[2];
+ MathData ar[2]= { MathData(buf), MathData(buf) };
InsetMathScript * script[2] = {0, 0};
for (int i = 0; i < 2; ++i) {
parse(ar[i], FLAG_ITEM, mode);
else if (t.cs() == "stackrel") {
// Here allowed formats are \stackrel[subscript]{superscript}{operator}
- MathData ar;
+ MathData ar(buf);
parse(ar, FLAG_OPTION, mode);
cell->push_back(MathAtom(new InsetMathStackrel(buf, !ar.empty())));
if (!ar.empty())
// can't handle \|
// FIXME: fix this in InsetMathDelim itself!
docstring const l = tl.cs() == "|" ? from_ascii("Vert") : tl.asString();
- MathData ar;
+ MathData ar(buf);
parse(ar, FLAG_RIGHT, mode);
if (!good())
break;
else if (t.cs() == "label") {
// FIXME: This is swallowed in inline formulas
docstring label = parse_verbatim_item();
- MathData ar;
+ MathData ar(buf);
asArray(label, ar);
if (grid.asHullInset()) {
grid.asHullInset()->label(cellrow, label);
// Since the Length class cannot use length variables
// we must not create an InsetMathSpace.
cell->push_back(MathAtom(new InsetMathMacro(buf, name)));
- MathData ar;
+ MathData ar(buf);
mathed_parse_cell(ar, '{' + arg + '}', mode_);
cell->append(ar);
}
} else {
docstring const arg = parse_verbatim_item();
cell->push_back(MathAtom(new InsetMathMacro(buf, t.cs())));
- MathData ar;
+ MathData ar(buf);
mathed_parse_cell(ar, '[' + opt + ']', mode_);
cell->append(ar);
- ar = MathData();
+ ar = MathData(buf);
mathed_parse_cell(ar, '{' + arg + '}', mode_);
cell->append(ar);
}
#if 0
else if (t.cs() == "infer") {
- MathData ar;
+ MathData ar(buf);
parse(ar, FLAG_OPTION, mode);
cell->push_back(createInsetMath(t.cs(), buf));
parse2(cell->back(), FLAG_ITEM, mode, false);
projects / lyx.git / commitdiff