OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [g++.dg/] [cpp0x/] [variadic98.C] - Blame information for rev 774

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 693 jeremybenn 
// PR c++/42358
2 
// { dg-do assemble }
3 
// { dg-options -std=c++0x }
4 
 
5 
typedef __PTRDIFF_TYPE__ ptrdiff_t;
6 
typedef __SIZE_TYPE__ size_t;
7 
namespace std __attribute__ ((__visibility__ ("default"))) {
8 
    using ::size_t;
9 
}
10 
namespace std __attribute__ ((__visibility__ ("default"))) {
11 
    struct __sfinae_types   {
12 
        typedef char __one;
13 
        typedef struct {
14 
        } __two;
15 
    };
16 
    template     struct integral_constant     {
17 
        static const _Tp value = __v;
18 
        typedef _Tp value_type;
19 
        typedef integral_constant<_Tp, __v> type;
20 
    };
21 
    typedef integral_constant false_type;
22 
    template     struct remove_cv;
23 
    template     struct __is_void_helper     : public false_type {
24 
    };
25 
    template     struct is_void     : public integral_constant::type>::value)>     {
26 
    };
27 
    template     struct is_array     : public false_type {
28 
    };
29 
    template     struct is_function     : public false_type {
30 
    };
31 
    template     struct extent     : public integral_constant {
32 
    };
33 
    template     struct remove_const     {
34 
        typedef _Tp type;
35 
    };
36 
    template     struct remove_volatile     {
37 
        typedef _Tp type;
38 
    };
39 
    template     struct remove_cv     {
40 
        typedef typename       remove_const::type>::type type;
41 
    };
42 
    template     struct is_lvalue_reference     : public false_type {
43 
    };
44 
    template     struct is_rvalue_reference     : public false_type {
45 
    };
46 
    template     struct is_reference     : public integral_constant::value           || is_rvalue_reference<_Tp>::value)>     {
47 
    };
48 
    template     struct remove_reference     {
49 
        typedef _Tp type;
50 
    };
51 
    template::value && !is_void<_Tp>::value>     struct __add_rvalue_reference_helper     {
52 
        typedef _Tp type;
53 
    };
54 
    template     struct add_rvalue_reference     : public __add_rvalue_reference_helper<_Tp>     {
55 
    };
56 
    template     typename add_rvalue_reference<_Tp>::type declval();
57 
    template::value || is_void<_To>::value      || is_function<_To>::value || is_array<_To>::value)>     struct __is_convertible_helper     {
58 
    };
59 
    template     struct __is_convertible_helper<_From, _To, false>     : public __sfinae_types     {
60 
        static __one __test(_To);
61 
        static __two __test(...);
62 
        static const bool __value = sizeof(__test(declval<_From>())) == 1;
63 
    };
64 
    template     struct is_convertible     : public integral_constant::__value>     {
65 
    };
66 
    template     struct enable_if     {
67 
    };
68 
    template     struct enable_if     {
69 
        typedef _Tp type;
70 
    };
71 
    template     struct identity     {
72 
        typedef _Tp type;
73 
    };
74 
    template     inline typename enable_if::value, _Tp&&>::type     forward(typename std::identity<_Tp>::type& __t)     {
75 
    }
76 
    template     inline typename enable_if::value, _Tp>::type     forward(typename std::identity<_Tp>::type __t)     {
77 
    }
78 
    template     inline typename std::remove_reference<_Tp>::type&&     move(_Tp&& __t)     {
79 
    }
80 
    template     struct pair     {
81 
        typedef _T1 first_type;
82 
        typedef _T2 second_type;
83 
        _T1 first;
84 
        _T2 second;
85 
        template::value>::type>         pair(_U1&& __x, const _T2& __y)  : first(std::forward<_U1>(__x)),    second(__y) {
86 
        }
87 
        template::value>::type>         pair(const _T1& __x, _U2&& __y)  : first(__x),    second(std::forward<_U2>(__y)) {
88 
        }
89 
        template::value          && std::is_convertible<_U2, _T2>::value>::type>         pair(_U1&& __x, _U2&& __y)  : first(std::forward<_U1>(__x)),    second(std::forward<_U2>(__y)) {
90 
        }
91 
        template         pair(pair<_U1, _U2>&& __p)  : first(std::move(__p.first)),    second(std::move(__p.second)) {
92 
        }
93 
        template         pair&         operator=(pair<_U1, _U2>&& __p)  {
94 
        }
95 
    };
