- added some (empty) exception specifications (reduces code size a little)

- synced to 1.1 (ex::const_iterator::operator[])

diff --git a/ginac/ex.h b/ginac/ex.h
index ee891a2fb9c431e0c66f7440a00ad5bc74c6e654..70ce112dd799690cbfe73e04fa54b68d2924a4fb 100644 (file)
--- a/ginac/ex.h
+++ b/ginac/ex.h
@@ -69,7 +69,7 @@ class ex
        
        // default constructor, copy constructor and assignment operator
 public:
        
        // default constructor, copy constructor and assignment operator
 public:

-       ex();
+       ex() throw();

 #ifdef OBSCURE_CINT_HACK
        ex(const ex & other);
        ex & operator=(const ex & other);
 #ifdef OBSCURE_CINT_HACK
        ex(const ex & other);
        ex & operator=(const ex & other);


@@ -97,35 +97,35 @@ public:
                friend class ex;
 
        public:
                friend class ex;
 
        public:

-               const_iterator() {}
-               const_iterator(const basic *bp_, size_t i_) : bp(bp_), i(i_) {}
+               const_iterator() throw() {}
+               const_iterator(const basic *bp_, size_t i_) throw() : bp(bp_), i(i_) {}

 
 

-               bool operator==(const const_iterator &other) const
+               bool operator==(const const_iterator &other) const throw()

                {
                        return bp == other.bp && i == other.i;
                }
 
                {
                        return bp == other.bp && i == other.i;
                }
 

-               bool operator!=(const const_iterator &other) const
+               bool operator!=(const const_iterator &other) const throw()

                {
                        return !(*this == other);
                }
 
                {
                        return !(*this == other);
                }
 

-               bool operator<(const const_iterator &other) const
+               bool operator<(const const_iterator &other) const throw()

                {
                        return i < other.i;
                }
 
                {
                        return i < other.i;
                }
 

-               bool operator>(const const_iterator &other) const
+               bool operator>(const const_iterator &other) const throw()

                {
                        return other < *this;
                }
 
                {
                        return other < *this;
                }
 

-               bool operator<=(const const_iterator &other) const
+               bool operator<=(const const_iterator &other) const throw()

                {
                        return !(other < *this);
                }
 
                {
                        return !(other < *this);
                }
 

-               bool operator>=(const const_iterator &other) const
+               bool operator>=(const const_iterator &other) const throw()

                {
                        return !(*this < other);
                }
                {
                        return !(*this < other);
                }


@@ -146,66 +146,67 @@ public:
                }
 #endif
 
                }
 #endif
 

-               const_iterator &operator++()
+               const_iterator &operator++() throw()

                {
                        ++i;
                        return *this;
                }
 
                {
                        ++i;
                        return *this;
                }
 

-               const_iterator operator++(int)
+               const_iterator operator++(int) throw()

                {
                        const_iterator tmp = *this;
                        ++i;
                        return tmp;
                }
 
                {
                        const_iterator tmp = *this;
                        ++i;
                        return tmp;
                }
 

-               const_iterator &operator+=(difference_type n)
+               const_iterator &operator+=(difference_type n) throw()

                {
                        i += n;
                        return *this;
                }
 
                {
                        i += n;
                        return *this;
                }
 

-               const_iterator operator+(difference_type n) const
+               const_iterator operator+(difference_type n) const throw()

                {
                        return const_iterator(bp, i + n);
                }
 
                {
                        return const_iterator(bp, i + n);
                }
 

-               inline friend const_iterator operator+(difference_type n, const const_iterator &it)
+               inline friend const_iterator operator+(difference_type n, const const_iterator &it) throw()

                {
                        return const_iterator(it.bp, it.i + n);
                }
 
                {
                        return const_iterator(it.bp, it.i + n);
                }
 

-               const_iterator &operator--()
+               const_iterator &operator--() throw()

                {
                        --i;
                        return *this;
                }
 
                {
                        --i;
                        return *this;
                }
 

-               const_iterator operator--(int)
+               const_iterator operator--(int) throw()

                {
                        const_iterator tmp = *this;
                        --i;
                        return tmp;
                }
 
                {
                        const_iterator tmp = *this;
                        --i;
                        return tmp;
                }
 

-               const_iterator &operator-=(difference_type n)
+               const_iterator &operator-=(difference_type n) throw()

                {
                        i -= n;
                        return *this;
                }
 
                {
                        i -= n;
                        return *this;
                }
 

