1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
|
! { dg-do run }
!
! Tests functionality of recursive allocatable derived types.
!
type :: recurses
type(recurses), allocatable :: c
integer, allocatable :: ia
end type
type(recurses), allocatable, target :: a, d
type(recurses), pointer :: b
integer :: total = 0
! Check chained allocation.
allocate(a)
a%ia = 1
allocate (a%c)
a%c%ia = 2
! Check move_alloc.
allocate (d)
d%ia = 3
call move_alloc (d, a%c%c)
if (a%ia .ne. 1) STOP 1
if (a%c%ia .ne. 2) STOP 2
if (a%c%c%ia .ne. 3) STOP 3
! Check that we can point anywhere in the chain
b => a%c%c
if (b%ia .ne. 3) STOP 4
b => a%c
if (b%ia .ne. 2) STOP 5
! Check that the pointer can be used as if it were an element in the chain.
if (.not.allocated (b%c)) STOP 6
b => a%c%c
if (.not.allocated (b%c)) allocate (b%c)
b%c%ia = 4
if (a%c%c%c%ia .ne. 4) STOP 7
! A rudimentary iterator.
b => a
do while (associated (b))
total = total + b%ia
b => b%c
end do
if (total .ne. 10) STOP 8
! Take one element out of the chain.
call move_alloc (a%c%c, d)
call move_alloc (d%c, a%c%c)
if (d%ia .ne. 3) STOP 9
deallocate (d)
! Checkcount of remaining chain.
total = 0
b => a
do while (associated (b))
total = total + b%ia
b => b%c
end do
if (total .ne. 7) STOP 10
! Deallocate to check that there are no memory leaks.
deallocate (a%c%c)
deallocate (a%c)
deallocate (a)
end
|
