Subversion Repositories openrisc

// { dg-do compile }

// { dg-options "-fgnu-tm" }

typedef long int ptrdiff_t;

typedef long unsigned int size_t;

namespace std __attribute__ ((__visibility__ ("default")))

{

  using::ptrdiff_t;

  using::size_t;

}

namespace std __attribute__ ((__visibility__ ("default")))

{

  struct input_iterator_tag

  {

  };

  struct output_iterator_tag

  {

  };

  struct forward_iterator_tag:public input_iterator_tag

  {

  };

  struct bidirectional_iterator_tag:public forward_iterator_tag

  {

  };

  struct random_access_iterator_tag:public bidirectional_iterator_tag

  {

  };

  template < typename _Category, typename _Tp, typename _Distance =

    ptrdiff_t, typename _Pointer = _Tp *, typename _Reference =

    _Tp & >struct iterator

  {

    typedef _Category iterator_category;

    typedef _Tp value_type;

    typedef _Distance difference_type;

    typedef _Pointer pointer;

    typedef _Reference reference;

  };

  template < typename _Iterator > struct iterator_traits

  {

    typedef typename _Iterator::iterator_category iterator_category;

    typedef typename _Iterator::value_type value_type;

    typedef typename _Iterator::difference_type difference_type;

    typedef typename _Iterator::pointer pointer;

    typedef typename _Iterator::reference reference;

  };

  template < typename _Tp > struct iterator_traits <_Tp * >

  {

    typedef random_access_iterator_tag iterator_category;

    typedef _Tp value_type;

    typedef ptrdiff_t difference_type;

    typedef _Tp *pointer;

    typedef _Tp & reference;

  };

  template < typename _Tp > struct iterator_traits 

  {

    typedef random_access_iterator_tag iterator_category;

    typedef _Tp value_type;

    typedef ptrdiff_t difference_type;

    typedef const _Tp *pointer;

    typedef const _Tp & reference;

  };

  template < typename _Iter > inline typename iterator_traits <

    _Iter >::iterator_category __iterator_category (const _Iter &)

  {

    return typename iterator_traits < _Iter >::iterator_category ();

  }

}

namespace std __attribute__ ((__visibility__ ("default")))

{

template < typename _Iterator > class reverse_iterator:public iterator < typename iterator_traits < _Iterator >::iterator_category,

    typename iterator_traits < _Iterator >::value_type,

    typename iterator_traits < _Iterator >::difference_type,

    typename iterator_traits < _Iterator >::pointer,

    typename iterator_traits < _Iterator >::reference >

  {

  protected:_Iterator current;

    typedef iterator_traits < _Iterator > __traits_type;

  public:typedef _Iterator iterator_type;

    typedef typename __traits_type::difference_type difference_type;

    typedef typename __traits_type::pointer pointer;

    typedef typename __traits_type::reference reference;

  reverse_iterator ():current ()

    {

    } explicit reverse_iterator (iterator_type __x):current (__x)

    {

    } reverse_iterator (const reverse_iterator & __x):current (__x.current)

    {

    } template < typename _Iter > reverse_iterator (const reverse_iterator <

                                                    _Iter >

                                                    &__x):current (__x.

                                                                   base ())

    {

    } iterator_type base () const

    {

      return current;

    }

    reference operator* () const

    {

      _Iterator __tmp = current;

        return *--__tmp;

    }

    pointer operator-> () const

    {

      return &(operator* ());

    }

    reverse_iterator & operator++ ()

    {

      --current;

      return *this;

    }

    reverse_iterator operator++ (int)

    {

      reverse_iterator __tmp = *this;

      --current;

      return __tmp;

    }

    reverse_iterator & operator-- ()

    {

      ++current;

      return *this;

    }

    reverse_iterator operator-- (int)

    {

      reverse_iterator __tmp = *this;

      ++current;

      return __tmp;

    }

    reverse_iterator operator+ (difference_type __n) const

    {

      return reverse_iterator (current - __n);

    }

    reverse_iterator & operator+= (difference_type __n)

    {

      current -= __n;

      return *this;

    }

    reverse_iterator operator- (difference_type __n) const

    {

      return reverse_iterator (current + __n);

    }

    reverse_iterator & operator-= (difference_type __n)

    {

      current += __n;

      return *this;

    }

    reference operator[] (difference_type __n) const

    {

      return *(*this + __n);

    }

  };

