Mercurial > hg > CbC > CbC_gcc
view gcc/testsuite/g++.dg/pr77550.C @ 144:8f4e72ab4e11
fix segmentation fault caused by nothing next cur_op to end
author | Takahiro SHIMIZU <anatofuz@cr.ie.u-ryukyu.ac.jp> |
---|---|
date | Sun, 23 Dec 2018 21:23:56 +0900 |
parents | 84e7813d76e9 |
children |
line wrap: on
line source
// { dg-do run } // { dg-options "-std=c++14 -O3" } #define enum enum __attribute((mode(SI))) namespace std { typedef int size_t; inline namespace __cxx11 {} template <typename...> using _Require = void; template <typename> using __void_t = void; template <typename, typename, template <typename...> class, typename...> struct A { using type = int; }; template <typename _Default, template <typename...> class _Op, typename... _Args> struct A<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> { using type = _Op<_Args...>; }; template <typename _Default, template <typename...> class _Op, typename... _Args> using __detected_or = A<_Default, void, _Op, _Args...>; template <typename _Default, template <typename...> class _Op, typename... _Args> using __detected_or_t = typename __detected_or<_Default, _Op, _Args...>::type; template <template <typename...> class _Default, template <typename...> class _Op, typename... _Args> using __detected_or_t_ = __detected_or_t<_Default<_Args...>, _Op, _Args...>; template <typename _InputIterator> void __distance(_InputIterator p1) { ++p1; } template <typename _InputIterator> void distance(_InputIterator p1, _InputIterator) { __distance(p1); } template <typename, typename> using __replace_first_arg_t = int; struct B { template <typename _Up> using rebind = _Up *; }; template <typename, typename> using __ptr_rebind = B; template <typename _Tp> _Tp max(_Tp p1, _Tp) { return p1; } } void *operator new(__SIZE_TYPE__, void *p2) { return p2; } template <typename _Tp> struct C { typedef _Tp *pointer; pointer allocate(int p1) { return static_cast<_Tp *>(operator new(p1 * sizeof(_Tp))); } template <typename _Up> void construct(_Up *p1) { new (p1) _Up; } }; namespace std { template <typename _Tp> using __allocator_base = C<_Tp>; template <typename _Tp> struct allocator : __allocator_base<_Tp> { typedef __SIZE_TYPE__ size_type; template <typename _Tp1> struct rebind { typedef allocator<_Tp1> other; }; }; struct D { template <typename _Alloc, typename _Up> using __rebind = typename _Alloc::template rebind<_Up>::other; template <typename _Tp> using __pointer = typename _Tp::pointer; template <typename _Tp> using __c_pointer = typename _Tp::const_pointer; template <typename _Tp> using __size_type = typename _Tp::size_type; }; template <typename _Alloc, typename _Up> using __alloc_rebind = __detected_or_t_<__replace_first_arg_t, D::__rebind, _Alloc, _Up>; template <typename _Alloc> struct K : D { typedef _Alloc value_type; using pointer = __detected_or_t<value_type, __pointer, _Alloc>; using const_pointer = __detected_or_t<__ptr_rebind<pointer, value_type>, __c_pointer>; using size_type = __detected_or_t<int, __size_type, _Alloc>; template <typename _Tp> using rebind_alloc = __alloc_rebind<_Alloc, _Tp>; template <typename _Tp> static _Require<> _S_construct(_Tp p1) { _Alloc __a; __a.construct(p1); } static pointer allocate(_Alloc p1, size_type p2) { return p1.allocate(p2); } template <typename _Tp, typename _Args> static auto construct(_Alloc, _Tp p2, _Args) { _S_construct(p2); } }; } template <typename _Alloc> struct O : std::K<_Alloc> { template <typename _Tp> struct rebind { typedef typename std::K<_Alloc>::template rebind_alloc<_Tp> other; }; }; namespace std { template <typename _ForwardIterator, typename _Tp, typename _Allocator> void __uninitialized_fill_a(_ForwardIterator p1, _ForwardIterator, _Tp, _Allocator p4) try { O<_Allocator>::construct(p4, p1, 0); } catch (...) { } size_t __deque_buf_size(size_t p1) { return 1 ? 512 / p1 : 0; } template <typename _Tp, typename _Ref, typename> struct F { template <typename _Up> using __ptr_to = B::rebind<_Up>; template <typename _CvTp> using __iter = F<_Tp, _CvTp &, __ptr_to<_CvTp>>; typedef __ptr_to<_Tp> _Elt_pointer; typedef __ptr_to<_Elt_pointer> _Map_pointer; _Elt_pointer _M_cur; _Elt_pointer _M_first; _Elt_pointer _M_last; _Map_pointer _M_node; F() {} F(__iter<_Tp> &p1) : _M_cur(p1._M_cur), _M_node(p1._M_node) {} _Ref operator*() { return *_M_cur; } void operator++() { _M_set_node(_M_node + 1); _M_cur = _M_first; } void _M_set_node(_Map_pointer p1) { _M_node = p1; _M_first = *p1; _M_last = _M_first; } }; template <typename _Tp, typename _Ref, typename _Ptr> int operator==(F<_Tp, _Ref, _Ptr> p1, F<_Tp, _Ref, _Ptr> p2) { return p1._M_cur == p2._M_cur; } template <typename _Tp, typename _Ref, typename _Ptr> int operator!=(F<_Tp, _Ref, _Ptr> p1, F<_Tp, _Ref, _Ptr> p2) { return !(p1 == p2); } template <typename _Tp, typename _Alloc> struct _Deque_base { typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type; typedef O<_Tp_alloc_type> _Alloc_traits; typedef typename _Alloc_traits::pointer _Ptr; typedef typename _Alloc_traits::template rebind<_Ptr>::other _Map_alloc_type; typedef F<_Tp, _Tp &, _Ptr> iterator; typedef F<_Tp, _Tp &, typename _Alloc_traits::const_pointer> const_iterator; _Deque_base(_Alloc p1, size_t) : _M_impl(p1) { _M_initialize_map(0); } ~_Deque_base() noexcept; typedef typename iterator::_Map_pointer _Map_pointer; struct L : _Tp_alloc_type { _Map_pointer _M_map; size_t _M_map_size; iterator _M_start; iterator _M_finish; L(_Tp_alloc_type) {} }; _Tp_alloc_type _M_get_Tp_allocator() { return _M_impl; } _Ptr _M_allocate_node() { return O<_Tp_alloc_type>::allocate(_M_impl, 1); } _Map_pointer _M_allocate_map(size_t p1) { _Map_alloc_type __map_alloc; return O<_Map_alloc_type>::allocate(__map_alloc, p1); } void _M_initialize_map(size_t); void _M_create_nodes(_Map_pointer, _Map_pointer); enum { _S_initial_map_size = 8 }; L _M_impl; }; template <typename _Tp, typename _Alloc> _Deque_base<_Tp, _Alloc>::~_Deque_base() noexcept {} template <typename _Tp, typename _Alloc> void _Deque_base<_Tp, _Alloc>::_M_initialize_map(size_t) { size_t __num_nodes(__deque_buf_size(sizeof(_Tp))); _M_impl._M_map_size = max((size_t)_S_initial_map_size, 0); _M_impl._M_map = _M_allocate_map(_M_impl._M_map_size); _Map_pointer __nstart(_M_impl._M_map); _Map_pointer __nfinish = __nstart + __num_nodes; try { _M_create_nodes(__nstart, __nfinish); } catch (...) { } _M_impl._M_start._M_set_node(__nstart); _M_impl._M_finish._M_set_node(__nfinish - 1); _M_impl._M_start._M_cur = _M_impl._M_start._M_first; _M_impl._M_finish._M_cur = _M_impl._M_finish._M_first; } template <typename _Tp, typename _Alloc> void _Deque_base<_Tp, _Alloc>::_M_create_nodes(_Map_pointer __nstart, _Map_pointer __nfinish) { _Map_pointer __cur; try { for (__cur = __nstart; __cur < __nfinish; ++__cur) *__cur = _M_allocate_node(); } catch (...) { } } template <typename _Tp, typename _Alloc = allocator<_Tp>> struct deque : _Deque_base<_Tp, _Alloc> { typedef _Deque_base<_Tp, _Alloc> _Base; typedef typename _Base::_Map_pointer _Map_pointer; typedef _Tp value_type; typedef typename _Base::const_iterator const_iterator; typedef size_t size_type; typedef _Alloc allocator_type; using _Base::_M_get_Tp_allocator; deque(size_type, value_type __value, allocator_type __a = allocator_type()) : _Base(__a, 0) { _M_fill_initialize(__value); } const_iterator begin() { return this->_M_impl._M_start; } const_iterator end() { return this->_M_impl._M_finish; } void _M_fill_initialize(const value_type &); }; template <typename _Container> auto begin(_Container p1) { return p1.begin(); } template <typename _Container> auto end(_Container p1) { return p1.end(); } template <typename _Container> auto cbegin(_Container p1) { return begin(p1); } template <typename _Container> auto cend(_Container p1) { return end(p1); } template <typename _Tp, typename _Alloc> void deque<_Tp, _Alloc>::_M_fill_initialize(const value_type &) { _Map_pointer __cur; try { for (__cur = this->_M_impl._M_start._M_node; __cur < this->_M_impl._M_finish._M_node; ++__cur) __uninitialized_fill_a(*__cur, *__cur, 0, _M_get_Tp_allocator()); } catch (...) { } } template <class> struct char_traits; namespace __cxx11 { template <typename _CharT, typename = char_traits<_CharT>, typename = allocator<_CharT>> struct basic_string; typedef basic_string<char> string; } template <> struct char_traits<char> { typedef char char_type; static int compare(char_type, char_type *p2, size_t p3) { return __builtin_memcmp(0, p2, p3); } }; namespace __cxx11 { template <typename, typename, typename> struct basic_string { typedef O<allocator<char>> _Alloc_traits; typedef _Alloc_traits::size_type size_type; typedef _Alloc_traits::pointer pointer; struct _Alloc_hider { _Alloc_hider(pointer, allocator<char> && = allocator<char>()); } _M_dataplus; size_type _M_string_length = 0; enum { _S_local_capacity = 15 } _M_local_buf[_S_local_capacity]; basic_string() : _M_dataplus(0) {} basic_string(const basic_string &) : _M_dataplus(0) {} size_type size() { return _M_string_length; } char *data() const { return 0; } }; //template<> basic_string<char, std::char_traits<char>, std::allocator<char>>:: //_Alloc_hider::_Alloc_hider(char*, std::allocator<char>&&) {} extern "C" void _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_Alloc_hiderC1EPcOS3_ (...) {} } template <typename _CharT> int operator==(basic_string<_CharT> &p1, const basic_string<_CharT> &p2) { return p1.size() && char_traits<_CharT>::compare(0, p2.data(), p1.size()); } } struct G { template <class Facade> static void increment(Facade p1) { p1.increment(); } }; template <class Derived> struct H { Derived derived() { return *static_cast<Derived *>(this); } void operator++() { Derived __trans_tmp_1 = derived(); G::increment(__trans_tmp_1); } }; template <class Derived> struct I { typedef H<Derived> type; }; template <class Derived, class Base> struct M : I<Derived>::type { M(Base p1) : m_iterator(p1) {} Base base() { return m_iterator; } Base &base_reference() { return m_iterator; } Base m_iterator; }; template <class, class> struct N; template <class Predicate, class Iterator> struct J { typedef M<N<Predicate, Iterator>, Iterator> type; }; template <class Predicate, class Iterator> struct N : J<Predicate, Iterator>::type { typedef typename J<Predicate, Iterator>::type super_t; N(Predicate p1, Iterator p2, Iterator p3) : super_t(p2), m_predicate(p1), m_end(p3) {} void increment() { while (this->base() != m_end && !m_predicate(*this->base())) ++this->base_reference(); } Predicate m_predicate; Iterator m_end; }; template <class Predicate, class Iterator> N<Predicate, Iterator> make_filter_iterator(Predicate p1, Iterator p2, Iterator p3) { return N<Predicate, Iterator>(p1, p2, p3); } struct Foo { std::string bar; }; int main() { std::deque<Foo> foos(0, {}); std::string test; auto p = [test](auto &foo) { return foo.bar == test; }; auto begin = make_filter_iterator(p, cbegin(foos), cend(foos)); auto end = make_filter_iterator(p, cend(foos), cend(foos)); distance(begin, end); }