96 
    struct input_iterator_tag {
97 
    };
98 
    struct output_iterator_tag {
99 
    };
100 
    struct forward_iterator_tag : public input_iterator_tag {
101 
    };
102 
    struct bidirectional_iterator_tag : public forward_iterator_tag {
103 
    };
104 
    template     struct iterator     {
105 
        typedef _Category iterator_category;
106 
        typedef _Tp value_type;
107 
        typedef _Distance difference_type;
108 
        typedef _Pointer pointer;
109 
        typedef _Reference reference;
110 
    };
111 
    template     struct iterator_traits     {
112 
        typedef typename _Iterator::iterator_category iterator_category;
113 
        typedef typename _Iterator::value_type value_type;
114 
        typedef typename _Iterator::difference_type difference_type;
115 
        typedef typename _Iterator::pointer pointer;
116 
        typedef typename _Iterator::reference reference;
117 
    };
118 
    template     inline typename iterator_traits<_Iter>::iterator_category     __iterator_category(const _Iter&)     {
119 
    }
120 
    template     inline typename iterator_traits<_InputIterator>::difference_type     __distance(_InputIterator __first, _InputIterator __last,                input_iterator_tag)     {
121 
    }
122 
    template     inline typename iterator_traits<_InputIterator>::difference_type     distance(_InputIterator __first, _InputIterator __last)     {
123 
        return std::__distance(__first, __last,         std::__iterator_category(__first));
124 
    }
125 
    template     class reverse_iterator     : public iterator::iterator_category,         typename iterator_traits<_Iterator>::value_type,         typename iterator_traits<_Iterator>::difference_type,         typename iterator_traits<_Iterator>::pointer,                       typename iterator_traits<_Iterator>::reference>     {
126 
    };
127 
    template     class back_insert_iterator     : public iterator     {
128 
    };
129 
}
130 
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
131 
    template     class new_allocator     {
132 
    public:
133 
        typedef size_t size_type;
134 
        typedef ptrdiff_t difference_type;
135 
        typedef _Tp* pointer;
136 
        typedef const _Tp* const_pointer;
137 
        typedef _Tp& reference;
138 
        typedef const _Tp& const_reference;
139 
        typedef _Tp value_type;
140 
        new_allocator() throw() {
141 
        }
142 
        new_allocator(const new_allocator&) throw() {
143 
        }
144 
        template         new_allocator(const new_allocator<_Tp1>&) throw() {
145 
        }
146 
        template         void         construct(pointer __p, _Args&&... __args)  {
147 
        }
148 
    };