  template < typename _Iterator >

    inline bool operator== (const reverse_iterator < _Iterator > &__x,

                            const reverse_iterator < _Iterator > &__y)

  {

    return __x.base () == __y.base ();

  }

  template < typename _Iterator >

    inline bool operator< (const reverse_iterator < _Iterator > &__x,

                           const reverse_iterator < _Iterator > &__y)

  {

    return __y.base () < __x.base ();

  }

  template < typename _Iterator >

    inline bool operator!= (const reverse_iterator < _Iterator > &__x,

                            const reverse_iterator < _Iterator > &__y)

  {

    return !(__x == __y);

  }

  template < typename _Iterator >

    inline bool operator> (const reverse_iterator < _Iterator > &__x,

                           const reverse_iterator < _Iterator > &__y)

  {

    return __y < __x;

  }

  template < typename _Iterator >

    inline bool operator<= (const reverse_iterator < _Iterator > &__x,

                            const reverse_iterator < _Iterator > &__y)

  {

    return !(__y < __x);

  }

  template < typename _Iterator >

    inline bool operator>= (const reverse_iterator < _Iterator > &__x,

                            const reverse_iterator < _Iterator > &__y)

  {

    return !(__x < __y);

  }

  template < typename _Iterator > inline typename reverse_iterator <

    _Iterator >::difference_type operator- (const reverse_iterator <

                                            _Iterator > &__x,

                                            const reverse_iterator <

                                            _Iterator > &__y)

  {

    return __y.base () - __x.base ();

  }

  template < typename _Iterator > inline reverse_iterator < _Iterator >

    operator+ (typename reverse_iterator < _Iterator >::difference_type __n,

               const reverse_iterator < _Iterator > &__x)

  {

    return reverse_iterator < _Iterator > (__x.base () - __n);

  }

  template < typename _IteratorL,

    typename _IteratorR > inline bool operator== (const reverse_iterator <

                                                  _IteratorL > &__x,

                                                  const reverse_iterator <

                                                  _IteratorR > &__y)

  {

    return __x.base () == __y.base ();

  }

  template < typename _IteratorL,

    typename _IteratorR > inline bool operator< (const reverse_iterator <

                                                 _IteratorL > &__x,

                                                 const reverse_iterator <

                                                 _IteratorR > &__y)

  {

    return __y.base () < __x.base ();

  }

  template < typename _IteratorL,

    typename _IteratorR > inline bool operator!= (const reverse_iterator <

                                                  _IteratorL > &__x,

                                                  const reverse_iterator <

                                                  _IteratorR > &__y)

  {

    return !(__x == __y);

  }

  template < typename _IteratorL,

    typename _IteratorR > inline bool operator> (const reverse_iterator <

                                                 _IteratorL > &__x,

                                                 const reverse_iterator <

                                                 _IteratorR > &__y)

  {

    return __y < __x;

  }

  template < typename _IteratorL,

    typename _IteratorR > inline bool operator<= (const reverse_iterator <

                                                  _IteratorL > &__x,

                                                  const reverse_iterator <

                                                  _IteratorR > &__y)

  {

    return !(__y < __x);

  }

  template < typename _IteratorL,

    typename _IteratorR > inline bool operator>= (const reverse_iterator <

                                                  _IteratorL > &__x,

                                                  const reverse_iterator <

                                                  _IteratorR > &__y)

  {

    return !(__x < __y);

  }

  template < typename _IteratorL,

    typename _IteratorR > inline typename reverse_iterator <

