further code uglification to make Jean-Marc's compiler happy

[lyx.git] / src / mathed / array.C

diff --git a/src/mathed/array.C b/src/mathed/array.C
index c5552aff4a6c622a0d43eff1e8c68bc1b427bd41..cdf974e615889e990e7a862f4d770d72a1b02c92 100644 (file)
--- a/src/mathed/array.C
+++ b/src/mathed/array.C
@@ -4,96 +4,55 @@
 
 #include "math_inset.h"
 #include "math_charinset.h"
+#include "math_scriptinset.h"
 #include "debug.h"
 #include "array.h"
-#include "math_scriptinset.h"
 #include "mathed/support.h"
 
 using std::ostream;
 using std::endl;
 
+
 MathArray::MathArray()
 {}
 
 
-MathArray::~MathArray()
-{
-       erase();
-}
-
-
-MathArray::MathArray(MathArray const & array)
-       : bf_(array.bf_)
-{
-       deep_copy(begin(), end());
-}
-
-
-MathArray::MathArray(MathArray const & array, int from, int to)
+MathArray::MathArray(MathArray const & array, size_type from, size_type to)
        : bf_(array.begin() + from, array.begin() + to)
-{
-       deep_copy(begin(), end());
-}
-
-
-void MathArray::deep_copy(iterator from, iterator to)
-{
-       for (iterator it = from; it != to; ++it)
-               *it = (*it)->clone();
-}
-
-
-int MathArray::last() const
-{
-       return size() - 1;
-}
+{}
 
 
 void MathArray::substitute(MathMacro const & m)
 {
-       MathArray tmp;
        for (iterator it = begin(); it != end(); ++it)
-               (*it)->substitute(tmp, m);
-       swap(tmp);
-}
-
-
-MathArray & MathArray::operator=(MathArray const & array)
-{
-       MathArray tmp(array);
-       swap(tmp);
-       return *this;
+               it->substitute(m);
 }
 
 
-MathInset * MathArray::nextInset(int pos)
+MathAtom * MathArray::at(size_type pos)
 {
-       return (pos == size()) ? 0 : bf_[pos];
+       return pos < size() ? &bf_[pos] : 0;
 }
 
 
-MathInset const * MathArray::nextInset(int pos) const
+MathAtom const * MathArray::at(size_type pos) const
 {
-       return (pos == size()) ? 0 : bf_[pos];
+       return pos < size() ? &bf_[pos] : 0;
 }
 
 
-void MathArray::insert(int pos, MathInset * p)
+void MathArray::insert(size_type pos, MathInset * p)
 {
-       bf_.insert(begin() + pos, p);
+       //cerr << "\n  1: "; p->write(cerr, true); cerr << p << "\n";
+       // inserting here invalidates the pointer!
+       bf_.insert(begin() + pos, MathAtom(p));
+       //cerr << "\n  2: "; p->write(cerr, true); cerr << p << "\n";
 }
 
 
-void MathArray::insert(int pos, unsigned char b, MathTextCodes t)
-{
-       bf_.insert(begin() + pos, new MathCharInset(b, t));
-}
-
-
-void MathArray::insert(int pos, MathArray const & array)
+void MathArray::insert(size_type pos, MathArray const & array)
 {
        bf_.insert(begin() + pos, array.begin(), array.end());
-       deep_copy(begin() + pos, begin() + pos + array.size());
 }
 
 
@@ -103,12 +62,6 @@ void MathArray::push_back(MathInset * p)
 }
 
 
-void MathArray::push_back(unsigned char b, MathTextCodes c)
-{
-       insert(size(), b, c);
-}
-
-
 void MathArray::push_back(MathArray const & array)
 {
        insert(size(), array);
@@ -134,7 +87,7 @@ bool MathArray::empty() const
 }
    
 
-int MathArray::size() const
+MathArray::size_type MathArray::size() const
 {
        return bf_.size();
 }
@@ -146,24 +99,22 @@ void MathArray::erase()
 }
 
 
-void MathArray::erase(int pos)
+void MathArray::erase(size_type pos)
 {
        if (pos < size())
                erase(pos, pos + 1);
 }
 
 
-void MathArray::erase(int pos1, int pos2)
+void MathArray::erase(size_type pos1, size_type pos2)
 {
-       for (iterator it = begin() + pos1; it != begin() + pos2; ++it)
-               delete *it;
        bf_.erase(begin() + pos1, begin() + pos2);
 }
 
 
-MathInset * MathArray::back() const
+MathAtom & MathArray::back()
 {
-       return size() ? bf_.back() : 0;
+       return bf_.back();
 }
 
 
@@ -188,10 +139,40 @@ std::ostream & operator<<(std::ostream & os, MathArray const & ar)
 }
 
 
+// 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)
+               return s;
+
+       for (MathTextCodes c = p->code(); it != end; ++it) {
+               p = it->nucleus()->asCharInset();
+               if (!p || it->up() || it->down() || p->code() != c)
+                       break;
+               s += p->getChar();
+       }
+       return s;
+}
+
+
 void MathArray::write(ostream & os, bool fragile) const
 {
-       for (const_iterator it = begin(); it != end(); ++it)
-               (*it)->write(os, fragile);
+       for (const_iterator it = begin(); it != end(); ++it) {
+               MathCharInset const * p = it->nucleus()->asCharInset();
+               if (p && !it->up() && !it->down()) {
+                       // special handling for character sequences with the same code
+                       string s = charSequence(it, end());
+                       p->writeHeader(os);
+                       os << s;
+                       p->writeTrailer(os);
+                       it += s.size() - 1;
+               } else {
+                       it->write(os, fragile);
+               }
+       }
 }
 
 
@@ -209,7 +190,7 @@ void MathArray::writeNormal(ostream & os) const
 void MathArray::validate(LaTeXFeatures & features) const
 {
        for (const_iterator it = begin(); it != end(); ++it)
-               (*it)->validate(features);
+               it->validate(features);
 }
 
 
@@ -219,7 +200,6 @@ void MathArray::pop_back()
                lyxerr << "pop_back from empty array!\n";
                return;
        }
-       delete back();
        bf_.pop_back();
 }