dont throw, assert or ponder on instead

git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@4184 a592a061-630c-0410-9148-cb99ea01b6c8

diff --git a/boost/ChangeLog b/boost/ChangeLog
index 3e8628dcc720cda44a82bc7e630abba7e1a7eaf3..f97b6325766557cc91e25dc2b1fd2a86b08a5ab6 100644 (file)
--- a/boost/ChangeLog
+++ b/boost/ChangeLog
@@ -1,5 +1,8 @@
 2002-05-22  Lars Gullik Bjønnes  <larsbj@birdstep.com>
 
+       * boost/detail/shared_count.hpp: never throw, assert or ponder on
+       instead.
+
        * major boost update. (a bit more is comming)
 
 2001-09-07  Jean-Marc Lasgouttes  <Jean-Marc.Lasgouttes@inria.fr>

diff --git a/boost/boost/detail/shared_count.hpp b/boost/boost/detail/shared_count.hpp
index 63316f41c41b9e18a2463f88251a80b677f553e7..c6a88d28a692b163b2c4c6fd14f0cb7ace2b3b1c 100644 (file)
--- a/boost/boost/detail/shared_count.hpp
+++ b/boost/boost/detail/shared_count.hpp
@@ -26,20 +26,24 @@
 #include <boost/detail/lightweight_mutex.hpp>
 
 #include <functional>       // for std::less
+#if 0
 #include <exception>        // for std::exception