    _IteratorL >::difference_type operator- (const reverse_iterator <

                                             _IteratorL > &__x,

                                             const reverse_iterator <

                                             _IteratorR > &__y)

  {

    return __y.base () - __x.base ();

  }

template < typename _Container > class back_insert_iterator:public iterator < output_iterator_tag, void, void, void,

    void >

  {

  protected:_Container * container;

  public:typedef _Container container_type;

    explicit back_insert_iterator (_Container & __x):container (&__x)

    {

    } back_insert_iterator & operator= (typename _Container::

                                        const_reference __value)

    {

      container->push_back (__value);

      return *this;

    }

    back_insert_iterator & operator* ()

    {

      return *this;

    }

    back_insert_iterator & operator++ ()

    {

      return *this;

    }

    back_insert_iterator operator++ (int)

    {

      return *this;

    }

  };

  template < typename _Container > inline back_insert_iterator < _Container >

    back_inserter (_Container & __x)

  {

    return back_insert_iterator < _Container > (__x);

  }

template < typename _Container > class front_insert_iterator:public iterator < output_iterator_tag, void, void, void,

    void >

  {

  protected:_Container * container;

  public:typedef _Container container_type;

    explicit front_insert_iterator (_Container & __x):container (&__x)

    {

    } front_insert_iterator & operator= (typename _Container::

                                         const_reference __value)

    {

      container->push_front (__value);

      return *this;

    }

    front_insert_iterator & operator* ()

    {

      return *this;

    }

    front_insert_iterator & operator++ ()

    {

      return *this;

    }

    front_insert_iterator operator++ (int)

    {

      return *this;

    }

  };

  template < typename _Container > inline front_insert_iterator < _Container >

    front_inserter (_Container & __x)

  {

    return front_insert_iterator < _Container > (__x);

  }

template < typename _Container > class insert_iterator:public iterator < output_iterator_tag, void, void, void,

    void >

  {

  protected:_Container * container;

    typename _Container::iterator iter;

  public:typedef _Container container_type;

      insert_iterator (_Container & __x,

                       typename _Container::iterator __i):container (&__x),

      iter (__i)

    {

    } insert_iterator & operator= (typename _Container::

                                   const_reference __value)

    {

      iter = container->insert (iter, __value);

      ++iter;

      return *this;

    }

    insert_iterator & operator* ()

    {

      return *this;

    }

    insert_iterator & operator++ ()

    {

      return *this;

    }

    insert_iterator & operator++ (int)

    {

      return *this;

    }

  };

  template < typename _Container,

    typename _Iterator > inline insert_iterator < _Container >

    inserter (_Container & __x, _Iterator __i)

  {

    return insert_iterator < _Container > (__x,

                                           typename _Container::

                                           iterator (__i));

  }

}

namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))

{

  using std::size_t;

  using std::ptrdiff_t;

  template < typename _Tp > class new_allocator

  {

  public:typedef size_t size_type;

    typedef ptrdiff_t difference_type;

    typedef _Tp *pointer;

    typedef const _Tp *const_pointer;

    typedef _Tp & reference;

    typedef const _Tp & const_reference;

    typedef _Tp value_type;

    template < typename _Tp1 > struct rebind

    {

      typedef new_allocator < _Tp1 > other;

    };

    new_allocator ()throw ()

    {

    } new_allocator (const new_allocator &) throw ()

    {

    } template < typename _Tp1 > new_allocator (const new_allocator < _Tp1 >

                                                &) throw ()

    {

    } ~new_allocator ()throw ()

    {

    } pointer address (reference __x) const

    {

      return &__x;

    }

    const_pointer address (const_reference __x) const

    {

      return &__x;

    }

    pointer allocate (size_type __n, const void * = 0)

    {

      return static_cast < _Tp * >(::operator  new (__n * sizeof (_Tp)));

    }

    void deallocate (pointer __p, size_type)

    {

      ::operator  delete (__p);

    } size_type max_size () const throw ()

    {

      return size_t (-1) / sizeof (_Tp);

    }

    void construct (pointer __p, const _Tp & __val)

    {

      ::new ((void *) __p) _Tp (__val);

    } void destroy (pointer __p)

    {

      __p->~_Tp ();

  }};

  template < typename _Tp > inline bool operator== (const new_allocator <

                                                    _Tp > &,

                                                    const new_allocator <

                                                    _Tp > &)

  {

    return true;

  }

  template < typename _Tp > inline bool operator!= (const new_allocator <

                                                    _Tp > &,

                                                    const new_allocator <

                                                    _Tp > &)

  {

    return false;

  }

}

