vasilito
cb424d7448
verify-patch-sanity.py validates every active recipe .patch has internally- consistent hunk line counts — catching the 'malformed patch at line N' failure at commit/CI/preflight time instead of hours into a cook. This cycle hit that class three times (qtwaylandscanner, sddm, xwayland), each only discovered when cookbook tried to apply the patch. Running it across the repo found 29 latent malformed patches (validated against GNU patch: e.g. relibc/P3-sysv-ipc reproduces 'malformed patch at line 22'). They were harmless only because they sit in vendored recipes (baked, not re- applied) — but would fail on any version-bump re-derivation. --fix recounts the hunk headers (body untouched) and repaired all 29. Wired into build-preflight.sh (Phase 1.0D) and redbear-ci.yml, with a unit test (test-patch-sanity.sh). Skips archived/legacy trees and unvalidatable formats (empty placeholders, bare-@@ git hunks).
645 lines
13 KiB
Fortran
645 lines
13 KiB
Fortran
! RUN: %python %S/test_modfile.py %s %flang_fc1 -flogical-abbreviations -fxor-operator
|
|
|
|
! Resolution of user-defined operators in expressions.
|
|
! Test by using generic function in a specification expression that needs
|
|
! to be written to a .mod file.
|
|
|
|
! Numeric operators
|
|
module m1
|
|
type :: t
|
|
sequence
|
|
logical :: x
|
|
end type
|
|
interface operator(+)
|
|
pure integer(8) function add_ll(x, y)
|
|
logical, intent(in) :: x, y
|
|
end
|
|
pure integer(8) function add_li(x, y)
|
|
logical, intent(in) :: x
|
|
integer, intent(in) :: y
|
|
end
|
|
pure integer(8) function add_tt(x, y)
|
|
import :: t
|
|
type(t), intent(in) :: x, y
|
|
end
|
|
end interface
|
|
interface operator(/)
|
|
pure integer(8) function div_tz(x, y)
|
|
import :: t
|
|
type(t), intent(in) :: x
|
|
complex, intent(in) :: y
|
|
end
|
|
pure integer(8) function div_ct(x, y)
|
|
import :: t
|
|
character(10), intent(in) :: x
|
|
type(t), intent(in) :: y
|
|
end
|
|
end interface
|
|
contains
|
|
subroutine s1(x, y, z)
|
|
logical :: x, y
|
|
real :: z(x + y) ! resolves to add_ll
|
|
end
|
|
subroutine s2(x, y, z)
|
|
logical :: x
|
|
integer :: y
|
|
real :: z(x + y) ! resolves to add_li
|
|
end
|
|
subroutine s3(x, y, z)
|
|
type(t) :: x
|
|
complex :: y
|
|
real :: z(x / y) ! resolves to div_tz
|
|
end
|
|
subroutine s4(x, y, z)
|
|
character(10) :: x
|
|
type(t) :: y
|
|
real :: z(x / y) ! resolves to div_ct
|
|
end
|
|
end
|
|
|
|
!Expect: m1.mod
|
|
!module m1
|
|
! type :: t
|
|
! sequence
|
|
! logical(4) :: x
|
|
! end type
|
|
! interface
|
|
! pure function add_ll(x, y)
|
|
! logical(4), intent(in) :: x
|
|
! logical(4), intent(in) :: y
|
|
! integer(8) :: add_ll
|
|
! end
|
|
! end interface
|
|
! interface
|
|
! pure function add_li(x, y)
|
|
! logical(4), intent(in) :: x
|
|
! integer(4), intent(in) :: y
|
|
! integer(8) :: add_li
|
|
! end
|
|
! end interface
|
|
! interface
|
|
! pure function add_tt(x, y)
|
|
! import :: t
|
|
! type(t), intent(in) :: x
|
|
! type(t), intent(in) :: y
|
|
! integer(8) :: add_tt
|
|
! end
|
|
! end interface
|
|
! interface
|
|
! pure function div_tz(x, y)
|
|
! import :: t
|
|
! type(t), intent(in) :: x
|
|
! complex(4), intent(in) :: y
|
|
! integer(8) :: div_tz
|
|
! end
|
|
! end interface
|
|
! interface
|
|
! pure function div_ct(x, y)
|
|
! import :: t
|
|
! character(10_4, 1), intent(in) :: x
|
|
! type(t), intent(in) :: y
|
|
! integer(8) :: div_ct
|
|
! end
|
|
! end interface
|
|
! interface operator(+)
|
|
! procedure :: add_ll
|
|
! procedure :: add_li
|
|
! procedure :: add_tt
|
|
! end interface
|
|
! interface operator(/)
|
|
! procedure :: div_tz
|
|
! procedure :: div_ct
|
|
! end interface
|
|
!contains
|
|
! subroutine s1(x, y, z)
|
|
! logical(4) :: x
|
|
! logical(4) :: y
|
|
! real(4) :: z(1_8:add_ll(x, y))
|
|
! end
|
|
! subroutine s2(x, y, z)
|
|
! logical(4) :: x
|
|
! integer(4) :: y
|
|
! real(4) :: z(1_8:add_li(x, y))
|
|
! end
|
|
! subroutine s3(x, y, z)
|
|
! type(t) :: x
|
|
! complex(4) :: y
|
|
! real(4) :: z(1_8:div_tz(x, y))
|
|
! end
|
|
! subroutine s4(x, y, z)
|
|
! character(10_4, 1) :: x
|
|
! type(t) :: y
|
|
! real(4) :: z(1_8:div_ct(x, y))
|
|
! end
|
|
!end
|
|
|
|
! Logical operators
|
|
module m2
|
|
type :: t
|
|
sequence
|
|
logical :: x
|
|
end type
|
|
interface operator(.And.)
|
|
pure integer(8) function and_ti(x, y)
|
|
import :: t
|
|
type(t), intent(in) :: x
|
|
integer, intent(in) :: y
|
|
end
|
|
pure integer(8) function and_li(x, y)
|
|
logical, intent(in) :: x
|
|
integer, intent(in) :: y
|
|
end
|
|
end interface
|
|
! Alternative spelling of .AND.
|
|
interface operator(.a.)
|
|
pure integer(8) function and_tt(x, y)
|
|
import :: t
|
|
type(t), intent(in) :: x, y
|
|
end
|
|
end interface
|
|
interface operator(.x.)
|
|
pure integer(8) function neqv_tt(x, y)
|
|
import :: t
|
|
type(t), intent(in) :: x, y
|
|
end
|
|
end interface
|
|
interface operator(.neqv.)
|
|
pure integer(8) function neqv_rr(x, y)
|
|
real, intent(in) :: x, y
|
|
end
|
|
end interface
|
|
contains
|
|
subroutine s1(x, y, z)
|
|
type(t) :: x
|
|
integer :: y
|
|
real :: z(x .and. y) ! resolves to and_ti
|
|
end
|
|
subroutine s2(x, y, z)
|
|
logical :: x
|
|
integer :: y
|
|
real :: z(x .a. y) ! resolves to and_li
|
|
end
|
|
subroutine s3(x, y, z)
|
|
type(t) :: x, y
|
|
real :: z(x .and. y) ! resolves to and_tt
|
|
end
|
|
subroutine s4(x, y, z)
|
|
type(t) :: x, y
|
|
real :: z(x .neqv. y) ! resolves to neqv_tt
|
|
end
|
|
subroutine s5(x, y, z)
|
|
real :: x, y
|
|
real :: z(x .xor. y) ! resolves to neqv_rr
|
|
end
|
|
end
|
|
|
|
!Expect: m2.mod
|
|
!module m2
|
|
! type :: t
|
|
! sequence
|
|
! logical(4) :: x
|
|
! end type
|
|
! interface
|
|
! pure function and_ti(x, y)
|
|
! import :: t
|
|
! type(t), intent(in) :: x
|
|
! integer(4), intent(in) :: y
|
|
! integer(8) :: and_ti
|
|
! end
|
|
! end interface
|
|
! interface
|
|
! pure function and_li(x, y)
|
|
! logical(4), intent(in) :: x
|
|
! integer(4), intent(in) :: y
|
|
! integer(8) :: and_li
|
|
! end
|
|
! end interface
|
|
! interface
|
|
! pure function and_tt(x, y)
|
|
! import :: t
|
|
! type(t), intent(in) :: x
|
|
! type(t), intent(in) :: y
|
|
! integer(8) :: and_tt
|
|
! end
|
|
! end interface
|
|
! interface
|
|
! pure function neqv_tt(x, y)
|
|
! import :: t
|
|
! type(t), intent(in) :: x
|
|
! type(t), intent(in) :: y
|
|
! integer(8) :: neqv_tt
|
|
! end
|
|
! end interface
|
|
! interface
|
|
! pure function neqv_rr(x, y)
|
|
! real(4), intent(in) :: x
|
|
! real(4), intent(in) :: y
|
|
! integer(8) :: neqv_rr
|
|
! end
|
|
! end interface
|
|
! interface operator( .and.)
|
|
! procedure :: and_ti
|
|
! procedure :: and_li
|
|
! procedure :: and_tt
|
|
! end interface
|
|
! interface operator(.x.)
|
|
! procedure :: neqv_tt
|
|
! procedure :: neqv_rr
|
|
! end interface
|
|
!contains
|
|
! subroutine s1(x, y, z)
|
|
! type(t) :: x
|
|
! integer(4) :: y
|
|
! real(4) :: z(1_8:and_ti(x, y))
|
|
! end
|
|
! subroutine s2(x, y, z)
|
|
! logical(4) :: x
|
|
! integer(4) :: y
|
|
! real(4) :: z(1_8:and_li(x, y))
|
|
! end
|
|
! subroutine s3(x, y, z)
|
|
! type(t) :: x
|
|
! type(t) :: y
|
|
! real(4) :: z(1_8:and_tt(x, y))
|
|
! end
|
|
! subroutine s4(x, y, z)
|
|
! type(t) :: x
|
|
! type(t) :: y
|
|
! real(4) :: z(1_8:neqv_tt(x, y))
|
|
! end
|
|
! subroutine s5(x, y, z)
|
|
! real(4) :: x
|
|
! real(4) :: y
|
|
! real(4) :: z(1_8:neqv_rr(x, y))
|
|
! end
|
|
!end
|
|
|
|
! Relational operators
|
|
module m3
|
|
type :: t
|
|
sequence
|
|
logical :: x
|
|
end type
|
|
interface operator(<>)
|
|
pure integer(8) function ne_it(x, y)
|
|
import :: t
|
|
integer, intent(in) :: x
|
|
type(t), intent(in) :: y
|
|
end
|
|
end interface
|
|
interface operator(/=)
|
|
pure integer(8) function ne_tt(x, y)
|
|
import :: t
|
|
type(t), intent(in) :: x, y
|
|
end
|
|
end interface
|
|
interface operator(.ne.)
|
|
pure integer(8) function ne_ci(x, y)
|
|
character(len=*), intent(in) :: x
|
|
integer, intent(in) :: y
|
|
end
|
|
end interface
|
|
contains
|
|
subroutine s1(x, y, z)
|
|
integer :: x
|
|
type(t) :: y
|
|
real :: z(x /= y) ! resolves to ne_it
|
|
end
|
|
subroutine s2(x, y, z)
|
|
type(t) :: x
|
|
type(t) :: y
|
|
real :: z(x .ne. y) ! resolves to ne_tt
|
|
end
|
|
subroutine s3(x, y, z)
|
|
character(len=*) :: x
|
|
integer :: y
|
|
real :: z(x <> y) ! resolves to ne_ci
|
|
end
|
|
end
|
|
|
|
!Expect: m3.mod
|
|
!module m3
|
|
! type :: t
|
|
! sequence
|
|
! logical(4) :: x
|
|
! end type
|
|
! interface
|
|
! pure function ne_it(x, y)
|
|
! import :: t
|
|
! integer(4), intent(in) :: x
|
|
! type(t), intent(in) :: y
|
|
! integer(8) :: ne_it
|
|
! end
|
|
! end interface
|
|
! interface
|
|
! pure function ne_tt(x, y)
|
|
! import :: t
|
|
! type(t), intent(in) :: x
|
|
! type(t), intent(in) :: y
|
|
! integer(8) :: ne_tt
|
|
! end
|
|
! end interface
|
|
! interface
|
|
! pure function ne_ci(x, y)
|
|
! character(*, 1), intent(in) :: x
|
|
! integer(4), intent(in) :: y
|
|
! integer(8) :: ne_ci
|
|
! end
|
|
! end interface
|
|
! interface operator(<>)
|
|
! procedure :: ne_it
|
|
! procedure :: ne_tt
|
|
! procedure :: ne_ci
|
|
! end interface
|
|
!contains
|
|
! subroutine s1(x, y, z)
|
|
! integer(4) :: x
|
|
! type(t) :: y
|
|
! real(4) :: z(1_8:ne_it(x, y))
|
|
! end
|
|
! subroutine s2(x, y, z)
|
|
! type(t) :: x
|
|
! type(t) :: y
|
|
! real(4) :: z(1_8:ne_tt(x, y))
|
|
! end
|
|
! subroutine s3(x, y, z)
|
|
! character(*, 1) :: x
|
|
! integer(4) :: y
|
|
! real(4) :: z(1_8:ne_ci(x, y))
|
|
! end
|
|
!end
|
|
|
|
! Concatenation
|
|
module m4
|
|
type :: t
|
|
sequence
|
|
logical :: x
|
|
end type
|
|
interface operator(//)
|
|
pure integer(8) function concat_12(x, y)
|
|
character(len=*,kind=1), intent(in) :: x
|
|
character(len=*,kind=2), intent(in) :: y
|
|
end
|
|
pure integer(8) function concat_int_real(x, y)
|
|
integer, intent(in) :: x
|
|
real, intent(in) :: y
|
|
end
|
|
end interface
|
|
contains
|
|
subroutine s1(x, y, z)
|
|
character(len=*,kind=1) :: x
|
|
character(len=*,kind=2) :: y
|
|
real :: z(x // y) ! resolves to concat_12
|
|
end
|
|
subroutine s2(x, y, z)
|
|
integer :: x
|
|
real :: y
|
|
real :: z(x // y) ! resolves to concat_int_real
|
|
end
|
|
end
|
|
!Expect: m4.mod
|
|
!module m4
|
|
! type :: t
|
|
! sequence
|
|
! logical(4) :: x
|
|
! end type
|
|
! interface
|
|
! pure function concat_12(x, y)
|
|
! character(*, 1), intent(in) :: x
|
|
! character(*, 2), intent(in) :: y
|
|
! integer(8) :: concat_12
|
|
! end
|
|
! end interface
|
|
! interface
|
|
! pure function concat_int_real(x, y)
|
|
! integer(4), intent(in) :: x
|
|
! real(4), intent(in) :: y
|
|
! integer(8) :: concat_int_real
|
|
! end
|
|
! end interface
|
|
! interface operator(//)
|
|
! procedure :: concat_12
|
|
! procedure :: concat_int_real
|
|
! end interface
|
|
!contains
|
|
! subroutine s1(x, y, z)
|
|
! character(*, 1) :: x
|
|
! character(*, 2) :: y
|
|
! real(4) :: z(1_8:concat_12(x, y))
|
|
! end
|
|
! subroutine s2(x, y, z)
|
|
! integer(4) :: x
|
|
! real(4) :: y
|
|
! real(4) :: z(1_8:concat_int_real(x, y))
|
|
! end
|
|
!end
|
|
|
|
! Unary operators
|
|
module m5
|
|
type :: t
|
|
end type
|
|
interface operator(+)
|
|
pure integer(8) function plus_l(x)
|
|
logical, intent(in) :: x
|
|
end
|
|
end interface
|
|
interface operator(-)
|
|
pure integer(8) function minus_t(x)
|
|
import :: t
|
|
type(t), intent(in) :: x
|
|
end
|
|
end interface
|
|
interface operator(.not.)
|
|
pure integer(8) function not_t(x)
|
|
import :: t
|
|
type(t), intent(in) :: x
|
|
end
|
|
pure integer(8) function not_real(x)
|
|
real, intent(in) :: x
|
|
end
|
|
end interface
|
|
contains
|
|
subroutine s1(x, y)
|
|
logical :: x
|
|
real :: y(+x) ! resolves_to plus_l
|
|
end
|
|
subroutine s2(x, y)
|
|
type(t) :: x
|
|
real :: y(-x) ! resolves_to minus_t
|
|
end
|
|
subroutine s3(x, y)
|
|
type(t) :: x
|
|
real :: y(.not. x) ! resolves to not_t
|
|
end
|
|
subroutine s4(x, y)
|
|
real :: y(.not. x) ! resolves to not_real
|
|
end
|
|
end
|
|
|
|
!Expect: m5.mod
|
|
!module m5
|
|
! type :: t
|
|
! end type
|
|
! interface
|
|
! pure function plus_l(x)
|
|
! logical(4), intent(in) :: x
|
|
! integer(8) :: plus_l
|
|
! end
|
|
! end interface
|
|
! interface
|
|
! pure function minus_t(x)
|
|
! import :: t
|
|
! type(t), intent(in) :: x
|
|
! integer(8) :: minus_t
|
|
! end
|
|
! end interface
|
|
! interface
|
|
! pure function not_t(x)
|
|
! import :: t
|
|
! type(t), intent(in) :: x
|
|
! integer(8) :: not_t
|
|
! end
|
|
! end interface
|
|
! interface
|
|
! pure function not_real(x)
|
|
! real(4), intent(in) :: x
|
|
! integer(8) :: not_real
|
|
! end
|
|
! end interface
|
|
! interface operator(+)
|
|
! procedure :: plus_l
|
|
! end interface
|
|
! interface operator(-)
|
|
! procedure :: minus_t
|
|
! end interface
|
|
! interface operator( .not.)
|
|
! procedure :: not_t
|
|
! procedure :: not_real
|
|
! end interface
|
|
!contains
|
|
! subroutine s1(x, y)
|
|
! logical(4) :: x
|
|
! real(4) :: y(1_8:plus_l(x))
|
|
! end
|
|
! subroutine s2(x, y)
|
|
! type(t) :: x
|
|
! real(4) :: y(1_8:minus_t(x))
|
|
! end
|
|
! subroutine s3(x, y)
|
|
! type(t) :: x
|
|
! real(4) :: y(1_8:not_t(x))
|
|
! end
|
|
! subroutine s4(x, y)
|
|
! real(4) :: x
|
|
! real(4) :: y(1_8:not_real(x))
|
|
! end
|
|
!end
|
|
|
|
! Resolved based on shape
|
|
module m6
|
|
interface operator(+)
|
|
pure integer(8) function add(x, y)
|
|
real, intent(in) :: x(:, :)
|
|
real, intent(in) :: y(:, :, :)
|
|
end
|
|
end interface
|
|
contains
|
|
subroutine s1(n, x, y, z, a, b)
|
|
integer(8) :: n
|
|
real :: x
|
|
real :: y(4, n)
|
|
real :: z(2, 2, 2)
|
|
real :: a(size(x+y)) ! intrinsic +
|
|
real :: b(y+z) ! resolves to add
|
|
end
|
|
end
|
|
|
|
!Expect: m6.mod
|
|
!module m6
|
|
! interface
|
|
! pure function add(x, y)
|
|
! real(4), intent(in) :: x(:, :)
|
|
! real(4), intent(in) :: y(:, :, :)
|
|
! integer(8) :: add
|
|
! end
|
|
! end interface
|
|
! interface operator(+)
|
|
! procedure :: add
|
|
! end interface
|
|
!contains
|
|
! subroutine s1(n, x, y, z, a, b)
|
|
! integer(8) :: n
|
|
! real(4) :: x
|
|
! real(4) :: y(1_8:4_8, 1_8:n)
|
|
! real(4) :: z(1_8:2_8, 1_8:2_8, 1_8:2_8)
|
|
! real(4) :: a(1_8:int(int(4_8*size(y,dim=2,kind=8),kind=4),kind=8))
|
|
! real(4) :: b(1_8:add(y, z))
|
|
! end
|
|
!end
|
|
|
|
! Parameterized derived type
|
|
module m7
|
|
type :: t(k)
|
|
integer, kind :: k
|
|
real(k) :: a
|
|
end type
|
|
interface operator(+)
|
|
pure integer(8) function f1(x, y)
|
|
import :: t
|
|
type(t(4)), intent(in) :: x, y
|
|
end
|
|
pure integer(8) function f2(x, y)
|
|
import :: t
|
|
type(t(8)), intent(in) :: x, y
|
|
end
|
|
end interface
|
|
contains
|
|
subroutine s1(x, y, z)
|
|
type(t(4)) :: x, y
|
|
real :: z(x + y) ! resolves to f1
|
|
end
|
|
subroutine s2(x, y, z)
|
|
type(t(8)) :: x, y
|
|
real :: z(x + y) ! resolves to f2
|
|
end
|
|
end
|
|
|
|
!Expect: m7.mod
|
|
!module m7
|
|
! type :: t(k)
|
|
! integer(4), kind :: k
|
|
! real(int(int(k,kind=4),kind=8))::a
|
|
! end type
|
|
! interface
|
|
! pure function f1(x, y)
|
|
! import :: t
|
|
! type(t(k=4_4)), intent(in) :: x
|
|
! type(t(k=4_4)), intent(in) :: y
|
|
! integer(8) :: f1
|
|
! end
|
|
! end interface
|
|
! interface
|
|
! pure function f2(x, y)
|
|
! import :: t
|
|
! type(t(k=8_4)), intent(in) :: x
|
|
! type(t(k=8_4)), intent(in) :: y
|
|
! integer(8) :: f2
|
|
! end
|
|
! end interface
|
|
! interface operator(+)
|
|
! procedure :: f1
|
|
! procedure :: f2
|
|
! end interface
|
|
!contains
|
|
! subroutine s1(x, y, z)
|
|
! type(t(k=4_4)) :: x
|
|
! type(t(k=4_4)) :: y
|
|
! real(4) :: z(1_8:f1(x, y))
|
|
! end
|
|
! subroutine s2(x, y, z)
|
|
! type(t(k=8_4)) :: x
|
|
! type(t(k=8_4)) :: y
|
|
! real(4) :: z(1_8:f2(x, y))
|
|
! end
|
|
!end
|