-               const_iterator operator-(difference_type n) const
+               const_iterator operator-(difference_type n) const throw()

                {
                        return const_iterator(bp, i - n);
                }
 
                {
                        return const_iterator(bp, i - n);
                }
 

-               inline friend difference_type operator-(const const_iterator &lhs, const const_iterator &rhs)
+               inline friend difference_type operator-(const const_iterator &lhs, const const_iterator &rhs) throw()

                {
                        return lhs.i - rhs.i;
                }
 
                {
                        return lhs.i - rhs.i;
                }
 

-               reference operator[](difference_type n) const
+               ex operator[](difference_type n) const

                {
                {

+                       return bp->op(i + n);

                }
 
        protected:
                }
 
        protected:


@@ -213,8 +214,8 @@ public:
                size_t i;
        };
 
                size_t i;
        };
 

-       const_iterator begin() const { return const_iterator(get_pointer(bp), 0); }
-       const_iterator end() const { return const_iterator(get_pointer(bp), bp->nops()); }
+       const_iterator begin() const throw() { return const_iterator(get_pointer(bp), 0); }
+       const_iterator end() const throw() { return const_iterator(get_pointer(bp), bp->nops()); }

 
 #if 0
        // This doesn't work because of the "reference to temporary" problem
 
 #if 0
        // This doesn't work because of the "reference to temporary" problem


@@ -227,7 +228,7 @@ public:
        // non-virtual functions in this class
 public:
        /** Efficiently swap the contents of two expressions. */
        // non-virtual functions in this class
 public:
        /** Efficiently swap the contents of two expressions. */

