the freespacing patch from Kayvan, draw the math empty delim with onoffdash, asure...

[lyx.git] / src / support / lyxstring.C

diff --git a/src/support/lyxstring.C b/src/support/lyxstring.C
index 13b9b151d72b0b9123916ededcb8d4c55445aa43..3f8deedfb55a18595f9b722aced6ae17ab750b37 100644 (file)
--- a/src/support/lyxstring.C
+++ b/src/support/lyxstring.C
@@ -3,8 +3,8 @@
  * 
  *           LyX, The Document Processor
  *      
- *         Copyright (C) 1995 Matthias Ettrich
- *          Copyright (C) 1995-1999 The LyX Team.
+ *         Copyright 1995 Matthias Ettrich
+ *          Copyright 1995-1999 The LyX Team.
  *
  * ====================================================== */
 
@@ -59,16 +59,12 @@ using std::min;
 
 // Lgb.
 
+
 ///////////////////////////////////////
 // The internal string representation
 ///////////////////////////////////////
-#define NEW_ALLOC 1
 
 struct lyxstring::Srep {
-#ifndef NEW_ALLOC
-       ///
-       static size_t const xtra = static_cast<size_t>(8);
-#endif
        /// size
        size_t sz;
        /// Reference count
@@ -118,15 +114,12 @@ private:
 
 lyxstring::Srep::Srep(lyxstring::size_type nsz, const value_type * p)
 {
-// can be called with p == 0 by lyxstring::assign(const value_type *, size_type)
+       // can be called with p == 0 by
+       // lyxstring::assign(const value_type *, size_type)
 
        sz = nsz;
        ref = 1;
-#ifdef NEW_ALLOC
        res = sz ? sz : 1;
-#else
-       res = sz + xtra;
-#endif
        s = new value_type[res + 1]; // add space for terminator
        if (p && sz) {
                // if sz = 0 nothing gets copied and we have an error
@@ -143,11 +136,7 @@ lyxstring::Srep::Srep(lyxstring::size_type nsz, value_type ch)
 {
        sz = nsz;
        ref = 1;
-#ifdef NEW_ALLOC
        res = sz ? sz : 1;
-#else
-       res = sz + xtra;
-#endif
        s = new value_type[res + 1]; // add space for terminator
        memset(s, ch, sz);
        if (!ch) {
@@ -160,16 +149,13 @@ lyxstring::Srep::Srep(lyxstring::size_type nsz, value_type ch)
 
 void lyxstring::Srep::assign(lyxstring::size_type nsz, const value_type * p)
 {
-// can be called with p == 0 by lyxstring::assign(const value_type *, size_type)
+       // can be called with p == 0
+       // by lyxstring::assign(const value_type *, size_type)
 
        if (res < nsz) {
                delete[] s;
                sz = nsz;
-#ifdef NEW_ALLOC
                res = sz ? sz : 1;
-#else
-               res = sz + xtra;
-#endif
                s = new value_type[res + 1]; // add space for terminator
        } else {
                sz = nsz;
@@ -190,11 +176,7 @@ void lyxstring::Srep::assign(lyxstring::size_type nsz, value_type ch)
        sz = nsz;
        if (res < nsz) {
                delete[] s;
-#ifdef NEW_ALLOC
                res = sz ? sz : 1;
-#else
-               res = sz + xtra;
-#endif
                s = new value_type[res + 1]; // add space for terminator
        }
        memset(s, ch, sz);
@@ -210,13 +192,9 @@ void lyxstring::Srep::append(lyxstring::size_type asz, const value_type * p)
 {
        register unsigned int const len = sz + asz;
        if (res < len) {
-#ifdef NEW_ALLOC
                do {
                        res *= 2;
                } while (res < len);
-#else
-               res = len + xtra;
-#endif
                value_type * tmp = new value_type[res + 1];
                memcpy(tmp, s, sz);
                memcpy(tmp + sz, p, asz);
@@ -235,13 +213,9 @@ void lyxstring::Srep::push_back(value_type c)
        s[sz] = c; // it is always room to put a value_type at the end
        ++sz;
        if (res < sz) {
-#ifdef NEW_ALLOC
                do {
                        res *= 2;
                } while (res < sz);
-#else
-               res = sz + xtra;
-#endif
                value_type * tmp = new value_type[res + 1];
                memcpy(tmp, s, sz);
                delete[] s;
@@ -251,25 +225,21 @@ void lyxstring::Srep::push_back(value_type c)
 
 
 void lyxstring::Srep::insert(lyxstring::size_type pos, const value_type * p,
-                          lyxstring::size_type n)
+                            lyxstring::size_type n)
 {
        if (res < n + sz) {
-#ifdef NEW_ALLOC
                do {
                        res *= 2;
                } while (res < n + sz);
-#else
-               res = sz + n + xtra;
-#endif
                value_type * tmp = new value_type[res + 1];
                memcpy(tmp, s, pos);
                memcpy(tmp + pos, p, n);
-               memcpy(tmp + pos + n, & s[pos], sz - pos);
+               memcpy(tmp + pos + n, &s[pos], sz - pos);
                sz += n;
                delete[] s;
                s = tmp;
        } else {
-               memmove(s + pos + n, & s[pos], sz - pos);
+               memmove(s + pos + n, &s[pos], sz - pos);
                memcpy(s + pos, p, n);
                sz += n;
        }
@@ -303,7 +273,7 @@ void lyxstring::Srep::reserve(lyxstring::size_type res_arg)
 
 
 void lyxstring::Srep::replace(lyxstring::size_type i, lyxstring::size_type n,
-                           value_type const * p, size_type n2)
+                             value_type const * p, size_type n2)
 {
 // can be called with p= 0 and n2= 0
        n = min(sz - i, n);
@@ -313,13 +283,9 @@ void lyxstring::Srep::replace(lyxstring::size_type i, lyxstring::size_type n,
                memcpy(s + i, p, n2);
                sz += n2;
        } else {
-#ifdef NEW_ALLOC
                do {
                        res *= 2;
                } while (res < n2 + sz);
-#else
-               res = sz + n2 + xtra;
-#endif
                value_type * tmp = new value_type[res + 1];
                memcpy(tmp, s, i);
                memcpy(tmp + i, p, n2);
@@ -334,7 +300,7 @@ void lyxstring::Srep::replace(lyxstring::size_type i, lyxstring::size_type n,
 ///////////////////////////////////////
 // The lyxstring Invariant tester
 ///////////////////////////////////////
-#ifdef DEVEL_VERSION
+#ifdef ENABLE_ASSERTIONS
 
 /** Testing of the lyxstring invariant
  * By creating an object that tests the lyxstring invariant during its
@@ -384,12 +350,14 @@ lyxstringInvariant::lyxstringInvariant(lyxstring const * ls) : object(ls)
        helper();
 }
 
+
 lyxstringInvariant::~lyxstringInvariant()
 {
        helper();
        // printf("lyxstringInvariant destructor completed\n");
 }
 
+
 void lyxstringInvariant::helper() const
 {
        // Some of these tests might look pointless but they are
@@ -411,7 +379,7 @@ void lyxstringInvariant::helper() const
 #define TestlyxstringInvariant(s) lyxstringInvariant lyxstring_invariant(s);
 #else
 #define TestlyxstringInvariant(s)
-#endif //DEVEL_VERSION
+#endif /* ENABLE_ASSERTIONS */
 
 
 ///////////////////////////////////////
@@ -421,6 +389,7 @@ void lyxstringInvariant::helper() const
 lyxstring::size_type const lyxstring::npos =
 static_cast<lyxstring::size_type>(-1);
 
+
 lyxstring::lyxstring()
 {
        static Srep empty_rep(0, "");
@@ -832,7 +801,7 @@ lyxstring & lyxstring::insert(size_type pos, lyxstring const & x)
 
 
 lyxstring & lyxstring::insert(size_type pos, lyxstring const & x,
-                         size_type pos2, size_type n)
+                             size_type pos2, size_type n)
 {
        Assert(pos <= rep->sz && pos2 <= x.rep->sz); // STD!
        TestlyxstringInvariant(this);
@@ -945,7 +914,7 @@ lyxstring::size_type lyxstring::find(lyxstring const & a, size_type i) const
 
 
 lyxstring::size_type lyxstring::find(value_type const * ptr, size_type i,
-                                size_type n) const
+                                    size_type n) const
 {
        Assert(ptr); // OURS!
        if (!rep->sz || !*ptr || i >= rep->sz) return npos;
@@ -1020,7 +989,7 @@ lyxstring::size_type lyxstring::rfind(lyxstring const & a, size_type i) const
 
 
 lyxstring::size_type lyxstring::rfind(value_type const * ptr, size_type i,
-                                 size_type n) const
+                                     size_type n) const
 {
        Assert(ptr); // OURS!
        TestlyxstringInvariant(this);
@@ -1076,7 +1045,7 @@ lyxstring::size_type lyxstring::rfind(value_type c, size_type i) const
 
 
 lyxstring::size_type lyxstring::find_first_of(lyxstring const & a,
-                                         size_type i) const
+                                             size_type i) const
 {
        Assert(i < rep->sz); // OURS!
        TestlyxstringInvariant(this);
@@ -1088,8 +1057,9 @@ lyxstring::size_type lyxstring::find_first_of(lyxstring const & a,
 }
 
 
-lyxstring::size_type lyxstring::find_first_of(value_type const * ptr, size_type i,
-                                         size_type n) const
+lyxstring::size_type lyxstring::find_first_of(value_type const * ptr,
+                                             size_type i,
+                                             size_type n) const
 {
        Assert(ptr && i < rep->sz); // OURS!
        TestlyxstringInvariant(this);
@@ -1103,7 +1073,7 @@ lyxstring::size_type lyxstring::find_first_of(value_type const * ptr, size_type
 
 
 lyxstring::size_type lyxstring::find_first_of(value_type const * ptr,
-                                         size_type i) const
+                                             size_type i) const
 {
        Assert(ptr && i < rep->sz); // OURS!
        TestlyxstringInvariant(this);
@@ -1128,7 +1098,7 @@ lyxstring::size_type lyxstring::find_first_of(value_type c, size_type i) const
 
 
 lyxstring::size_type lyxstring::find_last_of(lyxstring const & a,
-                                        size_type i) const
+                                            size_type i) const
 {
        TestlyxstringInvariant(this);
 
@@ -1139,8 +1109,10 @@ lyxstring::size_type lyxstring::find_last_of(lyxstring const & a,
        return npos;
 }
 
-lyxstring::size_type lyxstring::find_last_of(value_type const * ptr, size_type i,
-                                        size_type n) const
+
+lyxstring::size_type lyxstring::find_last_of(value_type const * ptr,
+                                            size_type i,
+                                            size_type n) const
 {
        Assert(ptr); // OURS!
        TestlyxstringInvariant(this);
@@ -1155,7 +1127,7 @@ lyxstring::size_type lyxstring::find_last_of(value_type const * ptr, size_type i
 
 
 lyxstring::size_type lyxstring::find_last_of(value_type const * ptr,
-                                        size_type i) const
+                                            size_type i) const
 {
        Assert(ptr); // OURS!
        TestlyxstringInvariant(this);
@@ -1522,7 +1494,8 @@ int lyxstring::compare(value_type const * s) const
 }
 
 
-int lyxstring::compare(size_type pos, size_type n, lyxstring const & str) const
+int lyxstring::compare(size_type pos, size_type n,
+                      lyxstring const & str) const
 {
        Assert(pos <= rep->sz); // OURS!
        TestlyxstringInvariant(this);
@@ -1764,11 +1737,13 @@ istream & operator>>(istream & is, lyxstring & s)
        return is;
 }
 
+
 ostream & operator<<(ostream & o, lyxstring const & s)
 {
        return o.write(s.data(), s.length());
 }
 
+
 istream & getline(istream & is, lyxstring & s,
                  lyxstring::value_type delim)
 {