1// { dg-do compile { target c++11 } } 2 3typedef __SIZE_TYPE__ size_t; 4namespace std __attribute__ ((__visibility__ ("default"))) { 5 using ::size_t; 6 void __throw_bad_function_call() __attribute__((__noreturn__)); 7} 8inline void* operator new(std::size_t, void* __p) throw() { 9 return __p; 10} 11namespace std { 12 class type_info { 13 public: 14 bool operator==(const type_info& __arg) const { } 15 }; 16 namespace tr1 { 17 template<typename _Tp, _Tp __v> struct integral_constant { }; 18 typedef integral_constant<bool, true> true_type; 19 template<typename _Res, typename... _ArgTypes> 20 struct _Maybe_unary_or_binary_function { }; 21 class _Undefined_class; 22 union _Nocopy_types { 23 void (_Undefined_class::*_M_member_pointer)(); 24 }; 25 union _Any_data { 26 void* _M_access() { 27 return &_M_pod_data[0]; 28 } 29 char _M_pod_data[sizeof(_Nocopy_types)]; 30 }; 31 enum _Manager_operation { __get_type_info, __get_functor_ptr, __clone_functor, __destroy_functor }; 32 template<typename _Tp> struct _Simple_type_wrapper { 33 _Simple_type_wrapper(_Tp __value) : __value(__value) { } 34 _Tp __value; 35 }; 36 template<typename _Signature> class function; 37 class _Function_base { 38 public: 39 static const std::size_t _M_max_size = sizeof(_Nocopy_types); 40 static const std::size_t _M_max_align = __alignof__(_Nocopy_types); 41 template<typename _Functor> class _Base_manager { 42 static const bool __stored_locally = (sizeof(_Functor) <= _M_max_size && __alignof__(_Functor) <= _M_max_align && (_M_max_align % __alignof__(_Functor) == 0)); 43 typedef integral_constant<bool, __stored_locally> _Local_storage; 44 public: 45 static bool _M_manager(_Any_data& __dest, const _Any_data& __source, _Manager_operation __op) { } 46 static void _M_init_functor(_Any_data& __functor, const _Functor& __f) { 47 _M_init_functor(__functor, __f, _Local_storage()); 48 } 49 template<typename _Class, typename _Tp> static bool _M_not_empty_function(_Tp _Class::* const& __mp) { 50 return __mp; 51 } 52 static void _M_init_functor(_Any_data& __functor, const _Functor& __f, true_type) { 53 new (__functor._M_access()) _Functor(__f); 54 } 55 }; 56 ~_Function_base() { 57 if (_M_manager) _M_manager(_M_functor, _M_functor, __destroy_functor); 58 } 59 bool _M_empty() const { 60 return !_M_manager; 61 } 62 typedef bool (*_Manager_type)(_Any_data&, const _Any_data&, _Manager_operation); 63 _Any_data _M_functor; 64 _Manager_type _M_manager; 65 }; 66 template<typename _Signature, typename _Functor> class _Function_handler; 67 template<typename _Class, typename _Member, typename _Res, typename... _ArgTypes> class _Function_handler<_Res(_ArgTypes...), _Member _Class::*> : public _Function_handler<void(_ArgTypes...), _Member _Class::*> { 68 public: 69 static _Res _M_invoke(const _Any_data& __functor, _ArgTypes... __args) { } 70 }; 71 template<typename _Class, typename _Member, typename... _ArgTypes> class _Function_handler<void(_ArgTypes...), _Member _Class::*> : public _Function_base::_Base_manager< _Simple_type_wrapper< _Member _Class::* > > { }; 72 template<typename _Res, typename... _ArgTypes> class function<_Res(_ArgTypes...)> : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>, private _Function_base { 73 typedef _Res _Signature_type(_ArgTypes...); 74 struct _Useless { }; 75 public: 76 template<typename _Functor> function(_Functor __f, _Useless = _Useless()); 77 _Res operator()(_ArgTypes... __args) const; 78 const type_info& target_type() const; 79 typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...); 80 _Invoker_type _M_invoker; 81 }; 82 template<typename _Res, typename... _ArgTypes> template<typename _Functor> function<_Res(_ArgTypes...)>:: function(_Functor __f, _Useless) : _Function_base() { 83 typedef _Function_handler<_Signature_type, _Functor> _My_handler; 84 if (_My_handler::_M_not_empty_function(__f)) { 85 _M_invoker = &_My_handler::_M_invoke; 86 _M_manager = &_My_handler::_M_manager; 87 _My_handler::_M_init_functor(_M_functor, __f); 88 } 89 } 90 template<typename _Res, typename... _ArgTypes> _Res function<_Res(_ArgTypes...)>:: operator()(_ArgTypes... __args) const { 91 if (_M_empty()) { 92 __throw_bad_function_call(); 93 } 94 return _M_invoker(_M_functor, __args...); 95 } 96 template<typename _Res, typename... _ArgTypes> const type_info& function<_Res(_ArgTypes...)>:: target_type() const { 97 if (_M_manager) { 98 _Any_data __typeinfo_result; 99 _M_manager(__typeinfo_result, _M_functor, __get_type_info); 100 } 101 } 102 } 103} 104struct X { 105 int bar; 106}; 107void test05() { 108 using std::tr1::function; 109 X x; 110 function<int(X&)> frm(&X::bar); 111 frm(x) == 17; 112 typeid(int X::*) == frm.target_type(); 113} 114