sort_index: all iterators are now set to int_index

Author: jvdp1

src/stdlib_sorting_sort_index.fypp

@@ -102,17 +102,17 @@ contains
         ${ti}$, intent(out), optional :: iwork(0:)
         logical, intent(in), optional            :: reverse
 
-        ${ti}$ :: array_size, i, stat
+        integer(int_index) :: array_size, i, stat
         ${t2}$, allocatable :: buf(:)
         ${ti}$, allocatable :: ibuf(:)
 
-        if ( size(array, kind=int_index) > huge(1_${ki}$) ) then
+        if ( size(array, kind=int_index) > huge(1_int_index) ) then
             error stop "Too many entries for the kind of index."
         end if
 
-        array_size = size(array, kind=${ki}$)
+        array_size = size(array, kind=int_index)
 
-        if ( size(index, kind=${ki}$) < array_size ) then
+        if ( size(index, kind=int_index) < array_size ) then
             error stop "index array is too small."
         end if
 
@@ -126,11 +126,11 @@ contains
 
 ! If necessary allocate buffers to serve as scratch memory.
         if ( present(work) ) then
-            if ( size(work, kind=${ki}$) < array_size/2 ) then
+            if ( size(work, kind=int_index) < array_size/2 ) then
                 error stop "work array is too small."
             end if
             if ( present(iwork) ) then
-                if ( size(iwork, kind=${ki}$) < array_size/2 ) then
+                if ( size(iwork, kind=int_index) < array_size/2 ) then
                     error stop "iwork array is too small."
                 endif
                 call merge_sort( array, index, work, iwork )
@@ -148,7 +148,7 @@ contains
             #:endif
             if ( stat /= 0 ) error stop "Allocation of array buffer failed."
             if ( present(iwork) ) then
-                if ( size(iwork, kind=${ki}$) < array_size/2 ) then
+                if ( size(iwork, kind=int_index) < array_size/2 ) then
                     error stop "iwork array is too small."
                 endif
                 call merge_sort( array, index, buf, iwork )
@@ -169,17 +169,17 @@ contains
 !! Returns the minimum length of a run from 32-63 so that N/MIN_RUN is
 !! less than or equal to a power of two. See
 !! https://svn.python.org/projects/python/trunk/Objects/listsort.txt
-            ${ti}$             :: min_run
-            ${ti}$, intent(in) :: n
+            integer(int_index)             :: min_run
+            integer(int_index), intent(in) :: n
 
-            ${ti}$ :: num, r
+            integer(int_index) :: num, r
 
             num = n
-            r = 0_${ki}$
+            r = 0_int_index
 
             do while( num >= 64 )
-                r = ior( r, iand(num, 1_${ki}$) )
-                num = ishft(num, -1_${ki}$)
+                r = ior( r, iand(num, 1_int_index) )
+                num = ishft(num, -1_int_index)
             end do
             min_run = num + r
 
@@ -192,11 +192,11 @@ contains
             ${t1}$, intent(inout)            :: array(0:)
             ${ti}$, intent(inout) :: index(0:)
 
-            ${ti}$ :: i, j
+            integer(int_index) :: i, j
             ${ti}$ :: key_index
             ${t3}$ :: key
 
-            do j=1, size(array, kind=${ki}$)-1
+            do j=1, size(array, kind=int_index)-1
                 key = array(j)
                 key_index = index(j)
                 i = j - 1
@@ -220,13 +220,13 @@ contains
 ! 1. len(-3) > len(-2) + len(-1)
 ! 2. len(-2) > len(-1)
 
-            ${ti}$ :: r
-            type(run_type_${namei}$), intent(in), target :: runs(0:)
+            integer(int_index) :: r
+            type(run_type_default), intent(in), target :: runs(0:)
 
-            ${ti}$ :: n
+            integer(int_index) :: n
             logical :: test
 
-            n = size(runs, kind=${ki}$)
+            n = size(runs, kind=int_index)
             test = .false.
             if (n >= 2) then
                 if ( runs( n-1 ) % base == 0 .or. &
@@ -278,12 +278,12 @@ contains
             ${ti}$, intent(inout) :: index(0:)
 
             ${t3}$ :: tmp
-            ${ti}$ :: i
+            integer(int_index) :: i
             ${ti}$ :: tmp_index
 
             tmp = array(0)
             tmp_index = index(0)
-            find_hole: do i=1, size(array, kind=${ki}$)-1
+            find_hole: do i=1, size(array, kind=int_index)-1
                 if ( array(i) >= tmp ) exit find_hole
                 array(i-1) = array(i)
                 index(i-1) = index(i)
@@ -320,11 +320,11 @@ contains
             ${t3}$, intent(inout)            :: buf(0:)
             ${ti}$, intent(inout) :: ibuf(0:)
 
-            ${ti}$ :: array_size, finish, min_run, r, r_count, &
+            integer(int_index) :: array_size, finish, min_run, r, r_count, &
                 start
-            type(run_type_${namei}$) :: runs(0:max_merge_stack-1), left, right
+            type(run_type_default) :: runs(0:max_merge_stack-1), left, right
 
-            array_size = size(array, kind=${ki}$)
+            array_size = size(array, kind=int_index)
 
 ! Very short runs are extended using insertion sort to span at least this
 ! many elements. Slices of up to this length are sorted using insertion sort.
@@ -372,7 +372,7 @@ contains
                 end do Insert
                 if ( start == 0 .and. finish == array_size - 1 ) return
 
-                runs(r_count) = run_type_${namei}$( base = start, &
+                runs(r_count) = run_type_default( base = start, &
                                           len = finish - start + 1 )
                 finish = start-1
                 r_count = r_count + 1
@@ -390,7 +390,7 @@ contains
                                 index( left % base: &
                                      right % base + right % len - 1 ), ibuf )
 
-                    runs(r) = run_type_${namei}$( base = left % base, &
+                    runs(r) = run_type_default( base = left % base, &
                                         len = left % len + right % len )
                     if ( r == r_count - 3 ) runs(r+1) = runs(r+2)
                     r_count = r_count - 1
@@ -409,14 +409,14 @@ contains
 ! `ARRAY(0:)`. `MID` must be > 0, and < `SIZE(ARRAY)-1`. Buffer `BUF`
 ! must be long enough to hold the shorter of the two runs.
             ${t1}$, intent(inout)            :: array(0:)
-            ${ti}$, intent(in)    :: mid
+            integer(int_index), intent(in)    :: mid
             ${t3}$, intent(inout)            :: buf(0:)
             ${ti}$, intent(inout) :: index(0:)
             ${ti}$, intent(inout) :: ibuf(0:)
 
-            ${ti}$ :: array_len, i, j, k
+            integer(int_index) :: array_len, i, j, k
 
-            array_len = size(array, kind=${ki}$)
+            array_len = size(array, kind=int_index)
 
 ! Merge first copies the shorter run into `buf`. Then, depending on which
 ! run was shorter, it traces the copied run and the longer run forwards
@@ -477,11 +477,11 @@ contains
             ${ti}$, intent(inout) :: index(0:)
 
             ${ti}$ :: itemp
-            ${ti}$ :: lo, hi
+            integer(int_index) :: lo, hi
             ${t3}$ :: temp
 
             lo = 0
-            hi = size( array, kind=${ki}$ ) - 1
+            hi = size( array, kind=int_index ) - 1
             do while( lo < hi )
                 temp = array(lo)
                 array(lo) = array(hi)