1// { dg-do compile }
2// { dg-options "-w" }
3
4class iplugin_factory;
5class idocument_plugin_factory {
6  virtual idocument_plugin_factory *create_plugin(iplugin_factory &, int &);
7};
8template <typename _Iterator, typename> class __normal_iterator {
9  _Iterator _M_current;
10
11public:
12  _Iterator iterator_type;
13  __normal_iterator(const _Iterator &p1) : _M_current(p1) {}
14  void operator++();
15  _Iterator &base() { return _M_current; }
16};
17
18template <typename _IteratorL, typename _IteratorR, typename _Container>
19int operator!=(__normal_iterator<_IteratorL, _Container> &p1,
20               __normal_iterator<_IteratorR, _Container> &p2) {
21  return p1.base() != p2.base();
22}
23
24class new_allocator {
25public:
26  typedef int *const_pointer;
27  int *allocate();
28};
29template <typename> class allocator : public new_allocator {};
30
31class basic_string {
32public:
33  basic_string(char *);
34};
35struct __uninitialized_copy {
36  template <typename _InputIterator, typename _ForwardIterator>
37  static _ForwardIterator __uninit_copy(_InputIterator p1, _InputIterator p2,
38                                        _ForwardIterator p3) try {
39    for (; p1 != p2; ++p1, ++p3)
40      ;
41    return p3;
42  }
43  catch (...) {
44  }
45};
46
47template <typename _InputIterator, typename _ForwardIterator>
48_ForwardIterator uninitialized_copy(_InputIterator p1, _InputIterator p2,
49                                    _ForwardIterator p3) {
50  return __uninitialized_copy::__uninit_copy(p1, p2, p3);
51}
52
53template <typename _InputIterator, typename _ForwardIterator, typename _Tp>
54_ForwardIterator __uninitialized_copy_a(_InputIterator p1, _InputIterator p2,
55                                        _ForwardIterator p3, allocator<_Tp> &) {
56  return uninitialized_copy(p1, p2, p3);
57}
58
59struct _Vector_base {
60  struct _Vector_impl : allocator<int> {
61    int *_M_start;
62    int *_M_finish;
63  };
64  allocator<int> &_M_get_Tp_allocator() {}
65  _Vector_base() {}
66  _Vector_base(int p1) { _M_create_storage(p1); }
67  _Vector_impl _M_impl;
68  int *_M_allocate(int p1) { p1 ? _M_impl.allocate() : 0; }
69  void _M_create_storage(int p1) {
70    this->_M_impl._M_start = this->_M_allocate(p1);
71  }
72};
73
74class vector : _Vector_base {
75  _Vector_base _Base;
76
77public:
78  vector() {}
79  vector(const vector &p1) : _Base(p1.size()) {
80    this->_M_impl._M_finish = __uninitialized_copy_a(
81        p1.begin(), p1.end(), this->_M_impl._M_start, _M_get_Tp_allocator());
82  }
83  ~vector();
84  __normal_iterator<typename allocator<int>::const_pointer, int> begin() const {
85    return this->_M_impl._M_start;
86  }
87  __normal_iterator<typename allocator<int>::const_pointer, int> end() const {
88    return this->_M_impl._M_finish;
89  }
90  int size() const { return this->_M_impl._M_finish - this->_M_impl._M_start; }
91};
92class iplugin_factory {
93public:
94  typedef enum {
95    STABLE,
96    EXPERIMENTAL
97  } quality_t;
98};
99class plugin_factory : public iplugin_factory {
100public:
101  plugin_factory(const int &, const basic_string &, const basic_string &,
102                 const basic_string &, quality_t);
103};
104template <typename plugin_t>
105class document_plugin_factory : plugin_factory, idocument_plugin_factory {
106public:
107  document_plugin_factory(const int &p1, const basic_string &,
108                          const basic_string &, const basic_string &, quality_t)
109      : plugin_factory(0, 0, 0, 0, STABLE) {}
110  idocument_plugin_factory *create_plugin(iplugin_factory &p1, int &p2) {
111    plugin_t(p1, p2);
112  }
113};
114
115class container {
116public:
117  template <typename init_t> container(init_t &);
118};
119template <class init_t> class initializer_t : init_t {
120public:
121  initializer_t(const init_t &p1) : init_t(p1) {}
122};
123
124class composition_t {};
125template <typename lhs_t, typename rhs_t>
126const initializer_t<composition_t> operator+(const initializer_t<lhs_t> &,
127                                             const initializer_t<rhs_t> &);
128template <typename value_t> class value_initializer_t {
129public:
130  value_initializer_t(const value_t &p1) : m_value(p1) {}
131  value_t m_value;
132};
133
134template <typename value_t>
135initializer_t<value_initializer_t<value_t> > init_value(const value_t &p1) {
136  initializer_t<value_initializer_t<value_t> >(
137      value_initializer_t<value_t>(p1));
138}
139
140class name_t {};
141class label_t {};
142class description_t {};
143class owner_initializer_t {};
144template <typename owner_t>
145initializer_t<owner_initializer_t> init_owner(owner_t &);
146class set : vector {};
147class node {
148public:
149  node(iplugin_factory &, int &);
150};
151initializer_t<name_t> init_name();
152initializer_t<label_t> init_label();
153initializer_t<description_t> init_description();
154template <typename base_t> class mesh_selection_sink : base_t {
155public:
156  mesh_selection_sink(iplugin_factory &p1, int &p2)
157      : base_t(p1, p2),
158        m_mesh_selection(init_owner(*this) + init_name() + init_label() +
159                         init_description() + init_value(set())) {}
160  container m_mesh_selection;
161};
162
163class selection_to_stdout : mesh_selection_sink<node> {
164public:
165  selection_to_stdout(iplugin_factory &p1, int &p2)
166      : mesh_selection_sink(p1, p2) {}
167  static iplugin_factory &get_factory() {
168    document_plugin_factory<selection_to_stdout>(0, "", 0, "",
169                                                 iplugin_factory::EXPERIMENTAL);
170  }
171};
172
173void selection_to_stdout_factory() { selection_to_stdout::get_factory(); }
174