149 
}
150 
namespace std __attribute__ ((__visibility__ ("default"))) {
151 
    template     class allocator: public __gnu_cxx::new_allocator<_Tp>     {
152 
    public:
153 
        typedef size_t size_type;
154 
        typedef ptrdiff_t difference_type;
155 
        typedef _Tp* pointer;
156 
        typedef const _Tp* const_pointer;
157 
        typedef _Tp& reference;
158 
        typedef const _Tp& const_reference;
159 
        typedef _Tp value_type;
160 
        template         struct rebind         {
161 
            typedef allocator<_Tp1> other;
162 
        };
163 
        allocator() throw() {
164 
        }
165 
        template         allocator(const allocator<_Tp1>&) throw() {
166 
        }
167 
    };
168 
    extern template class allocator;
169 
    extern template class allocator;
170 
    template     struct unary_function     {
171 
        typedef _Arg argument_type;
172 
        typedef _Result result_type;
173 
    };
174 
    template     struct binary_function     {
175 
        typedef _Arg1 first_argument_type;
176 
        typedef _Arg2 second_argument_type;
177 
        typedef _Result result_type;
178 
    };
179 
    template     struct less : public binary_function<_Tp, _Tp, bool>     {
180 
        bool       operator()(const _Tp& __x, const _Tp& __y) const       {
181 
        }
182 
    };
183 
    template     struct _Select1st : public unary_function<_Pair,            typename _Pair::first_type>     {
184 
        const typename _Pair::first_type&       operator()(const _Pair& __x) const       {
185 
        }
186 
    };
187 
    struct _Rb_tree_node_base   {
188 
        typedef _Rb_tree_node_base* _Base_ptr;
189 
        typedef const _Rb_tree_node_base* _Const_Base_ptr;
190 
    };
191 
    template     struct _Rb_tree_node : public _Rb_tree_node_base     {
192 
        typedef _Rb_tree_node<_Val>* _Link_type;
193 
        _Val _M_value_field;
194 
        template         _Rb_tree_node(_Args&&... __args)  : _Rb_tree_node_base(),    _M_value_field(std::forward<_Args>(__args)...) {
195 
        }
196 
    };
197 
    template     struct _Rb_tree_iterator     {
198 
        typedef _Tp value_type;
199 
        typedef _Tp& reference;
200 
        typedef _Tp* pointer;
201 
        typedef bidirectional_iterator_tag iterator_category;
202 
        typedef ptrdiff_t difference_type;
203 
        typedef _Rb_tree_iterator<_Tp> _Self;
204 
        typedef _Rb_tree_node_base::_Base_ptr _Base_ptr;
205 
        typedef _Rb_tree_node<_Tp>* _Link_type;
206 
        _Base_ptr _M_node;
207 
    };
208 
    template     struct _Rb_tree_const_iterator     {
209 
        typedef _Tp value_type;
210 
        typedef const _Tp& reference;
211 
        typedef const _Tp* pointer;
212 
        typedef _Rb_tree_iterator<_Tp> iterator;
213 
        typedef bidirectional_iterator_tag iterator_category;
214 
        typedef ptrdiff_t difference_type;
215 
        typedef _Rb_tree_const_iterator<_Tp> _Self;
216 
        typedef _Rb_tree_node_base::_Const_Base_ptr _Base_ptr;
217 
        typedef const _Rb_tree_node<_Tp>* _Link_type;
218 
        explicit       _Rb_tree_const_iterator(_Link_type __x)       : _M_node(__x) {
219 
        }
220 
        _Rb_tree_const_iterator(const iterator& __it)       : _M_node(__it._M_node) {
221 
        }
222 
        _Base_ptr _M_node;
223 
    };
224 
    template >     class _Rb_tree     {
225 
        typedef typename _Alloc::template rebind<_Rb_tree_node<_Val> >::other               _Node_allocator;
226 
        typedef _Rb_tree_node_base* _Base_ptr;
227 
        typedef const _Rb_tree_node_base* _Const_Base_ptr;
228 
    public:
229 
        typedef _Key key_type;
230 
        typedef _Val value_type;
231 
        typedef value_type* pointer;
232 
        typedef const value_type* const_pointer;
233 
        typedef value_type& reference;
234 
        typedef const value_type& const_reference;
235 
        typedef _Rb_tree_node<_Val>* _Link_type;
236 
        typedef const _Rb_tree_node<_Val>* _Const_Link_type;
237 
        typedef size_t size_type;
238 
        typedef ptrdiff_t difference_type;
239 
        typedef _Alloc allocator_type;
240 
        _Node_allocator&       _M_get_Node_allocator()       {
241 
        }
242 
        _Link_type       _M_get_node()       {
243 
        }
244 
        template         _Link_type         _M_create_node(_Args&&... __args)  {
245 
            _Link_type __tmp = _M_get_node();
246 
            try      {
247 
                _M_get_Node_allocator().construct(__tmp,           std::forward<_Args>(__args)...);
248 
            }
249 
            catch(...)      {
250 
            }
251 
        }
252 
        template         struct _Rb_tree_impl : public _Node_allocator         {
253 
            _Key_compare _M_key_compare;
254 
            _Rb_tree_node_base _M_header;
255 
            size_type _M_node_count;
256 
            _Rb_tree_impl(const _Key_compare& __comp, const _Node_allocator& __a)    : _Node_allocator(__a), _M_key_compare(__comp), _M_header(),      _M_node_count(0)    {
257 
            }
258 
            void    _M_initialize()    {
259 
            }
260 
        };
261 
        _Rb_tree_impl<_Compare> _M_impl;
262 
        _Base_ptr&       _M_rightmost()       {
263 
        }
264 
        _Link_type       _M_begin()       {
265 
        }
266 
        _Link_type       _M_end()       {
267 
        }
268 
        _Const_Link_type       _M_end() const       {
269 
        }
270 
        static _Link_type       _S_right(_Base_ptr __x)       {
271 
        }
272 
        static const_reference       _S_value(_Const_Base_ptr __x)       {
273 
        }
274 
        static const _Key&       _S_key(_Const_Base_ptr __x)       {
275 
            return _KeyOfValue()(_S_value(__x));
276 
        }
277 
        typedef _Rb_tree_iterator iterator;
278 
        typedef _Rb_tree_const_iterator const_iterator;
279 
        typedef std::reverse_iterator reverse_iterator;
280 
        typedef std::reverse_iterator const_reverse_iterator;
281 
        iterator       _M_insert_(_Const_Base_ptr __x, _Const_Base_ptr __y,    const value_type& __v);
282 
        iterator       _M_insert_lower(_Base_ptr __x, _Base_ptr __y, const value_type& __v);
283 
        iterator       _M_insert_equal_lower(const value_type& __x);
284 
        iterator       _M_lower_bound(_Link_type __x, _Link_type __y,        const _Key& __k);
285 
        iterator       _M_upper_bound(_Link_type __x, _Link_type __y,        const _Key& __k);
286 
        _Rb_tree(const _Compare& __comp,         const allocator_type& __a = allocator_type())       : _M_impl(__comp, __a) {
287 
        }
288 
        iterator       end()       {
289 
        }
290 
        iterator       _M_insert_equal_(const_iterator __position, const value_type& __x);
291 
        template         void         _M_insert_unique(_InputIterator __first, _InputIterator __last);
292 
        template         void         _M_insert_equal(_InputIterator __first, _InputIterator __last);
293 
        size_type       count(const key_type& __k) const;
294 
        pair       equal_range(const key_type& __k);
295 
        pair       equal_range(const key_type& __k) const;
296 
    };
297 
    template     typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator     _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::     _M_insert_(_Const_Base_ptr __x, _Const_Base_ptr __p, const _Val& __v)     {
298 
        _Link_type __z = _M_create_node(__v);
299 
    }
300 
    template     typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator     _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::     _M_insert_lower(_Base_ptr __x, _Base_ptr __p, const _Val& __v)     {
301 
        _Link_type __z = _M_create_node(__v);
302 
    }
303 
    template     typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator     _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::     _M_insert_equal_lower(const _Val& __v)     {
304 
        _Link_type __x = _M_begin();
305 
        _Link_type __y = _M_end();
306 
        return _M_insert_lower(__x, __y, __v);
307 
    }
308 
    template     pair::iterator,   typename _Rb_tree<_Key, _Val, _KeyOfValue,       _Compare, _Alloc>::iterator>     _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::     equal_range(const _Key& __k)     {
309 
        _Link_type __x = _M_begin();
310 
        _Link_type __y = _M_end();
311 
        while (__x != 0)  {
312 
            if (_M_impl._M_key_compare(_S_key(__x), __k))      __x = _S_right(__x);
313 
            else      {
314 
                _Link_type __xu(__x), __yu(__y);
315 
                return pair(_M_lower_bound(__x, __y, __k),         _M_upper_bound(__xu, __yu, __k));
316 
            }
317 
        }
318 
    }
319 
    template     pair::const_iterator,   typename _Rb_tree<_Key, _Val, _KeyOfValue,       _Compare, _Alloc>::const_iterator>     _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::     equal_range(const _Key& __k) const     {
320 
        _Const_Link_type __y = _M_end();
321 
        return pair(const_iterator(__y),         const_iterator(__y));
322 
    }
323 
    template     typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator     _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::     _M_insert_equal_(const_iterator __position, const _Val& __v)     {
324 
        if (__position._M_node == _M_end())  {
325 
            if (__position._M_node == _M_rightmost())      return _M_insert_(0, _M_rightmost(), __v);
326 
            else      return _M_insert_equal_lower(__v);
327 
        }
328 
    }
329 
    template     template       void       _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::       _M_insert_equal(_II __first, _II __last)       {
330 
        for (;
331 
             __first != __last;
332 
             ++__first)    _M_insert_equal_(end(), *__first);
333 
    }
334 
    template     typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type     _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::     count(const _Key& __k) const     {
335 
        pair __p = equal_range(__k);
336 
        const size_type __n = std::distance(__p.first, __p.second);
337 
    }
338 
    template     class initializer_list     {
339 
    public:
340 
        typedef _E value_type;
341 
        typedef const _E& reference;
342 
        typedef const _E& const_reference;
343 
        typedef size_t size_type;
344 
        typedef const _E* iterator;
345 
        typedef const _E* const_iterator;
346 
        iterator _M_array;
347 
        size_type _M_len;
348 
        initializer_list(const_iterator __a, size_type __l)       : _M_array(__a), _M_len(__l) {
349 
        }
350 
        const_iterator       begin() const {
351 
        }
352 
        const_iterator       end() const {
353 
        }
354 
    };
355 
    template ,      typename _Alloc = std::allocator > >     class multimap     {
356 
        typedef _Key key_type;
357 
        typedef _Tp mapped_type;
358 
        typedef std::pair value_type;
359 
        typedef _Compare key_compare;
360 
        typedef _Alloc allocator_type;
361 
        typedef typename _Alloc::value_type _Alloc_value_type;
362 
        typedef typename _Alloc::template rebind::other         _Pair_alloc_type;
363 
        typedef _Rb_tree,          key_compare, _Pair_alloc_type> _Rep_type;
364 
        _Rep_type _M_t;
365 
    public:
366 
        typedef typename _Pair_alloc_type::pointer pointer;
367 
        typedef typename _Pair_alloc_type::const_pointer const_pointer;
368 
        typedef typename _Pair_alloc_type::reference reference;
369 
        typedef typename _Pair_alloc_type::const_reference const_reference;
370 
        typedef typename _Rep_type::iterator iterator;
371 
        typedef typename _Rep_type::const_iterator const_iterator;
372 
        typedef typename _Rep_type::size_type size_type;
373 
        typedef typename _Rep_type::difference_type difference_type;
374 
        typedef typename _Rep_type::reverse_iterator reverse_iterator;
375 
        typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
376 
        multimap(initializer_list __l,         const _Compare& __comp = _Compare(),         const allocator_type& __a = allocator_type())       : _M_t(__comp, __a)       {
377 
            _M_t._M_insert_equal(__l.begin(), __l.end());
378 
        }
379 
        template         multimap(_InputIterator __first, _InputIterator __last)  : _M_t()         {
380 
        }
381 
        template         multimap(_InputIterator __first, _InputIterator __last,    const _Compare& __comp,    const allocator_type& __a = allocator_type())         : _M_t(__comp, __a)         {
382 
        }
383 
        template         void         insert(_InputIterator __first, _InputIterator __last)         {
384 
        }
385 
        size_type       count(const key_type& __x) const       {
386 
            return _M_t.count(__x);
387 
        }
388 
        std::pair       equal_range(const key_type& __x)       {
389 
            return _M_t.equal_range(__x);
390 
        }
391 
        template         friend bool         operator==(const multimap<_K1, _T1, _C1, _A1>&,      const multimap<_K1, _T1, _C1, _A1>&);
392 
        template         friend bool         operator<(const multimap<_K1, _T1, _C1, _A1>&,     const multimap<_K1, _T1, _C1, _A1>&);
393 
    };
394 
}
395 
extern "C" {
396 
    extern void __assert_fail (__const char *__assertion, __const char *__file,       unsigned int __line, __const char *__function)      throw () __attribute__ ((__noreturn__));
397 
}
398 
using namespace std;
399 
int test01() {
400 
    typedef multimap Container;
401 
    typedef Container::iterator iterator;
402 
    typedef pair itpair;
403 
    Container m({
404 
                {
405 
                1, 1.0 }
406 
                }
407 
               );
408 
    itpair ip = m.equal_range(1);
409 
    ((distance(ip.first, ip.second) == 3) ? static_cast (0) : __assert_fail ("distance(ip.first, ip.second) == 3", "/home/richard/src/trunk/libstdc++-v3/testsuite/23_containers/multimap/init-list.cc", 36, __PRETTY_FUNCTION__));
410 
    ((m.count(7) == 2) ? static_cast (0) : __assert_fail ("m.count(7) == 2", "/home/richard/src/trunk/libstdc++-v3/testsuite/23_containers/multimap/init-list.cc", 54, __PRETTY_FUNCTION__));
411 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.