+#endif
 
 namespace boost
 {
 
+#if 0
 class use_count_is_zero: public std::exception
 {
 public:
 
     virtual char const * what() const throw()
     {
-        return "use_count_is_zero";
+       return "use_count_is_zero";
     }
 };
+#endif
 
 class counted_base
 {
@@ -50,14 +54,14 @@ private:
 public:
 
     counted_base():
-        use_count_(0), weak_count_(0), self_deleter_(&self_delete)
+       use_count_(0), weak_count_(0), self_deleter_(&self_delete)
     {
     }
 
     // pre: initial_use_count <= initial_weak_count
 
     explicit counted_base(long initial_use_count, long initial_weak_count):
-        use_count_(initial_use_count), weak_count_(initial_weak_count), self_deleter_(&self_delete)
+       use_count_(initial_use_count), weak_count_(initial_weak_count), self_deleter_(&self_delete)
     {
     }
 
@@ -81,70 +85,74 @@ public:
     void add_ref()
     {
 #ifdef BOOST_HAS_THREADS
-        mutex_type::scoped_lock lock(mtx_);
+       mutex_type::scoped_lock lock(mtx_);
+#endif
+#if 0
+       if(use_count_ == 0 && weak_count_ != 0) throw use_count_is_zero();
+#else
+       if(use_count_ == 0 && weak_count_ != 0) assert(false);
 #endif
-        if(use_count_ == 0 && weak_count_ != 0) throw use_count_is_zero();
-        ++use_count_;
-        ++weak_count_;
+       ++use_count_;
+       ++weak_count_;
     }
 
     void release() // nothrow
     {
-        long new_use_count;
-        long new_weak_count;
+       long new_use_count;
+       long new_weak_count;
 
-        {
+       {
 #ifdef BOOST_HAS_THREADS
-            mutex_type::scoped_lock lock(mtx_);
+           mutex_type::scoped_lock lock(mtx_);
 #endif
-            new_use_count = --use_count_;
-            new_weak_count = --weak_count_;
-        }
+           new_use_count = --use_count_;
+           new_weak_count = --weak_count_;
+       }
 
-        if(new_use_count == 0)
-        {
-            dispose();
-        }
+       if(new_use_count == 0)
+       {
+           dispose();
+       }
 
-        if(new_weak_count == 0)
-        {
-            // not a direct 'delete this', because the inlined
-            // release() may use a different heap manager
-            self_deleter_(this);
-        }
+       if(new_weak_count == 0)
+       {
+           // not a direct 'delete this', because the inlined
+           // release() may use a different heap manager
+           self_deleter_(this);
+       }
     }
 
     void weak_add_ref() // nothrow
     {
 #ifdef BOOST_HAS_THREADS
-        mutex_type::scoped_lock lock(mtx_);
+       mutex_type::scoped_lock lock(mtx_);
 #endif
-        ++weak_count_;
+       ++weak_count_;
     }
 
     void weak_release() // nothrow
     {
-        long new_weak_count;
+       long new_weak_count;
 
-        {
+       {
 #ifdef BOOST_HAS_THREADS
-            mutex_type::scoped_lock lock(mtx_);
+           mutex_type::scoped_lock lock(mtx_);
 #endif
-            new_weak_count = --weak_count_;
-        }
+           new_weak_count = --weak_count_;
+       }
 
-        if(new_weak_count == 0)
-        {
-            self_deleter_(this);
-        }
+       if(new_weak_count == 0)
+       {
+           self_deleter_(this);
+       }
     }
 
     long use_count() const // nothrow
     {
 #ifdef BOOST_HAS_THREADS
-        mutex_type::scoped_lock lock(mtx_);
+       mutex_type::scoped_lock lock(mtx_);
 #endif
-        return use_count_;
+       return use_count_;
     }
 
 private:
@@ -154,7 +162,7 @@ private:
 
     static void self_delete(counted_base * p)
     {
-        delete p;
+       delete p;
     }
 
     // inv: use_count_ <= weak_count_
@@ -195,13 +203,13 @@ public:
     // pre: initial_use_count <= initial_weak_count, d(p) must not throw
 
     counted_base_impl(P p, D d, long initial_use_count, long initial_weak_count):
-        counted_base(initial_use_count, initial_weak_count), ptr(p), del(d)
+       counted_base(initial_use_count, initial_weak_count), ptr(p), del(d)
     {
     }
 
     virtual void dispose() // nothrow
     {
-        del(ptr);
+       del(ptr);
     }
 };
 
@@ -225,25 +233,29 @@ public:
 
     explicit shared_count(counted_base * pi): pi_(pi) // never throws
     {
-        pi_->add_ref();
+       pi_->add_ref();
     }
 
     template<class P, class D> shared_count(P p, D d, void const * = 0): pi_(0)
     {
-        try
-        {
-            pi_ = new counted_base_impl<P, D>(p, d, 1, 1);
-        }
-        catch(...)
-        {
-            d(p); // delete p
-            throw;
-        }
+#if 0
+       try
+       {
+#endif
+           pi_ = new counted_base_impl<P, D>(p, d, 1, 1);
+#if 0
+       }
+       catch(...)
+       {
+           d(p); // delete p
+           throw;
+       }
+#endif
     }
 
     template<class P, class D> shared_count(P, D, counted_base * pi): pi_(pi)
     {
-        pi_->add_ref();
+       pi_->add_ref();
     }
 
 #ifndef BOOST_NO_AUTO_PTR
@@ -253,58 +265,58 @@ public:
     template<typename Y>
     explicit shared_count(std::auto_ptr<Y> & r): pi_(new counted_base_impl< Y *, checked_deleter<Y> >(r.get(), checked_deleter<Y>(), 1, 1))
     {
-        r.release();
+       r.release();
     }
 
-#endif 
+#endif
 
     ~shared_count() // nothrow
     {
-        pi_->release();
+       pi_->release();
     }
 
     shared_count(shared_count const & r): pi_(r.pi_) // nothrow
     {
-        pi_->add_ref();
+       pi_->add_ref();
     }
 
     explicit shared_count(weak_count const & r); // throws use_count_is_zero when r.use_count() == 0
 
     shared_count & operator= (shared_count const & r) // nothrow
     {
-        counted_base * tmp = r.pi_;
-        tmp->add_ref();
-        pi_->release();
-        pi_ = tmp;
+       counted_base * tmp = r.pi_;
+       tmp->add_ref();
+       pi_->release();
+       pi_ = tmp;
 
-        return *this;
+       return *this;
     }
 
     void swap(shared_count & r) // nothrow
     {
-        counted_base * tmp = r.pi_;
-        r.pi_ = pi_;
-        pi_ = tmp;
+       counted_base * tmp = r.pi_;
+       r.pi_ = pi_;
+       pi_ = tmp;
     }
 
     long use_count() const // nothrow
     {
-        return pi_->use_count();
+       return pi_->use_count();
     }
 
     bool unique() const // nothrow
     {
-        return pi_->use_count() == 1;
+       return pi_->use_count() == 1;
     }
 
     friend inline bool operator==(shared_count const & a, shared_count const & b)
     {
-        return a.pi_ == b.pi_;
+       return a.pi_ == b.pi_;
     }
 
     friend inline bool operator<(shared_count const & a, shared_count const & b)
     {
-        return std::less<counted_base *>()(a.pi_, b.pi_);
+       return std::less<counted_base *>()(a.pi_, b.pi_);
     }
 };
 