namespace std __attribute__ ((__visibility__ ("default")))

{

  template < typename _Tp > class allocator;

  template <> class allocator < void >

  {

  public:typedef size_t size_type;

    typedef ptrdiff_t difference_type;

    typedef void *pointer;

    typedef const void *const_pointer;

    typedef void value_type;

      template < typename _Tp1 > struct rebind

    {

      typedef allocator < _Tp1 > other;

    };

  };

template < typename _Tp > class allocator:public __gnu_cxx::new_allocator <

    _Tp >

  {

  public:typedef size_t size_type;

    typedef ptrdiff_t difference_type;

    typedef _Tp *pointer;

    typedef const _Tp *const_pointer;

    typedef _Tp & reference;

    typedef const _Tp & const_reference;

    typedef _Tp value_type;

    template < typename _Tp1 > struct rebind

    {

      typedef allocator < _Tp1 > other;

    };

    allocator ()throw ()

    {

    } allocator (const allocator & __a) throw ():__gnu_cxx::new_allocator <

      _Tp > (__a)

    {

    } template < typename _Tp1 > allocator (const allocator < _Tp1 >

                                            &) throw ()

    {

    } ~allocator ()throw ()

    {

  }};

  template < typename _T1,

    typename _T2 > inline bool operator== (const allocator < _T1 > &,

                                           const allocator < _T2 > &)

  {

    return true;

  }

  template < typename _Tp > inline bool operator== (const allocator < _Tp > &,

                                                    const allocator < _Tp > &)

  {

    return true;

  }

  template < typename _T1,

    typename _T2 > inline bool operator!= (const allocator < _T1 > &,

                                           const allocator < _T2 > &)

  {

    return false;

  }

  template < typename _Tp > inline bool operator!= (const allocator < _Tp > &,

                                                    const allocator < _Tp > &)

  {

    return false;

  }

  template < typename _Alloc, bool = __is_empty (_Alloc) > struct __alloc_swap

  {

    static void _S_do_it (_Alloc &, _Alloc &)

    {

  }};

  template < typename _Alloc > struct __alloc_swap <_Alloc, false >

  {

    static void _S_do_it (_Alloc & __one, _Alloc & __two)

    {

      if (__one != __two)

        swap (__one, __two);

    }

  };

  template < typename _Alloc, bool = __is_empty (_Alloc) > struct __alloc_neq

  {

    static bool _S_do_it (const _Alloc &, const _Alloc &)

    {

      return false;

    }

  };

  template < typename _Alloc > struct __alloc_neq <_Alloc, false >

  {

    static bool _S_do_it (const _Alloc & __one, const _Alloc & __two)

    {

      return __one != __two;

    }

  };

}

namespace std __attribute__ ((__visibility__ ("default")))

{

  struct _List_node_base

  {

    _List_node_base *_M_next;

    _List_node_base *_M_prev;

    static void swap (_List_node_base & __x, _List_node_base & __y) throw ();

    void _M_transfer (_List_node_base * const __first,

                      _List_node_base * const __last) throw ();

    void _M_reverse () throw ();

    void _M_hook (_List_node_base * const __position) throw ();

    void _M_unhook () throw ();

  };

  template < typename _Tp > struct _List_node:public _List_node_base

  {

    _Tp _M_data;

  };

  template < typename _Tp > struct _List_iterator

