Unclear or confusing error message when compiling a template example

[cmaapic]

I'm trying to test out templates. I'm using Brad Richardson's tutorial examples as a starting point.

I get the following message in the output windows when using LFortran.

syntax error: Newline is unexpected here
--> input:241:33
|
241 | instantiate sort_template(sp)
| ^

Note: Please report unclear or confusing messages as bugs at
https://github.com/lfortran/lfortran/issues.

Compilation Time: 13.599999904632568 ms

Here is the complete source code.

!#################################

! Templated sort routine
!
! This is based on the pre Fortran 2028
! syntax for a generic sorting module.
!

!#################################

! include 'integer_kind_module.f90'

module integer_kind_module
implicit none
integer, parameter :: i8 = selected_int_kind(2)
integer, parameter :: i16 = selected_int_kind(4)
integer, parameter :: i32 = selected_int_kind(9)
integer, parameter :: i64 = selected_int_kind(15)
end module

!#################################

! include 'precision_module.f90'

module precision_module
implicit none
!
! Updated with the release of Nag 7 which
! supports 16 bit reals.
!
! single, double, quad naming used by lapack.
! hence sp, dp, qp
!
! we have used hp as half precision
!
! integer, parameter :: hp = selected_real_kind( 3, 4)

integer, parameter :: sp = selected_real_kind( 6, 37)
integer, parameter :: dp = selected_real_kind(15, 307)
integer, parameter :: qp = selected_real_kind(30, 291)

end module

!#################################

! include 'timing_module.f90'

module timing_module

use integer_kind_module
use precision_module

implicit none

integer, dimension (8), private :: dt

real (dp) :: r_count
real (dp) :: r_count_rate

real (dp) :: start_time = 0.0_dp
real (dp) :: end_time = 0.0_dp
real (dp) :: last_time = 0.0_dp
real (dp) :: total_time = 0.0_dp

real (dp) :: difference = 0.0_dp

integer (i64) :: count,count_rate,count_max
integer (i64) , parameter :: nag_count_rate = 10000000
integer (i64) , parameter :: gfortran_count_rate = 1000000000
integer (i64) , parameter :: intel_count_rate = 1000000

contains

subroutine start_timing()

implicit none

call date_and_time(values=dt)
100 format (1x, i4, '/', i2, '/', i2, 1x, i2, ':', i2, ':', i2, 1x, i3)
print 100, dt(1:3), dt(5:8)

call system_clock(count,count_rate,count_max)
r_count      = count
r_count_rate = count_rate
start_time   = r_count/r_count_rate
last_time    = start_time

end subroutine start_timing

subroutine end_timing()

implicit none

call date_and_time(values=dt)

print 100, dt(1:3), dt(5:8)
100 format (1x, i4, '/', i2, '/', i2, 1x, i2, ':', i2, ':', i2, 1x, i3)

call system_clock(count,count_rate,count_max)
r_count      = count
end_time     = r_count/r_count_rate

total_time   = end_time - start_time
print 200,total_time
200 format(' Total time = ',12x,f18.6)

end subroutine end_timing

subroutine print_time_difference()

implicit none

call system_clock(count,count_rate,count_max)
r_count      = count
end_time     = r_count/r_count_rate

difference = end_time - last_time
last_time       = end_time

print 100, difference
100 format(' Time difference =  ',f18.6)

end subroutine print_time_difference

function time_difference()

implicit none

real (dp) :: time_difference

call system_clock(count,count_rate,count_max)
r_count      = count
end_time     = r_count/r_count_rate

time_difference = end_time - last_time
last_time       = end_time

end function time_difference

end module

!#################################

module sort_template_module

template sort_template(k)

! use precision_module
! use integer_kind_module

private

public :: sort

integer, parameter :: k

contains

subroutine sort(x, n)

use precision_module
use integer_kind_module

type(k) , intent(inout) :: x(:)
integer , intent(in)    :: n 

call quicksort(1, n)

contains

recursive subroutine quicksort(l, r)

  implicit none
  integer, intent (in) :: l, r
  integer :: i, j
  type (k) :: v, t

! used to include the common sorting code
! include 'quicksort_include_code.f90'

    i = l
    j = r
    v = x(int((l+r)/2))
    do
      do while (x(i)<v)
        i = i + 1
      end do
      do while (v<x(j))
        j = j - 1
      end do
      if (i<=j) then
        t = x(i)
        x(i) = x(j)
        x(j) = t
        i = i + 1
        j = j - 1
      end if
      if (i>j) exit
    end do
    if (l<j) then
      call quicksort(l, j)
    end if
    if (i<r) then
      call quicksort(i, r)
    end if

