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

Subversion Repositories openrisc

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 693 jeremybenn 
// PR c++/47416
2 
// { dg-do compile }
3 
// { dg-options "-std=c++0x" }
4 
 
5 
namespace std
6 
{
7 
  template < typename _Tp, _Tp __v > struct integral_constant
8 
  {
9 
    static const _Tp value = __v;
10 
  };
11 
  typedef integral_constant < bool, false > false_type;
12 
    template < typename > struct is_array:false_type
13 
  {
14 
  };
15 
    template < typename > struct is_function:false_type
16 
  {
17 
  };
18 
    template < typename _Tp > struct remove_const
19 
  {
20 
    typedef _Tp type;
21 
  };
22 
    template < typename _Tp > struct remove_volatile
23 
  {
24 
    typedef _Tp type;
25 
  };
26 
    template < typename _Tp > struct remove_cv
27 
  {
28 
    typedef typename remove_const < typename remove_volatile <
29 
      _Tp >::type >::type type;
30 
  };
31 
    template < typename > struct remove_reference
32 
  {
33 
  };
34 
    template < typename _Tp > struct remove_reference <_Tp & >
35 
  {
36 
    typedef _Tp type;
37 
  };
38 
    template < typename _Up, bool = is_array < _Up >::value, bool =
39 
    is_function < _Up >::value > struct __decay_selector;
40 
    template < typename _Up > struct __decay_selector <_Up, false, false >
41 
  {
42 
    typedef typename remove_cv < _Up >::type __type;
43 
  };
44 
    template < typename _Tp > class decay
45 
  {
46 
    typedef typename remove_reference < _Tp >::type __remove_type;
47 
  public:typedef typename __decay_selector <
48 
      __remove_type >::__type type;
49 
  };
50 
  template < typename _Tp > struct __strip_reference_wrapper
51 
  {
52 
    typedef _Tp __type;
53 
  };
54 
  template < typename _Tp > struct __decay_and_strip
55 
  {
56 
    typedef typename __strip_reference_wrapper < typename decay <
57 
      _Tp >::type >::__type __type;
58 
  };
59 
  template < typename _Tp > _Tp forward (typename remove_reference <
60 
                                         _Tp >::type &)
61 
  {
62 
  }
63 
  template < class _T1, class _T2 > struct pair
64 
  {
65 
    _T1 first;
66 
    _T2 second;
67 
    constexpr pair (_T1, _T2 &):first (), second (__b)  // { dg-error "was not declared in this scope" }
68 
    {
69 
    }
70 
  };
71 
  template < class _T1,
72 
    class _T2 > pair < typename __decay_and_strip < _T1 >::__type,
73 
    typename __decay_and_strip < _T2 >::__type > make_pair (_T1 && __x, _T2
74 
                                                            && __y)
75 
  {
76 
    typedef typename __decay_and_strip < _T1 >::__type __ds_type1;
77 
    typedef typename __decay_and_strip < _T2 >::__type __ds_type2;
78 
    typedef pair < __ds_type1, __ds_type2 > __pair_type;
79 
    __pair_type (forward < _T1 > (__x), std::forward < _T2 > (__y));
80 
  }
81 
}
82 
 
83 
typedef long size_t;
84 
namespace std
85 
{
86 
  template < typename > class allocator;
87 
  template < class > struct char_traits;
88 
    template < typename _CharT, typename = char_traits < _CharT >, typename =
89 
    allocator < _CharT > >class basic_string;
90 
  typedef basic_string < char >string;
91 
}
92 
namespace __gnu_cxx
93 
{
94 
  template < bool > class __pool;
95 
  template < template < bool > class, bool > struct __common_pool
96 
  {
97 
  };
98 
    template < template < bool > class, bool > struct __common_pool_base;
99 
    template < template < bool > class _PoolTp >
100 
    struct __common_pool_base <_PoolTp, true >:__common_pool < _PoolTp, true >
101 
  {
102 
  };
103 
    template < template < bool > class _PoolTp,
104 
    bool _Thread > struct __common_pool_policy:__common_pool_base < _PoolTp,
105 
    _Thread >
106 
  {
107 
    template < typename, template < bool > class _PoolTp1 =
108 
      _PoolTp, bool _Thread1 = _Thread > struct _M_rebind
109 
    {
110 
      typedef __common_pool_policy < _PoolTp1, _Thread1 > other;
111 
    };
112 
  };
113 
    template < typename _Tp > class __mt_alloc_base
114 
  {
115 
  };
116 
template < typename _Tp, typename _Poolp = __common_pool_policy < __pool, true > >class __mt_alloc:public __mt_alloc_base <
117 
    _Tp
118 
    >
119 
  {
120 
  public:size_t size_type;
121 
    typedef _Tp value_type;
122 
    template < typename _Tp1, typename _Poolp1 = _Poolp > struct rebind
123 
    {
124 
      typedef typename _Poolp1::template _M_rebind < _Tp1 >::other pol_type;
125 
      typedef __mt_alloc < _Tp1, pol_type > other;
126 
    };
127 
  };
128 
}
129 
 
