X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2Farray.C;h=48deaf73ab7066e3b125c9b91b8cb0d7bb11a3bb;hb=dff2911bda426ad439e6475f62183cedd7044801;hp=756cb75c5aeed92af7efed4f3d914ade46c1457e;hpb=9f42114d4d865aac377bee09389e4c88fe701cc3;p=features.git diff --git a/src/mathed/array.C b/src/mathed/array.C index 756cb75c5a..48deaf73ab 100644 --- a/src/mathed/array.C +++ b/src/mathed/array.C @@ -1,336 +1,270 @@ - -#include - #ifdef __GNUG__ #pragma implementation #endif -#include "debug.h" -#include "array.h" #include "math_inset.h" +#include "math_charinset.h" #include "math_scriptinset.h" -#include "math_parser.h" +#include "math_stringinset.h" +#include "debug.h" +#include "array.h" #include "mathed/support.h" +#include "support/LAssert.h" using std::ostream; using std::endl; + MathArray::MathArray() {} -MathArray::~MathArray() -{ - for (int pos = 0; pos < size(); next(pos)) - if (MathIsInset(pos)) - delete GetInset(pos); -} +MathArray::MathArray(MathArray const & array, size_type from, size_type to) + : bf_(array.begin() + from, array.begin() + to) +{} -MathArray::MathArray(MathArray const & array) - : bf_(array.bf_) +void MathArray::substitute(MathMacro const & m) { - for (int pos = 0; pos < size(); next(pos)) - if (isInset(pos)) - replace(pos, GetInset(pos)->Clone()); + for (iterator it = begin(); it != end(); ++it) + it->nucleus()->substitute(m); } -bool MathArray::next(int & pos) const +MathScriptInset const * MathArray::asScript(const_iterator it) const { - if (pos >= size() - 1) - return false; - - pos += item_size(pos); - return true; + if (it->nucleus()->asScriptInset()) + return 0; + const_iterator jt = it + 1; + if (jt == end()) + return 0; + return jt->nucleus()->asScriptInset(); } -bool MathArray::prev(int & pos) const +MathAtom & MathArray::at(size_type pos) { - if (pos == 0) - return false; - - pos -= item_size(pos - 1); - return true; + lyx::Assert(pos < size()); + return bf_[pos]; } -bool MathArray::last(int & pos) const +MathAtom const & MathArray::at(size_type pos) const { - pos = bf_.size(); - return prev(pos); + lyx::Assert(pos < size()); + return bf_[pos]; } -int MathArray::item_size(int pos) const +void MathArray::insert(size_type pos, MathAtom const & t) { - return 2 + (isInset(pos) ? sizeof(MathInset*) : 1); + bf_.insert(begin() + pos, t); } - -void MathArray::substitute(MathMacro const & m) +void MathArray::insert(size_type pos, MathArray const & array) { - MathArray tmp; - for (int pos = 0; pos < size(); next(pos)) { - if (isInset(pos)) - GetInset(pos)->substitute(tmp, m); - else - tmp.push_back(GetChar(pos), GetCode(pos)); - } - swap(tmp); + bf_.insert(begin() + pos, array.begin(), array.end()); } -MathArray & MathArray::operator=(MathArray const & array) -{ - MathArray tmp(array); - swap(tmp); - return *this; +void MathArray::push_back(MathAtom const & t) +{ + bf_.push_back(t); } -MathInset * MathArray::GetInset(int pos) const +void MathArray::push_back(MathArray const & array) { - if (!isInset(pos)) - return 0; - MathInset * p; - memcpy(&p, &bf_[0] + pos + 1, sizeof(p)); - return p; + insert(size(), array); } -byte MathArray::GetChar(int pos) const -{ - return pos < size() ? bf_[pos + 1] : '\0'; -} -MathTextCodes MathArray::GetCode(int pos) const +void MathArray::clear() { - return pos < size() ? MathTextCodes(bf_[pos]) : LM_TC_MIN; + erase(); } -void MathArray::insert(int pos, MathInset * p) + +void MathArray::swap(MathArray & array) { - bf_.insert(bf_.begin() + pos, 2 + sizeof(p), LM_TC_INSET); - memcpy(&bf_[pos + 1], &p, sizeof(p)); + if (this != &array) + bf_.swap(array.bf_); } -void MathArray::replace(int pos, MathInset * p) +bool MathArray::empty() const { - memcpy(&bf_[pos + 1], &p, sizeof(p)); + return bf_.empty(); } -void MathArray::insert(int pos, byte b, MathTextCodes t) + +MathArray::size_type MathArray::size() const { - bf_.insert(bf_.begin() + pos, 3, t); - bf_[pos + 1] = b; + return bf_.size(); } -void MathArray::insert(int pos, MathArray const & array) +void MathArray::erase() { -#ifdef WITH_WARNINGS -#warning quick and really dirty: make sure that we really own our insets -#endif - MathArray a = array; - bf_.insert(bf_.begin() + pos, a.bf_.begin(), a.bf_.end()); + erase(0, size()); } -void MathArray::push_back(MathInset * p) -{ - insert(size(), p); -} - -void MathArray::push_back(byte b, MathTextCodes c) +void MathArray::erase(size_type pos) { - insert(size(), b, c); + if (pos < size()) + erase(pos, pos + 1); } -void MathArray::push_back(MathArray const & array) + +void MathArray::erase(size_type pos1, size_type pos2) { - insert(size(), array); + bf_.erase(begin() + pos1, begin() + pos2); } - -void MathArray::clear() +MathAtom & MathArray::back() { - bf_.clear(); + return bf_.back(); } -void MathArray::swap(MathArray & array) +void MathArray::dump2(ostream & os) const { - if (this != &array) - bf_.swap(array.bf_); + for (const_iterator it = begin(); it != end(); ++it) + os << it->nucleus() << ' '; } -bool MathArray::empty() const +void MathArray::dump(ostream & os) const { - return bf_.empty(); + for (const_iterator it = begin(); it != end(); ++it) + os << "<" << it->nucleus() << ">"; } - -int MathArray::size() const + +std::ostream & operator<<(std::ostream & os, MathArray const & ar) { - return bf_.size(); + ar.dump2(os); + return os; } -void MathArray::erase(int pos) +// 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) { - if (pos < static_cast(bf_.size())) - erase(pos, pos + item_size(pos)); + string s; + MathCharInset const * p = it->nucleus()->asCharInset(); + if (!p) + return s; + + 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 MathArray::erase(int pos1, int pos2) +MathArray MathArray::glueChars() const { - bf_.erase(bf_.begin() + pos1, bf_.begin() + pos2); + MathArray ar; + const_iterator it = begin(); + while (it != end()) { + if (it->nucleus() && it->nucleus()->asCharInset()) { + string s = charSequence(it, end()); + MathTextCodes c = it->nucleus()->asCharInset()->code(); + ar.push_back(MathAtom(new MathStringInset(s, c))); + it += s.size(); + } else { + ar.push_back(*it); + ++it; + } + } + return ar; } -bool MathArray::isInset(int pos) const +void MathArray::write(MathWriteInfo & wi) const { - if (pos >= size()) - return false; - return MathIsInset(bf_[pos]); + glueChars().write1(wi); } -MathInset * MathArray::back_inset() const +void MathArray::write1(MathWriteInfo & wi) const { - if (!empty()) { - int pos = size(); - prev(pos); - if (isInset(pos)) - return GetInset(pos); + for (const_iterator it = begin(); it != end(); ++it) { + MathInset * p = it->nucleus(); + if (!p) + continue; + if (MathScriptInset const * q = asScript(it)) { + q->write(p, wi); + ++it; + } else { + p->write(wi); + } } - return 0; } -MathScriptInset * MathArray::prevScriptInset(int pos) const +void MathArray::writeNormal(ostream & os) const { - if (!pos) - return 0; - prev(pos); - - MathInset * inset = GetInset(pos); - if (inset && inset->isScriptInset()) - return static_cast(inset); - - return 0; -} - -MathScriptInset * MathArray::nextScriptInset(int pos) const -{ - MathInset * inset = GetInset(pos); - if (inset && inset->isScriptInset()) - return static_cast(inset); - - return 0; + for (const_iterator it = begin(); it != end(); ++it) { + MathInset * p = it->nucleus(); + if (!p) + continue; + if (MathScriptInset const * q = asScript(it)) { + q->writeNormal(p, os); + ++it; + } else { + p->writeNormal(os); + } + } } -void MathArray::dump2(ostream & os) const +void MathArray::validate(LaTeXFeatures & features) const { - for (buffer_type::const_iterator it = bf_.begin(); it != bf_.end(); ++it) - os << int(*it) << ' '; - os << endl; + for (const_iterator it = begin(); it != end(); ++it) + it->nucleus()->validate(features); } - -void MathArray::dump(ostream & os) const -{ - for (int pos = 0; pos < size(); next(pos)) { - if (isInset(pos)) - os << ""; - else - os << "<" << int(bf_[pos]) << " " << int(bf_[pos+1]) << ">"; +void MathArray::pop_back() +{ + if (!size()) { + lyxerr << "pop_back from empty array!\n"; + return; } + bf_.pop_back(); } -std::ostream & operator<<(std::ostream & os, MathArray const & ar) +MathArray::const_iterator MathArray::begin() const { - ar.dump2(os); - return os; + return bf_.begin(); } -void MathArray::Write(ostream & os, bool fragile) const +MathArray::const_iterator MathArray::end() const { - if (empty()) - return; - - int brace = 0; - - for (int pos = 0; pos < size(); next(pos)) { - if (isInset(pos)) { - - GetInset(pos)->Write(os, fragile); - - } else { + return bf_.end(); +} - MathTextCodes fcode = GetCode(pos); - byte c = GetChar(pos); - - if (MathIsSymbol(fcode)) { - latexkeys const * l = lm_get_key_by_id(c, LM_TK_SYM); - - if (l == 0) { - l = lm_get_key_by_id(c, LM_TK_BIGSYM); - } - - if (l) { - os << '\\' << l->name << ' '; - } else { - lyxerr << "Could not find the LaTeX name for " << c << " and fcode " << fcode << "!" << std::endl; - } - } else { - if (fcode >= LM_TC_RM && fcode <= LM_TC_TEXTRM) - os << '\\' << math_font_name[fcode - LM_TC_RM] << '{'; - - // Is there a standard logical XOR? - if ((fcode == LM_TC_TEX && c != '{' && c != '}') || - (fcode == LM_TC_SPECIAL)) - os << '\\'; - else { - if (c == '{') - ++brace; - if (c == '}') - --brace; - } - if (c == '}' && fcode == LM_TC_TEX && brace < 0) - lyxerr <<"Math warning: Unexpected closing brace.\n"; - else - os << c; - } - - if (fcode >= LM_TC_RM && fcode <= LM_TC_TEXTRM) - os << '}'; - - } - } - if (brace > 0) - os << string(brace, '}'); +MathArray::iterator MathArray::begin() +{ + return bf_.begin(); } -void MathArray::WriteNormal(ostream & os) const +MathArray::iterator MathArray::end() { - if (empty()) { - os << "[par] "; - return; - } - - Write(os, true); + return bf_.end(); } -