Hi

the following program displays behavior that I don't understand.

module type_mod 
    type mytype 
        real, dimension(:,:,:,:,:,:), allocatable:: a 
        contains 
            procedure :: allocate 
    end type mytype 
    contains 
    subroutine allocate(this,n1, n4) 
        class(mytype), intent(inout):: this 
        integer , intent(in) :: n1, n4 
        integer, parameter :: n2= 5, n3=5 
        if (.not. allocated(this%a)) allocate(this%a(n1,n2,n3,n4,10,10)) 
    end subroutine allocate 
end module type_mod 
program main 
    use type_mod 
    implicit none 
    type(mytype) :: t 
    real, allocatable :: a2(:,:,:,:) 
    integer:: n1, n2, n3,n4, i, case 
    call t%allocate(5,5) 
    t%a=10.0 
    n1=size(t%a,1); n2=size(t%a,3); n3=size(t%a,4); n4=size(t%a,6) 
    allocate(a2(n1,n2,n3,n4)) 
    i=2 
    case =2 
    select case (case) 
    case(1) 
        a2= t%a(:,2,:,:,i,:)  ! this works 
    case(2) 
        a2= 1.0*t%a(:,2,:,:,i,:) ! this does NOT work 
    case(3) 
        a2(:,:,:,:)= 1.0*t%a(:,2,:,:,i,:) ! this works 
    end select 
    print*, n1,n2,n3,n4 
    print*, shape(a2) 
    print*, a2(1,2,3,4) 
end program main 
 

Compile with bounds checking, allowing for Fortran 2003 reallocation of allocatable arrays on assignment, e.g.:

ifort -g -check bounds -assume realloc_lhs -o "main.o" "../main.f90" 
 

Output is:

           5           5           5          10
           5           1           5           5
forrtl: severe (408): fort: (2): Subscript #2 of the array A2 has value 2 which is greater than the upper bound of 1

Traceback indicates the line containing  print*, a2(1,2,3,4) as the source of the violation.

If you set case=1 or case=3, I get the expected output:

           5           5           5          10
           5           5           5          10
   10.00000

*The question*: Why do I get the error in case=2 ?

*More information*: Not allowing for the Fortran 2003 reallocation on assignment yields the expected results in all cases. Turning off bounds checking yields somewhat strangely:

           5           5           5          10
           5           1           5          10
   10.00000

Thanks in advance!

Daniel

PS: I am using Intel composer_xe_2013.0.079 on Ubuntu 12.04