  {

    typedef _List_iterator < _Tp > _Self;

    typedef _List_node < _Tp > _Node;

    typedef ptrdiff_t difference_type;

    typedef std::bidirectional_iterator_tag iterator_category;

    typedef _Tp value_type;

    typedef _Tp *pointer;

    typedef _Tp & reference;

      _List_iterator ():_M_node ()

    {

    } explicit _List_iterator (_List_node_base * __x):_M_node (__x)

    {

    } reference operator* () const

    {

      return static_cast < _Node * >(_M_node)->_M_data;

    }

    pointer operator-> () const

    {

      return &static_cast < _Node * >(_M_node)->_M_data;

    }

    _Self & operator++ ()

    {

      _M_node = _M_node->_M_next;

      return *this;

    }

    _Self operator++ (int)

    {

      _Self __tmp = *this;

      _M_node = _M_node->_M_next;

      return __tmp;

    }

    _Self & operator-- ()

    {

      _M_node = _M_node->_M_prev;

      return *this;

    }

    _Self operator-- (int)

    {

      _Self __tmp = *this;

      _M_node = _M_node->_M_prev;

      return __tmp;

    }

    bool operator== (const _Self & __x) const

    {

      return _M_node == __x._M_node;

    }

    bool operator!= (const _Self & __x) const

    {

      return _M_node != __x._M_node;

    }

    _List_node_base *_M_node;

  };

  template < typename _Tp > struct _List_const_iterator

  {

    typedef _List_const_iterator < _Tp > _Self;

    typedef const _List_node < _Tp > _Node;

    typedef _List_iterator < _Tp > iterator;

    typedef ptrdiff_t difference_type;

    typedef std::bidirectional_iterator_tag iterator_category;

    typedef _Tp value_type;

    typedef const _Tp *pointer;

    typedef const _Tp & reference;

      _List_const_iterator ():_M_node ()

    {

    } explicit _List_const_iterator (const _List_node_base *

                                     __x):_M_node (__x)

    {

    } _List_const_iterator (const iterator & __x):_M_node (__x._M_node)

    {

    } reference operator* () const

    {

      return static_cast < _Node * >(_M_node)->_M_data;

    }

    pointer operator-> () const

    {

      return &static_cast < _Node * >(_M_node)->_M_data;

    }

    _Self & operator++ ()

    {

      _M_node = _M_node->_M_next;

      return *this;

    }

    _Self operator++ (int)

    {

      _Self __tmp = *this;

      _M_node = _M_node->_M_next;

      return __tmp;

    }

    _Self & operator-- ()

    {

      _M_node = _M_node->_M_prev;

      return *this;

    }

    _Self operator-- (int)

    {

      _Self __tmp = *this;

      _M_node = _M_node->_M_prev;

      return __tmp;

    }

    bool operator== (const _Self & __x) const

    {

      return _M_node == __x._M_node;

    }

    bool operator!= (const _Self & __x) const

    {

      return _M_node != __x._M_node;

    }

    const _List_node_base *_M_node;

  };

  template < typename _Tp, typename _Alloc > class _List_base