130 
namespace std
131 
{
132 
  template < typename _Tp > class allocator:public __gnu_cxx::__mt_alloc <
133 
    _Tp >
134 
  {
135 
  };
136 
  template < typename, typename > struct unary_function
137 
  {
138 
  };
139 
  template < typename, typename, typename > struct binary_function
140 
  {
141 
  };
142 
  template < typename _Tp > struct equal_to:binary_function < _Tp, _Tp, bool >
143 
  {
144 
  };
145 
}
146 
 
147 
namespace boost
148 
{
149 
  template < class > struct hash;
150 
    template < class K, class T, class = hash < K >, class =
151 
    std::equal_to < K >, class =
152 
    std::allocator < std::pair < const K, T > >>class unordered_map;
153 
    template < >struct hash :std::unary_function < std::string,
154 
    size_t >
155 
  {
156 
  };
157 
  namespace unordered_detail
158 
  {
159 
    template < class Alloc, class T > struct rebind_wrap
160 
    {
161 
      typedef typename Alloc::template rebind < T >::other type;
162 
    };
163 
  }
164 
  namespace unordered_detail
165 
  {
166 
    size_t default_bucket_count;
167 
      template < class, class > struct map_extractor;
168 
    struct ungrouped
169 
    {
170 
    };
171 
      template < class T > class hash_table:T::buckets, T::buffered_functions
172 
    {
173 
    };
174 
      template < class, class, class H, class P, class A, class, class G > struct types
175 
    {
176 
      typedef H hasher;
177 
      typedef P key_equal;
178 
      typedef A value_allocator;
179 
    };
180 
      template < class T > class hash_unique_table:T
181 
    {
182 
    public:typedef typename T::hasher hasher;
183 
      typedef typename T::key_equal key_equal;
184 
      typedef typename T::value_allocator value_allocator;
185 
      typedef typename T::table table;
186 
        hash_unique_table (size_t n, hasher, key_equal,
187 
                           value_allocator & a):table (n, a)    // { dg-error "is not a direct base" }
188 
      {
189 
      }
190 
    };
191 
    template < class K, class H, class P, class A > struct map:types < K,
192 
      typename A::value_type, H, P, A, map_extractor < K,
193 
      typename A::value_type >, ungrouped >
194 
    {
195 
      typedef hash_unique_table < map < K, H, P, A > >impl;
196 
      typedef hash_table < map < K, H, P, A > >table;
197 
    };
198 
  }
199 
  template < class K, class T, class H, class P, class A > class unordered_map
200 
  {
201 
    typedef std::pair < const K, T > value_type;
202 
    typedef H hasher;
203 
    typedef P key_equal;
204 
    typedef A allocator_type;
205 
    typedef typename unordered_detail::rebind_wrap < allocator_type,
206 
      value_type >::type value_allocator;
207 
    typedef boost::unordered_detail::map < K, H, P, value_allocator > types;
208 
    typedef typename types::impl table;
209 
    typedef size_t size_type;
210 
  private:table table_;
211 
  public: unordered_map (size_type n = boost::unordered_detail::default_bucket_count,
212 
                         hasher hf = hasher (), key_equal eql = key_equal (),
213 
                         allocator_type a = allocator_type ()):table_ (n, hf, eql, a)   // { dg-message "required" }
214 
    {
215 
    }
216 
  };
217 
};
218 
 
219 
void
220 
foo (const int &a)
221 
{
222 
  typedef boost::unordered_map < std::string, int >Name2Port;
223 
  Name2Port b;                  // { dg-message "required" }
224 
  std::make_pair (a, b);
225 
}

powered by: WebSVN 2.1.0

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