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