@@ -324,59 +336,59 @@ public:
 
     weak_count(shared_count const & r): pi_(r.pi_) // nothrow
     {
-        pi_->weak_add_ref();
+       pi_->weak_add_ref();
     }
 
     weak_count(weak_count const & r): pi_(r.pi_) // nothrow
     {
-        pi_->weak_add_ref();
+       pi_->weak_add_ref();
     }
 
     ~weak_count() // nothrow
     {
-        pi_->weak_release();
+       pi_->weak_release();
     }
 
     weak_count & operator= (shared_count const & r) // nothrow
     {
-        counted_base * tmp = r.pi_;
-        tmp->weak_add_ref();
-        pi_->weak_release();
-        pi_ = tmp;
+       counted_base * tmp = r.pi_;
+       tmp->weak_add_ref();
+       pi_->weak_release();
+       pi_ = tmp;
 
-        return *this;
+       return *this;
     }
 
     weak_count & operator= (weak_count const & r) // nothrow
     {
-        counted_base * tmp = r.pi_;
-        tmp->weak_add_ref();
-        pi_->weak_release();
-        pi_ = tmp;
+       counted_base * tmp = r.pi_;
+       tmp->weak_add_ref();
+       pi_->weak_release();
+       pi_ = tmp;
 
-        return *this;
+       return *this;
     }
 
     void swap(weak_count & r) // nothrow
     {
-        counted_base * tmp = r.pi_;
-        r.pi_ = pi_;
-        pi_ = tmp;
+       counted_base * tmp = r.pi_;
+       r.pi_ = pi_;
+       pi_ = tmp;
     }
 
     long use_count() const // nothrow
     {
-        return pi_->use_count();
+       return pi_->use_count();
     }
 
     friend inline bool operator==(weak_count const & a, weak_count const & b)
     {
-        return a.pi_ == b.pi_;
+       return a.pi_ == b.pi_;
     }
 
     friend inline bool operator<(weak_count const & a, weak_count const & b)
     {
-        return std::less<counted_base *>()(a.pi_, b.pi_);
+       return std::less<counted_base *>()(a.pi_, b.pi_);
     }
 };
 

diff --git a/config/ChangeLog b/config/ChangeLog
index 1c4300ea4501818f18e58eb835756c86b3934375..fecf1d5c185d705d796960b0c446de658d4fd8e6 100644 (file)
--- a/config/ChangeLog
+++ b/config/ChangeLog
@@ -1,6 +1,7 @@
 2002-05-22  Lars Gullik Bjønnes  <larsbj@birdstep.com>
 
        * lyxinclude.m4 (lyx_warning): add entry for gcc 3.1
+       (lyx_warning): disable exceptions for gcc 3.1 too
 
        * kde.m4: remove file
 

diff --git a/config/lyxinclude.m4 b/config/lyxinclude.m4
index 804d2d25bc1a693bab65bb7125c3f60ca9995de4..7dd281dd6a771ee0d68743cd81ce389e6db277bb 100644 (file)
--- a/config/lyxinclude.m4
+++ b/config/lyxinclude.m4
@@ -211,7 +211,7 @@ if test x$GXX = xyes; then
       2.95.*)  CXXFLAGS="$lyx_opt -fno-exceptions";;
       2.96*)  CXXFLAGS="$lyx_opt -fno-exceptions";;
       3.0*)    CXXFLAGS="$lyx_opt -fno-rtti -fno-exceptions";;
-      3.1*)    CXXFLAGS="$lyx_opt";;
+      3.1*)    CXXFLAGS="$lyx_opt -fno-rtti -fno-exceptions";;
       *2.91.*) CXXFLAGS="$lyx_opt -fno-rtti -fno-exceptions";;
       *)       CXXFLAGS="$lyx_opt -fno-rtti -fno-exceptions";;
     esac