Mercurial > hg > CbC > CbC_gcc
view gcc/testsuite/g++.dg/torture/pr53602.C @ 131:84e7813d76e9
gcc-8.2
author | mir3636 |
---|---|
date | Thu, 25 Oct 2018 07:37:49 +0900 |
parents | 04ced10e8804 |
children |
line wrap: on
line source
// { dg-do compile } // { dg-options "-std=c++11" } // { dg-additional-options "-Wno-return-type" } namespace std { template <class, class> struct pair { }; struct input_iterator_tag { }; struct forward_iterator_tag : public input_iterator_tag { }; template <typename, typename _Tp, typename = _Tp> struct iterator { }; } namespace __gnu_cxx { template <typename _Tp> struct new_allocator { typedef _Tp pointer; typedef _Tp value_type; template <typename _Tp1> struct rebind { typedef new_allocator <_Tp1> other; }; }; } namespace std { template <typename _Tp> struct allocator : public __gnu_cxx::new_allocator <_Tp> { }; } extern "C" { struct rtl_String; void rtl_string_release (rtl_String *) throw (); void rtl_string_newFromStr (rtl_String * *, const char *) throw (); } namespace std { template <typename, typename, typename> struct binary_function; template <typename _Tp> struct equal_to : public binary_function <_Tp, _Tp, bool> { }; } namespace rtl { struct OString { rtl_String * pData; OString (const char *value) { rtl_string_newFromStr (&pData, value); } ~OString () { rtl_string_release (pData); } }; struct OStringHash; } namespace boost { template <class> struct hash; namespace unordered { template <class T, class = boost::hash <T>, class = std::equal_to <T>, class = std::allocator <T>>class unordered_set; } using boost::unordered::unordered_set; namespace detail { template <bool> struct if_true { template <class, class F> struct then { typedef F type; }; }; } template <class, class> struct pointer_to_other; template <class T, class U> struct pointer_to_other <T *, U> { typedef U type; }; namespace unordered { namespace detail { template <typename T, T> struct integral_constant { }; struct choice9 { typedef char (&type)[9]; }; struct choice8:choice9 { }; struct choice7:choice8 { }; struct choice6:choice7 { }; struct choice5:choice6 { }; struct choice4:choice5 { }; struct choice3:choice4 { }; struct choice2:choice3 { }; struct choice1:choice2 { }; choice1 choose (); template <typename Alloc, typename T> struct rebind_wrap { typedef typename Alloc::template rebind <T>::other type; }; template <typename, typename T2> struct sfinae:T2 { }; template <typename Tp, typename Default> struct default_type_pointer { template <typename X> static boost::unordered::detail::sfinae <typename X::pointer, choice1> test (choice1); struct DefaultWrap { typedef Default pointer; }; enum { value = (1 == sizeof (test <Tp> (choose ()))) }; typedef typename boost::detail::if_true <value>::template then <Tp, DefaultWrap>::type::pointer type; }; template <typename Tp, typename Default> struct default_type_const_pointer { template <typename> static choice2::type test (choice2); struct DefaultWrap { }; enum { value = (1 == sizeof (test <Tp> (choose ()))) }; typedef typename boost::detail::if_true <value>::template then <Tp, DefaultWrap> type; }; struct default_type_propagate_on_container_swap { struct DefaultWrap { }; }; template <typename Alloc> struct allocator_traits { typedef typename Alloc::value_type value_type; typedef typename default_type_pointer <Alloc, value_type *>::type pointer; template <typename T> struct pointer_to_other : boost::pointer_to_other <pointer, T> { }; typedef typename default_type_const_pointer <Alloc, typename pointer_to_other <value_type>::type>::type const_pointer; }; } namespace detail { struct move_tag { }; template <typename> struct table; template <typename NodeAlloc> struct node_constructor { void construct_value () { } }; struct ptr_bucket { ptr_bucket () { } }; template <typename A, typename Bucket, typename Node> struct buckets { typedef Node node; typedef Bucket bucket; typedef typename boost::unordered::detail::rebind_wrap <A, node>::type node_allocator; typedef typename boost::unordered::detail::rebind_wrap <A, bucket>::type bucket_allocator; typedef boost::unordered::detail::allocator_traits <node_allocator> node_allocator_traits; typedef boost::unordered::detail::allocator_traits <bucket_allocator> bucket_allocator_traits; typedef typename node_allocator_traits::pointer node_pointer; typedef typename node_allocator_traits::const_pointer const_node_pointer; typedef typename bucket_allocator_traits::pointer bucket_pointer; typedef boost::unordered::detail::node_constructor <node_allocator> node_constructor; bucket_pointer buckets_; unsigned size_; template <typename Types> buckets (boost::unordered::detail::table <Types>, boost::unordered::detail::move_tag) : buckets_ (), size_ () { } }; struct functions { }; } } namespace detail { template <class Category, class T, class, class, class> struct iterator_base:std::iterator <Category, T> { }; } template <class Category, class T, class Distance, class Pointer = T, class Reference = T> struct iterator:boost::detail::iterator_base <Category, T, Distance, Pointer, Reference> { }; namespace unordered { namespace iterator_detail { template <typename, typename NodePointer, typename Value> struct c_iterator:public boost::iterator <std::forward_iterator_tag, Value, int> { friend bool operator== (c_iterator, c_iterator) { } }; } namespace detail { template <typename ValueType> struct value_base { typedef ValueType value_type; value_type value () { } }; template <typename Types> struct table:boost::unordered::detail::buckets <typename Types::allocator, typename Types::bucket, typename Types::key_equal> { typedef typename Types::value_type value_type; typedef boost::unordered::detail::buckets <typename Types::allocator, typename Types::bucket, typename Types::node> buckets; typedef typename buckets::node_pointer node_pointer; typedef typename buckets::const_node_pointer const_node_pointer; typedef boost::unordered::iterator_detail::c_iterator <const_node_pointer, node_pointer, value_type> c_iterator; unsigned max_size () { } }; template <typename> struct table_impl; template <typename T> struct ptr_node : boost::unordered::detail::value_base <T>, boost::unordered::detail::ptr_bucket { boost::unordered::detail::ptr_bucket bucket_base; unsigned hash_; ptr_node () : bucket_base (), hash_ () { } }; template <typename A, typename T, typename, typename> struct pick_node2 { }; template <typename A, typename T> struct pick_node2 <A, T, boost::unordered::detail::ptr_node <T> *, boost::unordered::detail::ptr_bucket *> { typedef boost::unordered::detail::ptr_node <T> node; typedef boost::unordered::detail::ptr_bucket bucket; }; template <typename A, typename T> struct pick_node { typedef boost::unordered::detail::allocator_traits <typename boost::unordered::detail::rebind_wrap <A, boost::unordered::detail::ptr_node <T>>::type> tentative_node_traits; typedef boost::unordered::detail::allocator_traits <typename boost::unordered::detail::rebind_wrap <A, boost::unordered::detail::ptr_bucket>::type> tentative_bucket_traits; typedef pick_node2 <A, T, typename tentative_node_traits::pointer, typename tentative_bucket_traits::pointer> pick; typedef typename pick::node node; typedef typename pick::bucket bucket; }; template <typename A, typename T, typename H, typename P> struct set { typedef boost::unordered::detail::set <A, T, H, P> types; typedef T value_type; typedef P key_equal; typedef typename boost::unordered::detail::rebind_wrap <A, value_type>::type allocator; typedef boost::unordered::detail::pick_node <allocator, value_type> pick; typedef typename pick::node node; typedef typename pick::bucket bucket; typedef boost::unordered::detail::table_impl <types> table; }; template <typename Types> struct table_impl : boost::unordered::detail::table <Types> { typedef boost::unordered::detail::table <Types> table; typedef typename table::node_constructor node_constructor; table_impl () : table () { } template <class InputIt> void insert_range_impl2 (node_constructor, InputIt) { } }; } template <class T, class H, class P, class A> struct unordered_set { typedef T key_type; typedef T value_type; typedef boost::unordered::detail::set <A, T, H, P> types; typedef typename types::table table; typedef typename table::c_iterator const_iterator; typedef typename table::c_iterator iterator; table table_; bool empty () { return table_.size_; } iterator end () { } std::pair <iterator, bool> insert (value_type) { } unsigned erase (const key_type &); const_iterator find (const key_type); }; template <class T, class H, class P, class A> unsigned unordered_set <T, H, P, A>::erase (const key_type &) { } } } using namespace::rtl; namespace skeletonmaker { void checkDefaultInterfaces (boost::unordered_set <OString, OStringHash> interfaces, boost::unordered_set <OStringHash> services, OString) { if (services.empty ()) interfaces.erase ("com.sun.star.lang.XServiceInfo"); else if (interfaces.find ("com.sun.star.lang.XServiceInfo") == interfaces.end ()) interfaces.insert ("com.sun.star.lang.XServiceInfo"); } }