pr16688.C revision 1.1.1.1 
1/* PR 16688.  Test provided by Wolfgang Bangerth.  The alias analyzer
2   was aborting when trying to group aliases.  */
3
4/* { dg-do compile } */
5/* { dg-options "-O2" } */
6
7template<typename _Tp>
8struct iterator_traits;
9
10template<typename _Tp>
11struct iterator_traits<_Tp*> {
12    typedef _Tp& reference;
13};
14
15template<typename _Iterator> struct NI {
16    _Iterator current;
17
18    typedef typename iterator_traits<_Iterator>::reference reference;
19
20    NI() { }
21
22    NI(const _Iterator& __i) : current(__i) { }
23
24    reference operator*() const { return *current; }
25
26    NI& operator++() { return *this; }
27
28    const _Iterator& base() const { return current; }
29};
30
31template<typename _IteratorL, typename _IteratorR>
32inline int
33operator-(const NI<_IteratorL>& __lhs,
34          const NI<_IteratorR>& __rhs)
35{ return __lhs.base() - __rhs.base(); }
36
37
38template<typename _II, typename _OI>
39inline _OI
40__copy_aux(_II __first, _II __last, _OI __result)
41{
42  struct __copy {
43      static _OI
44      copy(_II __first, _II __last, _OI __result)
45        {
46          for (; __first != __last; ++__result, ++__first)
47            *__result = *__first;
48          return __result;
49        }
50  };
51
52  return __copy::copy(__first, __last, __result);
53}
54
55struct __copy_normal
56{
57    template<typename _II, typename _OI>
58    static _OI
59    copy_n(_II __first, _II __last, _OI __result)
60      {
61        return __copy_aux(__first, __last, __result);
62      }
63};
64template<typename _InputIterator, typename _OutputIterator>
65inline _OutputIterator
66copy(_InputIterator __first, _InputIterator __last,
67     _OutputIterator __result)
68{
69  return __copy_normal::copy_n(__first, __last, __result);
70}
71
72template <typename T, typename U, typename V>
73void uninitialized_fill_n(T,U,V);
74
75
76template<typename _Tp>
77struct _Vector_base {
78    struct _Vector_impl {
79        _Tp* start;
80        _Tp* finish;
81        _Tp* end_of_storage;
82        _Vector_impl() : start(0), finish(0), end_of_storage(0)
83          { }
84    } impl;
85
86    _Vector_base(unsigned __n) {
87      impl.start = allocate(__n);
88      impl.finish = impl.start;
89      impl.end_of_storage = impl.start + __n;
90    }
91
92    ~_Vector_base() {
93      deallocate(impl.start,
94                    impl.end_of_storage - impl.start);
95    }
96
97    _Tp* allocate(unsigned __n);
98
99    void deallocate(_Tp* __p, unsigned __n);
100
101    NI<_Tp*> begin() { return NI<_Tp*> (impl.start); }
102};
103
104
105template<typename _Tp>
106struct vector : _Vector_base<_Tp>
107{
108    vector(int __n)
109                    : _Vector_base<_Tp>(__n)
110      {
111        uninitialized_fill_n(this->impl.start, __n, _Tp());
112      }
113};
114
115
116
117struct Tensor
118{
119    Tensor ();
120    Tensor (const Tensor &);
121
122    double values[2];
123};
124
125
126inline
127Tensor::Tensor (const Tensor &p)
128{
129  for (unsigned int i=0; i<2; ++i)
130    values[i] = p.values[i];
131}
132
133
134struct TriaAccessor
135{
136    typedef void * AccessorData;
137
138    void copy_from (const TriaAccessor &);
139    void operator = (const TriaAccessor *);
140
141    TriaAccessor & operator = (const TriaAccessor &);
142
143    bool operator == (const TriaAccessor &) const;
144
145    bool operator != (const TriaAccessor &) const;
146    void operator ++ ();
147
148    int state () const;
149    bool used () const;
150
151    int present_level;
152    int present_index;
153    int** levels;
154};
155
156inline int TriaAccessor::state () const {
157  if ((present_level>=0) && (present_index>=0))
158    return 0;
159  else
160    if ((present_level==-1) && (present_index==-1))
161      return 1;
162    else
163      return 2;
164}
165
166
167inline
168void TriaAccessor::operator ++ () {
169  ++this->present_index;
170
171  while (this->present_index >=
172         static_cast<int>(*this->levels[this->present_level]))
173    {
174      ++this->present_level;
175      this->present_index = 0;
176
177      if (this->present_level >= static_cast<int>(1))
178        {
179
180          this->present_level = this->present_index = -1;
181          return;
182        }
183    }
184}
185
186struct MGDoFObjectAccessor : TriaAccessor {};
187
188
189
190struct TriaRawIterator
191{
192    TriaRawIterator ();
193
194    TriaRawIterator (const TriaRawIterator &);
195    TriaRawIterator (const MGDoFObjectAccessor &a);
196    const MGDoFObjectAccessor & operator * () const;
197
198    MGDoFObjectAccessor & operator * ();
199    const MGDoFObjectAccessor * operator -> () const;
200
201    MGDoFObjectAccessor * operator -> ();
202
203    TriaRawIterator & operator = (const TriaRawIterator &);
204
205    bool operator == (const TriaRawIterator &) const;
206    bool operator != (const TriaRawIterator &) const;
207    bool operator < (const TriaRawIterator &) const;
208    MGDoFObjectAccessor accessor;
209
210    TriaRawIterator & operator ++ ();
211};
212
213struct TriaIterator : TriaRawIterator
214{
215    TriaIterator ();
216
217    TriaIterator (const TriaIterator &i);
218
219    TriaIterator &
220    operator = (const TriaIterator &);
221
222    TriaIterator &
223    operator = (const TriaRawIterator &);
224};
225
226
227inline
228TriaRawIterator::TriaRawIterator (const TriaRawIterator &i) :
229                accessor (i.accessor) {}
230
231inline
232TriaIterator::TriaIterator (const TriaIterator &i) :
233                TriaRawIterator (static_cast<TriaRawIterator >(i)) {}
234
235inline
236TriaRawIterator & TriaRawIterator::operator ++ () {
237  while (++accessor, (this->accessor.state() == 0))
238    if (this->accessor.used() == true)
239      return *this;
240  return *this;
241}
242
243struct Comp {
244    Comp (const Tensor &dir) : dir(dir) {}
245
246    bool operator () (const TriaIterator &c1, const TriaIterator &c2) const;
247    const Tensor dir;
248};
249
250
251template<typename Iter>
252void x1(Iter first, Iter last, int i, Comp comp)
253{
254  x1(Iter(), last, i, comp);
255}
256
257template<typename Iter>
258inline void x2(Iter first, Iter last, Comp comp)
259{
260  if (first.base() != last.base())
261    x1(first, last, (last - first), comp);
262}
263
264void downstream_dg (const Tensor& direction)
265{
266  vector<TriaIterator> ordered_cells(13);
267  const Comp comparator(direction);
268
269  TriaIterator begin, end;
270
271  copy (begin, end, ordered_cells.begin());
272  x2 (ordered_cells.begin(), ordered_cells.begin(), comparator);
273}
274