gcc/testsuite/g++.dg/tm/20100727.C

   1 // { dg-do compile }
   2 // { dg-options "-fgnu-tm" }
   3
   4 typedef long int ptrdiff_t;
   5 typedef long unsigned int size_t;
   6 namespace std __attribute__ ((__visibility__ ("default")))
   7 {
   8   using::ptrdiff_t;
   9   using::size_t;
  10 }
  11
  12 namespace std __attribute__ ((__visibility__ ("default")))
  13 {
  14   struct input_iterator_tag
  15   {
  16   };
  17   struct output_iterator_tag
  18   {
  19   };
  20   struct forward_iterator_tag:public input_iterator_tag
  21   {
  22   };
  23   struct bidirectional_iterator_tag:public forward_iterator_tag
  24   {
  25   };
  26   struct random_access_iterator_tag:public bidirectional_iterator_tag
  27   {
  28   };
  29   template < typename _Category, typename _Tp, typename _Distance =
  30     ptrdiff_t, typename _Pointer = _Tp *, typename _Reference =
  31     _Tp & >struct iterator
  32   {
  33     typedef _Category iterator_category;
  34     typedef _Tp value_type;
  35     typedef _Distance difference_type;
  36     typedef _Pointer pointer;
  37     typedef _Reference reference;
  38   };
  39   template < typename _Iterator > struct iterator_traits
  40   {
  41     typedef typename _Iterator::iterator_category iterator_category;
  42     typedef typename _Iterator::value_type value_type;
  43     typedef typename _Iterator::difference_type difference_type;
  44     typedef typename _Iterator::pointer pointer;
  45     typedef typename _Iterator::reference reference;
  46   };
  47   template < typename _Tp > struct iterator_traits <_Tp * >
  48   {
  49     typedef random_access_iterator_tag iterator_category;
  50     typedef _Tp value_type;
  51     typedef ptrdiff_t difference_type;
  52     typedef _Tp *pointer;
  53     typedef _Tp & reference;
  54   };
  55   template < typename _Tp > struct iterator_traits <const _Tp *>
  56   {
  57     typedef random_access_iterator_tag iterator_category;
  58     typedef _Tp value_type;
  59     typedef ptrdiff_t difference_type;
  60     typedef const _Tp *pointer;
  61     typedef const _Tp & reference;
  62   };
  63   template < typename _Iter > inline typename iterator_traits <
  64     _Iter >::iterator_category __iterator_category (const _Iter &)
  65   {
  66     return typename iterator_traits < _Iter >::iterator_category ();
  67   }
  68 }
  69
  70 namespace std __attribute__ ((__visibility__ ("default")))
  71 {
  72 template < typename _Iterator > class reverse_iterator:public iterator < typename iterator_traits < _Iterator >::iterator_category,
  73     typename iterator_traits < _Iterator >::value_type,
  74     typename iterator_traits < _Iterator >::difference_type,
  75     typename iterator_traits < _Iterator >::pointer,
  76     typename iterator_traits < _Iterator >::reference >
  77   {
  78   protected:_Iterator current;
  79     typedef iterator_traits < _Iterator > __traits_type;
  80   public:typedef _Iterator iterator_type;
  81     typedef typename __traits_type::difference_type difference_type;
  82     typedef typename __traits_type::pointer pointer;
  83     typedef typename __traits_type::reference reference;
  84   reverse_iterator ():current ()
  85     {
  86     } explicit reverse_iterator (iterator_type __x):current (__x)
  87     {
  88     } reverse_iterator (const reverse_iterator & __x):current (__x.current)
  89     {
  90     } template < typename _Iter > reverse_iterator (const reverse_iterator <
  91                                                     _Iter >
  92                                                     &__x):current (__x.
  93                                                                    base ())
  94     {
  95     } iterator_type base () const
  96     {
  97       return current;
  98     }
  99     reference operator* () const
 100     {
 101       _Iterator __tmp = current;
 102         return *--__tmp;
 103     }
 104     pointer operator-> () const
 105     {
 106       return &(operator* ());
 107     }
 108     reverse_iterator & operator++ ()
 109     {
 110       --current;
 111       return *this;
 112     }
 113     reverse_iterator operator++ (int)
 114     {
 115       reverse_iterator __tmp = *this;
 116       --current;
 117       return __tmp;
 118     }
 119     reverse_iterator & operator-- ()
 120     {
 121       ++current;
 122       return *this;
 123     }
 124     reverse_iterator operator-- (int)
 125     {
 126       reverse_iterator __tmp = *this;
 127       ++current;
 128       return __tmp;
 129     }
 130     reverse_iterator operator+ (difference_type __n) const
 131     {
 132       return reverse_iterator (current - __n);
 133     }
 134     reverse_iterator & operator+= (difference_type __n)
 135     {
 136       current -= __n;
 137       return *this;
 138     }
 139     reverse_iterator operator- (difference_type __n) const
 140     {
 141       return reverse_iterator (current + __n);
 142     }
 143     reverse_iterator & operator-= (difference_type __n)
 144     {
 145       current += __n;
 146       return *this;
 147     }
 148     reference operator[] (difference_type __n) const
 149     {
 150       return *(*this + __n);
 151     }
 152   };
 153   template < typename _Iterator >
 154     inline bool operator== (const reverse_iterator < _Iterator > &__x,
 155                             const reverse_iterator < _Iterator > &__y)
 156   {
 157     return __x.base () == __y.base ();
 158   }
 159   template < typename _Iterator >
 160     inline bool operator< (const reverse_iterator < _Iterator > &__x,
 161                            const reverse_iterator < _Iterator > &__y)
 162   {
 163     return __y.base () < __x.base ();
 164   }
 165   template < typename _Iterator >
 166     inline bool operator!= (const reverse_iterator < _Iterator > &__x,
 167                             const reverse_iterator < _Iterator > &__y)
 168   {
 169     return !(__x == __y);
 170   }
 171   template < typename _Iterator >
 172     inline bool operator> (const reverse_iterator < _Iterator > &__x,
 173                            const reverse_iterator < _Iterator > &__y)
 174   {
 175     return __y < __x;
 176   }
 177   template < typename _Iterator >
 178     inline bool operator<= (const reverse_iterator < _Iterator > &__x,
 179                             const reverse_iterator < _Iterator > &__y)
 180   {
 181     return !(__y < __x);
 182   }
 183   template < typename _Iterator >
 184     inline bool operator>= (const reverse_iterator < _Iterator > &__x,
 185                             const reverse_iterator < _Iterator > &__y)
 186   {
 187     return !(__x < __y);
 188   }
 189   template < typename _Iterator > inline typename reverse_iterator <
 190     _Iterator >::difference_type operator- (const reverse_iterator <
 191                                             _Iterator > &__x,
 192                                             const reverse_iterator <
 193                                             _Iterator > &__y)
 194   {
 195     return __y.base () - __x.base ();
 196   }
 197   template < typename _Iterator > inline reverse_iterator < _Iterator >
 198     operator+ (typename reverse_iterator < _Iterator >::difference_type __n,
 199                const reverse_iterator < _Iterator > &__x)
 200   {
 201     return reverse_iterator < _Iterator > (__x.base () - __n);
 202   }
 203   template < typename _IteratorL,
 204     typename _IteratorR > inline bool operator== (const reverse_iterator <
 205                                                   _IteratorL > &__x,
 206                                                   const reverse_iterator <
 207                                                   _IteratorR > &__y)
 208   {
 209     return __x.base () == __y.base ();
 210   }
 211   template < typename _IteratorL,
 212     typename _IteratorR > inline bool operator< (const reverse_iterator <
 213                                                  _IteratorL > &__x,
 214                                                  const reverse_iterator <
 215                                                  _IteratorR > &__y)
 216   {
 217     return __y.base () < __x.base ();
 218   }
 219   template < typename _IteratorL,
 220     typename _IteratorR > inline bool operator!= (const reverse_iterator <
 221                                                   _IteratorL > &__x,
 222                                                   const reverse_iterator <
 223                                                   _IteratorR > &__y)
 224   {
 225     return !(__x == __y);
 226   }
 227   template < typename _IteratorL,
 228     typename _IteratorR > inline bool operator> (const reverse_iterator <
 229                                                  _IteratorL > &__x,
 230                                                  const reverse_iterator <
 231                                                  _IteratorR > &__y)
 232   {
 233     return __y < __x;
 234   }
 235   template < typename _IteratorL,
 236     typename _IteratorR > inline bool operator<= (const reverse_iterator <
 237                                                   _IteratorL > &__x,
 238                                                   const reverse_iterator <
 239                                                   _IteratorR > &__y)
 240   {
 241     return !(__y < __x);
 242   }
 243   template < typename _IteratorL,
 244     typename _IteratorR > inline bool operator>= (const reverse_iterator <
 245                                                   _IteratorL > &__x,
 246                                                   const reverse_iterator <
 247                                                   _IteratorR > &__y)
 248   {
 249     return !(__x < __y);
 250   }
 251   template < typename _IteratorL,
 252     typename _IteratorR > inline typename reverse_iterator <
 253     _IteratorL >::difference_type operator- (const reverse_iterator <
 254                                              _IteratorL > &__x,
 255                                              const reverse_iterator <
 256                                              _IteratorR > &__y)
 257   {
 258     return __y.base () - __x.base ();
 259   }
 260 template < typename _Container > class back_insert_iterator:public iterator < output_iterator_tag, void, void, void,
 261     void >
 262   {
 263   protected:_Container * container;
 264   public:typedef _Container container_type;
 265     explicit back_insert_iterator (_Container & __x):container (&__x)
 266     {
 267     } back_insert_iterator & operator= (typename _Container::
 268                                         const_reference __value)
 269     {
 270       container->push_back (__value);
 271       return *this;
 272     }
 273     back_insert_iterator & operator* ()
 274     {
 275       return *this;
 276     }
 277     back_insert_iterator & operator++ ()
 278     {
 279       return *this;
 280     }
 281     back_insert_iterator operator++ (int)
 282     {
 283       return *this;
 284     }
 285   };
 286   template < typename _Container > inline back_insert_iterator < _Container >
 287     back_inserter (_Container & __x)
 288   {
 289     return back_insert_iterator < _Container > (__x);
 290   }
 291 template < typename _Container > class front_insert_iterator:public iterator < output_iterator_tag, void, void, void,
 292     void >
 293   {
 294   protected:_Container * container;
 295   public:typedef _Container container_type;
 296     explicit front_insert_iterator (_Container & __x):container (&__x)
 297     {
 298     } front_insert_iterator & operator= (typename _Container::
 299                                          const_reference __value)
 300     {
 301       container->push_front (__value);
 302       return *this;
 303     }
 304     front_insert_iterator & operator* ()
 305     {
 306       return *this;
 307     }
 308     front_insert_iterator & operator++ ()
 309     {
 310       return *this;
 311     }
 312     front_insert_iterator operator++ (int)
 313     {
 314       return *this;
 315     }
 316   };
 317   template < typename _Container > inline front_insert_iterator < _Container >
 318     front_inserter (_Container & __x)
 319   {
 320     return front_insert_iterator < _Container > (__x);
 321   }
 322 template < typename _Container > class insert_iterator:public iterator < output_iterator_tag, void, void, void,
 323     void >
 324   {
 325   protected:_Container * container;
 326     typename _Container::iterator iter;
 327   public:typedef _Container container_type;
 328       insert_iterator (_Container & __x,
 329                        typename _Container::iterator __i):container (&__x),
 330       iter (__i)
 331     {
 332     } insert_iterator & operator= (typename _Container::
 333                                    const_reference __value)
 334     {
 335       iter = container->insert (iter, __value);
 336       ++iter;
 337       return *this;
 338     }
 339     insert_iterator & operator* ()
 340     {
 341       return *this;
 342     }
 343     insert_iterator & operator++ ()
 344     {
 345       return *this;
 346     }
 347     insert_iterator & operator++ (int)
 348     {
 349       return *this;
 350     }
 351   };
 352   template < typename _Container,
 353     typename _Iterator > inline insert_iterator < _Container >
 354     inserter (_Container & __x, _Iterator __i)
 355   {
 356     return insert_iterator < _Container > (__x,
 357                                            typename _Container::
 358                                            iterator (__i));
 359   }
 360 }
 361
 362 namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
 363 {
 364   using std::size_t;
 365   using std::ptrdiff_t;
 366   template < typename _Tp > class new_allocator
 367   {
 368   public:typedef size_t size_type;
 369     typedef ptrdiff_t difference_type;
 370     typedef _Tp *pointer;
 371     typedef const _Tp *const_pointer;
 372     typedef _Tp & reference;
 373     typedef const _Tp & const_reference;
 374     typedef _Tp value_type;
 375     template < typename _Tp1 > struct rebind
 376     {
 377       typedef new_allocator < _Tp1 > other;
 378     };
 379     new_allocator ()throw ()
 380     {
 381     } new_allocator (const new_allocator &) throw ()
 382     {
 383     } template < typename _Tp1 > new_allocator (const new_allocator < _Tp1 >
 384                                                 &) throw ()
 385     {
 386     } ~new_allocator ()throw ()
 387     {
 388     } pointer address (reference __x) const
 389     {
 390       return &__x;
 391     }
 392     const_pointer address (const_reference __x) const
 393     {
 394       return &__x;
 395     }
 396     pointer allocate (size_type __n, const void * = 0)
 397     {
 398       return static_cast < _Tp * >(::operator  new (__n * sizeof (_Tp)));
 399     }
 400     void deallocate (pointer __p, size_type)
 401     {
 402       ::operator  delete (__p);
 403     } size_type max_size () const throw ()
 404     {
 405       return size_t (-1) / sizeof (_Tp);
 406     }
 407     void construct (pointer __p, const _Tp & __val)
 408     {
 409       ::new ((void *) __p) _Tp (__val);
 410     } void destroy (pointer __p)
 411     {
 412       __p->~_Tp ();
 413   }};
 414   template < typename _Tp > inline bool operator== (const new_allocator <
 415                                                     _Tp > &,
 416                                                     const new_allocator <
 417                                                     _Tp > &)
 418   {
 419     return true;
 420   }
 421   template < typename _Tp > inline bool operator!= (const new_allocator <
 422                                                     _Tp > &,
 423                                                     const new_allocator <
 424                                                     _Tp > &)
 425   {
 426     return false;
 427   }
 428 }
 429
 430 namespace std __attribute__ ((__visibility__ ("default")))
 431 {
 432   template < typename _Tp > class allocator;
 433   template <> class allocator < void >
 434   {
 435   public:typedef size_t size_type;
 436     typedef ptrdiff_t difference_type;
 437     typedef void *pointer;
 438     typedef const void *const_pointer;
 439     typedef void value_type;
 440       template < typename _Tp1 > struct rebind
 441     {
 442       typedef allocator < _Tp1 > other;
 443     };
 444   };
 445 template < typename _Tp > class allocator:public __gnu_cxx::new_allocator <
 446     _Tp >
 447   {
 448   public:typedef size_t size_type;
 449     typedef ptrdiff_t difference_type;
 450     typedef _Tp *pointer;
 451     typedef const _Tp *const_pointer;
 452     typedef _Tp & reference;
 453     typedef const _Tp & const_reference;
 454     typedef _Tp value_type;
 455     template < typename _Tp1 > struct rebind
 456     {
 457       typedef allocator < _Tp1 > other;
 458     };
 459     allocator ()throw ()
 460     {
 461     } allocator (const allocator & __a) throw ():__gnu_cxx::new_allocator <
 462       _Tp > (__a)
 463     {
 464     } template < typename _Tp1 > allocator (const allocator < _Tp1 >
 465                                             &) throw ()
 466     {
 467     } ~allocator ()throw ()
 468     {
 469   }};
 470   template < typename _T1,
 471     typename _T2 > inline bool operator== (const allocator < _T1 > &,
 472                                            const allocator < _T2 > &)
 473   {
 474     return true;
 475   }
 476   template < typename _Tp > inline bool operator== (const allocator < _Tp > &,
 477                                                     const allocator < _Tp > &)
 478   {
 479     return true;
 480   }
 481   template < typename _T1,
 482     typename _T2 > inline bool operator!= (const allocator < _T1 > &,
 483                                            const allocator < _T2 > &)
 484   {
 485     return false;
 486   }
 487   template < typename _Tp > inline bool operator!= (const allocator < _Tp > &,
 488                                                     const allocator < _Tp > &)
 489   {
 490     return false;
 491   }
 492   template < typename _Alloc, bool = __is_empty (_Alloc) > struct __alloc_swap
 493   {
 494     static void _S_do_it (_Alloc &, _Alloc &)
 495     {
 496   }};
 497   template < typename _Alloc > struct __alloc_swap <_Alloc, false >
 498   {
 499     static void _S_do_it (_Alloc & __one, _Alloc & __two)
 500     {
 501       if (__one != __two)
 502         swap (__one, __two);
 503     }
 504   };
 505   template < typename _Alloc, bool = __is_empty (_Alloc) > struct __alloc_neq
 506   {
 507     static bool _S_do_it (const _Alloc &, const _Alloc &)
 508     {
 509       return false;
 510     }
 511   };
 512   template < typename _Alloc > struct __alloc_neq <_Alloc, false >
 513   {
 514     static bool _S_do_it (const _Alloc & __one, const _Alloc & __two)
 515     {
 516       return __one != __two;
 517     }
 518   };
 519 }
 520
 521 namespace std __attribute__ ((__visibility__ ("default")))
 522 {
 523   struct _List_node_base
 524   {
 525     _List_node_base *_M_next;
 526     _List_node_base *_M_prev;
 527     static void swap (_List_node_base & __x, _List_node_base & __y) throw ();
 528     void _M_transfer (_List_node_base * const __first,
 529                       _List_node_base * const __last) throw ();
 530     void _M_reverse () throw ();
 531     void _M_hook (_List_node_base * const __position) throw ();
 532     void _M_unhook () throw ();
 533   };
 534   template < typename _Tp > struct _List_node:public _List_node_base
 535   {
 536     _Tp _M_data;
 537   };
 538   template < typename _Tp > struct _List_iterator
 539   {
 540     typedef _List_iterator < _Tp > _Self;
 541     typedef _List_node < _Tp > _Node;
 542     typedef ptrdiff_t difference_type;
 543     typedef std::bidirectional_iterator_tag iterator_category;
 544     typedef _Tp value_type;
 545     typedef _Tp *pointer;
 546     typedef _Tp & reference;
 547       _List_iterator ():_M_node ()
 548     {
 549     } explicit _List_iterator (_List_node_base * __x):_M_node (__x)
 550     {
 551     } reference operator* () const
 552     {
 553       return static_cast < _Node * >(_M_node)->_M_data;
 554     }
 555     pointer operator-> () const
 556     {
 557       return &static_cast < _Node * >(_M_node)->_M_data;
 558     }
 559     _Self & operator++ ()
 560     {
 561       _M_node = _M_node->_M_next;
 562       return *this;
 563     }
 564     _Self operator++ (int)
 565     {
 566       _Self __tmp = *this;
 567       _M_node = _M_node->_M_next;
 568       return __tmp;
 569     }
 570     _Self & operator-- ()
 571     {
 572       _M_node = _M_node->_M_prev;
 573       return *this;
 574     }
 575     _Self operator-- (int)
 576     {
 577       _Self __tmp = *this;
 578       _M_node = _M_node->_M_prev;
 579       return __tmp;
 580     }
 581     bool operator== (const _Self & __x) const
 582     {
 583       return _M_node == __x._M_node;
 584     }
 585     bool operator!= (const _Self & __x) const
 586     {
 587       return _M_node != __x._M_node;
 588     }
 589     _List_node_base *_M_node;
 590   };
 591   template < typename _Tp > struct _List_const_iterator
 592   {
 593     typedef _List_const_iterator < _Tp > _Self;
 594     typedef const _List_node < _Tp > _Node;
 595     typedef _List_iterator < _Tp > iterator;
 596     typedef ptrdiff_t difference_type;
 597     typedef std::bidirectional_iterator_tag iterator_category;
 598     typedef _Tp value_type;
 599     typedef const _Tp *pointer;
 600     typedef const _Tp & reference;
 601       _List_const_iterator ():_M_node ()
 602     {
 603     } explicit _List_const_iterator (const _List_node_base *
 604                                      __x):_M_node (__x)
 605     {
 606     } _List_const_iterator (const iterator & __x):_M_node (__x._M_node)
 607     {
 608     } reference operator* () const
 609     {
 610       return static_cast < _Node * >(_M_node)->_M_data;
 611     }
 612     pointer operator-> () const
 613     {
 614       return &static_cast < _Node * >(_M_node)->_M_data;
 615     }
 616     _Self & operator++ ()
 617     {
 618       _M_node = _M_node->_M_next;
 619       return *this;
 620     }
 621     _Self operator++ (int)
 622     {
 623       _Self __tmp = *this;
 624       _M_node = _M_node->_M_next;
 625       return __tmp;
 626     }
 627     _Self & operator-- ()
 628     {
 629       _M_node = _M_node->_M_prev;
 630       return *this;
 631     }
 632     _Self operator-- (int)
 633     {
 634       _Self __tmp = *this;
 635       _M_node = _M_node->_M_prev;
 636       return __tmp;
 637     }
 638     bool operator== (const _Self & __x) const
 639     {
 640       return _M_node == __x._M_node;
 641     }
 642     bool operator!= (const _Self & __x) const
 643     {
 644       return _M_node != __x._M_node;
 645     }
 646     const _List_node_base *_M_node;
 647   };
 648   template < typename _Tp, typename _Alloc > class _List_base
 649   {
 650   protected:typedef typename _Alloc::template rebind < _List_node < _Tp >
 651       >::other _Node_alloc_type;
 652     typedef typename _Alloc::template rebind < _Tp >::other _Tp_alloc_type;
 653     struct _List_impl:public _Node_alloc_type
 654     {
 655       _List_node_base _M_node;
 656         _List_impl ():_Node_alloc_type (), _M_node ()
 657       {
 658       } _List_impl (const _Node_alloc_type & __a):_Node_alloc_type (__a),
 659         _M_node ()
 660       {
 661     }};
 662     _List_impl _M_impl;
 663     _List_node < _Tp > *_M_get_node ()
 664     {
 665       return _M_impl._Node_alloc_type::allocate (1);
 666     }
 667     void _M_put_node (_List_node < _Tp > *__p)
 668     {
 669       _M_impl._Node_alloc_type::deallocate (__p, 1);
 670   } public:typedef _Alloc allocator_type;
 671     _Node_alloc_type & _M_get_Node_allocator ()
 672     {
 673       return *static_cast < _Node_alloc_type * >(&this->_M_impl);
 674     }
 675     const _Node_alloc_type & _M_get_Node_allocator () const
 676     {
 677       return *static_cast < const _Node_alloc_type *>(&this->_M_impl);
 678     } _Tp_alloc_type _M_get_Tp_allocator () const
 679     {
 680       return _Tp_alloc_type (_M_get_Node_allocator ());
 681     }
 682     allocator_type get_allocator () const
 683     {
 684       return allocator_type (_M_get_Node_allocator ());
 685     }
 686     _List_base ():_M_impl ()
 687     {
 688       _M_init ();
 689     }
 690   _List_base (const allocator_type & __a):_M_impl (__a)
 691     {
 692       _M_init ();
 693     } ~_List_base ()
 694     {
 695       _M_clear ();
 696     } void _M_clear ();
 697     void _M_init ()
 698     {
 699       this->_M_impl._M_node._M_next = &this->_M_impl._M_node;
 700       this->_M_impl._M_node._M_prev = &this->_M_impl._M_node;
 701   }};
 702 template < typename _Tp, typename _Alloc = std::allocator < _Tp > >class list:protected _List_base < _Tp,
 703     _Alloc
 704     >
 705   {
 706     typedef typename _Alloc::value_type _Alloc_value_type;
 707     typedef _List_base < _Tp, _Alloc > _Base;
 708     typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
 709   public:typedef _Tp value_type;
 710     typedef typename _Tp_alloc_type::pointer pointer;
 711     typedef typename _Tp_alloc_type::const_pointer const_pointer;
 712     typedef typename _Tp_alloc_type::reference reference;
 713     typedef typename _Tp_alloc_type::const_reference const_reference;
 714     typedef _List_iterator < _Tp > iterator;
 715     typedef _List_const_iterator < _Tp > const_iterator;
 716     typedef std::reverse_iterator < const_iterator > const_reverse_iterator;
 717     typedef std::reverse_iterator < iterator > reverse_iterator;
 718     typedef size_t size_type;
 719     typedef ptrdiff_t difference_type;
 720     typedef _Alloc allocator_type;
 721   protected:typedef _List_node < _Tp > _Node;
 722     using _Base::_M_impl;
 723     using _Base::_M_put_node;
 724     using _Base::_M_get_node;
 725     using _Base::_M_get_Tp_allocator;
 726     using _Base::_M_get_Node_allocator;
 727   public:iterator begin ()
 728     {
 729       return iterator (this->_M_impl._M_node._M_next);
 730     }
 731     const_iterator begin () const
 732     {
 733       return const_iterator (this->_M_impl._M_node._M_next);
 734     }
 735     iterator end ()
 736     {
 737       return iterator (&this->_M_impl._M_node);
 738     }
 739     void remove (const _Tp & __value);
 740     template < typename _Predicate > void remove_if (_Predicate);
 741     void _M_erase (iterator __position)
 742     {
 743       __position._M_node->_M_unhook ();
 744       _Node *__n = static_cast < _Node * >(__position._M_node);
 745       _M_get_Tp_allocator ().destroy (&__n->_M_data);
 746       _M_put_node (__n);
 747     } void _M_check_equal_allocators (list & __x)
 748     {
 749       if (std::__alloc_neq <
 750           typename _Base::_Node_alloc_type >::
 751           _S_do_it (_M_get_Node_allocator (), __x._M_get_Node_allocator ()));
 752     }
 753   };
 754 }
 755
 756 namespace std __attribute__ ((__visibility__ ("default")))
 757 {
 758   template < typename _Tp, typename _Alloc > void list < _Tp,
 759     _Alloc >::remove (const value_type & __value)
 760   {
 761     iterator __first = begin ();
 762     iterator __last = end ();
 763     iterator __extra = __last;
 764     while (__first != __last)
 765       {
 766         iterator __next = __first;
 767         ++__next;
 768         if (*__first == __value)
 769           {
 770             if (&*__first != &__value)
 771               _M_erase (__first);
 772             else
 773               __extra = __first;
 774           }
 775         __first = __next;
 776       }
 777     if (__extra != __last)
 778       _M_erase (__extra);
 779   }
 780 }
 781
 782 class Unit
 783 {
 784 public:int dummy;
 785 };
 786 class Building
 787 {
 788 public:__attribute__ ((transaction_callable)) void removeUnitFromInside (Unit *
 789                                                                     unit);
 790     std::list < Unit * >unitsInside;
 791 };
 792 void
 793 Building::removeUnitFromInside (Unit * unit)
 794 {
 795   unitsInside.remove (unit);
 796 }