end subroutine

end subroutine

end template

end module

!#################################

program test

use precision_module
use integer_kind_module
use timing_module

use sort_template_module

implicit none
integer, parameter :: n = 1000
character (12) :: nn = '1,000'
character (80) :: report_file_name = 'ch3801_report.txt'

real (sp), allocatable, dimension (:) :: x_sp
real (sp), allocatable, dimension (:) :: t_x_sp

real (dp), allocatable, dimension (:) :: x_dp
real (dp), allocatable, dimension (:) :: t_x_dp

real (qp), allocatable, dimension (:) :: x_qp

integer (i32), allocatable, dimension (:) :: y_i32
integer (i64), allocatable, dimension (:) :: y_i64

instantiate sort_template(sp)

instantiate sort_template(dp)

instantiate sort_template(qp)

instantiate sort_template(i32)

instantiate sort_template(i64)

integer :: allocate_status = 0

character (20), dimension (5) :: heading1 = &
[ ' 32 bit real', &
' 32 bit int ', &
' 64 bit real', &
' 64 bit int ', &
' 128 bit real' ]

character (20), dimension (3) :: &
heading2 = [ ' Allocate ', &
' Random ', &
' Sort ' ]

print *, 'Program starts'
print *, 'N = ', nn
call start_timing()

open (unit=100, file=report_file_name)

print *, heading1(1)

allocate (x_sp(1:n), stat=allocate_status)
if (allocate_status/=0) then
print *, ' Allocate failed. Program terminates'
stop 10
end if

print 100, heading2(1), time_difference()
100 format (a20, 2x, f18.6)

call random_number(x_sp)
t_x_sp = x_sp

print 100, heading2(2), time_difference()
call sort_data(x_sp, n)
print 100, heading2(3), time_difference()
write (unit=100, fmt='(a)') ' First 10 32 bit reals'
write (unit=100, fmt=110) x_sp(1:10)
110 format (5(2x,e14.6))

print *, heading1(2)

allocate (y_i32(1:n), stat=allocate_status)
if (allocate_status/=0) then
print *, 'Allocate failed. Program terminates'
stop 30
end if

print 100, heading2(1), time_difference()
y_i32 = int(t_x_sp*1000000000, i32)

deallocate (x_sp)
deallocate (t_x_sp)

print 100, heading2(2), time_difference()
call sort_data(y_i32, n)
print 100, heading2(3), time_difference()
write (unit=100, fmt='(a)') 'First 10 32 bit integers'
write (unit=100, fmt=120) y_i32(1:10)
120 format (5(2x,i10))
deallocate (y_i32)

print *, heading1(3)

allocate (x_dp(1:n), stat=allocate_status)
if (allocate_status/=0) then
print *, 'Allocate failed. Program terminates'
stop 30
end if

allocate (t_x_dp(1:n), stat=allocate_status)
if (allocate_status/=0) then
print *, 'Allocate failed. Program terminates'
stop 40
end if

print 100, heading2(1), time_difference()
call random_number(x_dp)
t_x_dp = x_dp
print 100, heading2(2), time_difference()
call sort_data(x_dp, n)
print 100, heading2(3), time_difference()
write (unit=100, fmt='(a)') 'First 10 64 bit reals'
write (unit=100, fmt=110) x_dp(1:10)

print *, heading1(4)

allocate (y_i64(1:n), stat=allocate_status)
if (allocate_status/=0) then
print *, 'Allocate failed. Program terminates'
stop 40
end if

print 100, heading2(1), time_difference()
y_i64 = int(t_x_dp*1000000000000000_i64, i64)

deallocate (x_dp)
deallocate (t_x_dp)

print 100, heading2(2), time_difference()
call sort_data(y_i64, n)
print 100, heading2(3), time_difference()
write (unit=100, fmt='(a)') 'First 10 64 bit integers'
write (unit=100, fmt=120) y_i64(1:10)
deallocate (y_i64)

print *, heading1(5)

allocate (x_qp(1:n), stat=allocate_status)
if (allocate_status/=0) then
print *, 'Allocate failed. Program terminates'
stop 50
end if

print 100, heading2(1), time_difference()
call random_number(x_qp)
print 100, heading2(2), time_difference()
call sort_data(x_qp, n)
print 100, heading2(3), time_difference()
write (unit=100, fmt='(a)') 'First 10 128 bitreals'
write (unit=100, fmt=110) x_qp(1:10)

close (200)
print *, 'Program terminates'
call end_timing()

end program