  {

  protected:typedef typename _Alloc::template rebind < _List_node < _Tp >

      >::other _Node_alloc_type;

    typedef typename _Alloc::template rebind < _Tp >::other _Tp_alloc_type;

    struct _List_impl:public _Node_alloc_type

    {

      _List_node_base _M_node;

        _List_impl ():_Node_alloc_type (), _M_node ()

      {

      } _List_impl (const _Node_alloc_type & __a):_Node_alloc_type (__a),

        _M_node ()

      {

    }};

    _List_impl _M_impl;

    _List_node < _Tp > *_M_get_node ()

    {

      return _M_impl._Node_alloc_type::allocate (1);

    }

    void _M_put_node (_List_node < _Tp > *__p)

    {

      _M_impl._Node_alloc_type::deallocate (__p, 1);

  } public:typedef _Alloc allocator_type;

    _Node_alloc_type & _M_get_Node_allocator ()

    {

      return *static_cast < _Node_alloc_type * >(&this->_M_impl);

    }

    const _Node_alloc_type & _M_get_Node_allocator () const

    {

      return *static_cast < const _Node_alloc_type *>(&this->_M_impl);

    } _Tp_alloc_type _M_get_Tp_allocator () const

    {

      return _Tp_alloc_type (_M_get_Node_allocator ());

    }

    allocator_type get_allocator () const

    {

      return allocator_type (_M_get_Node_allocator ());

    }

    _List_base ():_M_impl ()

    {

      _M_init ();

    }

  _List_base (const allocator_type & __a):_M_impl (__a)

    {

      _M_init ();

    } ~_List_base ()

    {

      _M_clear ();

    } void _M_clear ();

    void _M_init ()

    {

      this->_M_impl._M_node._M_next = &this->_M_impl._M_node;

      this->_M_impl._M_node._M_prev = &this->_M_impl._M_node;

  }};

template < typename _Tp, typename _Alloc = std::allocator < _Tp > >class list:protected _List_base < _Tp,

    _Alloc

    >

  {

    typedef typename _Alloc::value_type _Alloc_value_type;

    typedef _List_base < _Tp, _Alloc > _Base;

    typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;

  public:typedef _Tp value_type;

    typedef typename _Tp_alloc_type::pointer pointer;

    typedef typename _Tp_alloc_type::const_pointer const_pointer;

    typedef typename _Tp_alloc_type::reference reference;

    typedef typename _Tp_alloc_type::const_reference const_reference;

    typedef _List_iterator < _Tp > iterator;

    typedef _List_const_iterator < _Tp > const_iterator;

    typedef std::reverse_iterator < const_iterator > const_reverse_iterator;

    typedef std::reverse_iterator < iterator > reverse_iterator;

    typedef size_t size_type;

    typedef ptrdiff_t difference_type;

    typedef _Alloc allocator_type;

  protected:typedef _List_node < _Tp > _Node;

    using _Base::_M_impl;

    using _Base::_M_put_node;

    using _Base::_M_get_node;

    using _Base::_M_get_Tp_allocator;

    using _Base::_M_get_Node_allocator;

  public:iterator begin ()

    {

      return iterator (this->_M_impl._M_node._M_next);

    }

    const_iterator begin () const

    {

      return const_iterator (this->_M_impl._M_node._M_next);

    }

    iterator end ()

    {

      return iterator (&this->_M_impl._M_node);

    }

    void remove (const _Tp & __value);

    template < typename _Predicate > void remove_if (_Predicate);

    void _M_erase (iterator __position)

    {

      __position._M_node->_M_unhook ();

      _Node *__n = static_cast < _Node * >(__position._M_node);

      _M_get_Tp_allocator ().destroy (&__n->_M_data);

      _M_put_node (__n);

    } void _M_check_equal_allocators (list & __x)

    {

      if (std::__alloc_neq <

          typename _Base::_Node_alloc_type >::

          _S_do_it (_M_get_Node_allocator (), __x._M_get_Node_allocator ()));

    }

  };

}

namespace std __attribute__ ((__visibility__ ("default")))

{

  template < typename _Tp, typename _Alloc > void list < _Tp,

    _Alloc >::remove (const value_type & __value)

  {

    iterator __first = begin ();

    iterator __last = end ();

    iterator __extra = __last;

    while (__first != __last)

      {

        iterator __next = __first;

        ++__next;

        if (*__first == __value)

          {

            if (&*__first != &__value)

              _M_erase (__first);

            else

              __extra = __first;

          }

        __first = __next;

      }

    if (__extra != __last)

      _M_erase (__extra);

  }

}

class Unit

{

public:int dummy;

};

class Building

{

public:__attribute__ ((transaction_callable)) void removeUnitFromInside (Unit *

                                                                    unit);

    std::list < Unit * >unitsInside;

};

void

Building::removeUnitFromInside (Unit * unit)

{

  unitsInside.remove (unit);

}