-       void swap(ex & other)
+       void swap(ex & other) throw()

        {
                GINAC_ASSERT(bp->flags & status_flags::dynallocated);
                GINAC_ASSERT(other.bp->flags & status_flags::dynallocated);
        {
                GINAC_ASSERT(bp->flags & status_flags::dynallocated);
                GINAC_ASSERT(other.bp->flags & status_flags::dynallocated);


@@ -387,7 +388,7 @@ public:
 extern const basic *_num0_bp;
 
 inline
 extern const basic *_num0_bp;
 
 inline

-ex::ex() : bp(*const_cast<basic *>(_num0_bp))
+ex::ex() throw() : bp(*const_cast<basic *>(_num0_bp))

 {
        GINAC_ASSERT(bp->flags & status_flags::dynallocated);
 #ifdef OBSCURE_CINT_HACK
 {
        GINAC_ASSERT(bp->flags & status_flags::dynallocated);
 #ifdef OBSCURE_CINT_HACK

diff --git a/ginac/ptr.h b/ginac/ptr.h
index df758808b8e33985d542a3af8d73ad317764f95c..fd380506fdd6daaec5183e94f8557c7306f51f4c 100644 (file)
--- a/ginac/ptr.h
+++ b/ginac/ptr.h
@@ -48,12 +48,12 @@ public:
     // no default ctor: a ptr is never unbound
 
        /** Bind ptr to newly created object, start reference counting. */
     // no default ctor: a ptr is never unbound
 
        /** Bind ptr to newly created object, start reference counting. */

-       ptr(T *t) : p(t) { GINAC_ASSERT(p); p->refcount = 1; }
+       ptr(T *t) throw() : p(t) { GINAC_ASSERT(p); p->refcount = 1; }

 
        /** Bind ptr to existing reference-counted object. */
 
        /** Bind ptr to existing reference-counted object. */

-       explicit ptr(T &t) : p(&t) { ++p->refcount; }
+       explicit ptr(T &t) throw() : p(&t) { ++p->refcount; }

 
 

-       ptr(const ptr & other) : p(other.p) { ++p->refcount; }
+       ptr(const ptr & other) throw() : p(other.p) { ++p->refcount; }

 
        ~ptr()
        {
 
        ~ptr()
        {


@@ -71,10 +71,10 @@ public:
                return *this;
        }
 
                return *this;
        }
 

-       T &operator*() const { return *p; }
-       T *operator->() const { return p; }
+       T &operator*() const throw() { return *p; }
+       T *operator->() const throw() { return p; }

 
 

-       friend inline T *get_pointer(const ptr & x) { return x.p; }
+       friend inline T *get_pointer(const ptr & x) throw() { return x.p; }

 
        /** Announce your intention to modify the object bound to this ptr.
         *  This ensures that the object is not shared by any other ptrs. */
 
        /** Announce your intention to modify the object bound to this ptr.
         *  This ensures that the object is not shared by any other ptrs. */


@@ -89,7 +89,7 @@ public:
        }
 
        /** Swap the bound object of this ptr with another ptr. */
        }
 
        /** Swap the bound object of this ptr with another ptr. */

-       void swap(ptr & other)
+       void swap(ptr & other) throw()

        {
                T *t = p;
                p = other.p;
        {
                T *t = p;
                p = other.p;


@@ -102,22 +102,22 @@ public:
        // to different (probably derived) types and raw pointers.
 
        template <class U>
        // to different (probably derived) types and raw pointers.
 
        template <class U>

-       bool operator==(const ptr<U> & rhs) const { return p == get_pointer(rhs); }
+       bool operator==(const ptr<U> & rhs) const throw() { return p == get_pointer(rhs); }

 
        template <class U>
 
        template <class U>

-       bool operator!=(const ptr<U> & rhs) const { return p != get_pointer(rhs); }
+       bool operator!=(const ptr<U> & rhs) const throw() { return p != get_pointer(rhs); }

 
        template <class U>
 
        template <class U>

-       inline friend bool operator==(const ptr & lhs, const U * rhs) { return lhs.p == rhs; }
+       inline friend bool operator==(const ptr & lhs, const U * rhs) throw() { return lhs.p == rhs; }

 
        template <class U>
 
        template <class U>

-       inline friend bool operator!=(const ptr & lhs, const U * rhs) { return lhs.p != rhs; }
+       inline friend bool operator!=(const ptr & lhs, const U * rhs) throw() { return lhs.p != rhs; }

 
        template <class U>
 
        template <class U>

-       inline friend bool operator==(const U * lhs, const ptr & rhs) { return lhs == rhs.p; }
+       inline friend bool operator==(const U * lhs, const ptr & rhs) throw() { return lhs == rhs.p; }

 
        template <class U>
 
        template <class U>

-       inline friend bool operator!=(const U * lhs, const ptr & rhs) { return lhs != rhs.p; }
+       inline friend bool operator!=(const U * lhs, const ptr & rhs) throw() { return lhs != rhs.p; }

 
        inline friend std::ostream & operator<<(std::ostream & os, const ptr<T> & rhs)
        {
 
        inline friend std::ostream & operator<<(std::ostream & os, const ptr<T> & rhs)
        {

diff --git a/ginac/symbol.cpp b/ginac/symbol.cpp
index dd6e664394a4beae6f39e178372c865be1016f54..480c25c453fc8f648548cbded62cabeece80703a 100644 (file)
--- a/ginac/symbol.cpp
+++ b/ginac/symbol.cpp
@@ -296,7 +296,7 @@ unsigned symbol::next_serial = 0;
 //////////
 
 /** Default ctor.  Defaults to unassigned. */
 //////////
 
 /** Default ctor.  Defaults to unassigned. */

-symbol::assigned_ex_info::assigned_ex_info() : is_assigned(false)
+symbol::assigned_ex_info::assigned_ex_info() throw() : is_assigned(false)

 {
 }
 
 {
 }
 

diff --git a/ginac/symbol.h b/ginac/symbol.h
index 707aedb1d7981bc02741adb77c888e6add4d6c30..bacd59fa370a9f49c2347e97c50be6d5d60aa2b9 100644 (file)
--- a/ginac/symbol.h
+++ b/ginac/symbol.h
@@ -46,11 +46,11 @@ class symbol : public basic
        class assigned_ex_info {
                friend class ptr<assigned_ex_info>;
        public:
        class assigned_ex_info {
                friend class ptr<assigned_ex_info>;
        public:

-               assigned_ex_info();     ///< Default ctor
-               bool is_assigned;       ///< True if there is an expression assigned
-               ex assigned_expression; ///< The actual expression
+               assigned_ex_info() throw();  ///< Default ctor
+               bool is_assigned;            ///< True if there is an expression assigned
+               ex assigned_expression;      ///< The actual expression

        private:
        private:

-               size_t refcount;        ///< Reference counter, managed by ptr<assigned_ex_info>
+               size_t refcount;             ///< Reference counter, managed by ptr<assigned_ex_info>

        };
 
 // member functions
        };
 
 // member functions