refac(depth1stsearch): prep for pure function

Author: Damian Rouson

src/dag_s.f90

@@ -14,6 +14,10 @@
 
   implicit none
 
+  type searched_and_ordered_t
+    integer, allocatable, dimension(:) :: s, o
+  end type 
+
 contains
 
   module procedure construct_from_components
@@ -30,47 +34,52 @@ pure module function topological_sort(dag) result(order)
     call assert(all(dag%vertices(:)%edges_allocated()), "dag_s topological_sort: all(dag%vertices(:)%edges_allocated())")
 
     block
-      integer, allocatable :: discovered(:), searched(:)
+      type(searched_and_ordered_t) searched_and_ordered
+      integer, allocatable :: discovered(:)
       integer v
 
-      allocate(discovered(0), order(0), searched(0))
+      allocate(discovered(0), searched_and_ordered%o(0), searched_and_ordered%s(0))
 
       do v = 1, size(dag%vertices)
-        if (.not. any(v == searched)) then
-          call depth_first_search(v, [integer::], searched, order)
-          discovered = [discovered, searched]
-          searched = discovered
+        if (.not. any(v == searched_and_ordered%s)) then
+          call depth_first_search(v, [integer::], searched_and_ordered%o, searched_and_ordered%s)
+          discovered = [discovered, searched_and_ordered%s]
+          searched_and_ordered%s= discovered
         end if
       end do
+      order = searched_and_ordered%o
     end block
 
   contains
 
-    pure recursive subroutine depth_first_search(v, d, s, o)
+    pure recursive subroutine depth_first_search(v, d, o, s)
       integer, intent(in) :: v, d(:)
       integer, intent(out), allocatable :: s(:)
       integer, intent(inout), allocatable :: o(:)
 
       call assert(.not. any(v == d), "depth_first_search: cycle detected", intrinsic_array_t([v,d]))
 
       block
-        integer, allocatable :: dependencies(:), s_local(:), d_local(:)
+        integer, allocatable :: dependencies(:), d_local(:)
         integer w
+        type(searched_and_ordered_t) hybrid
 
+        hybrid%o = o
         dependencies = dag%depends_on(v)
 
-        allocate(s_local(0), d_local(0))
+        allocate(d_local(0), hybrid%s(0))
 
         do w = 1, size(dependencies)
-          if (.not. any(dependencies(w) == s_local)) then
-            call depth_first_search(dependencies(w), [d, v], s_local, o)
-            d_local = [d_local, s_local]
-            s_local = d_local
+          if (.not. any(dependencies(w) == hybrid%s)) then
+            call depth_first_search(dependencies(w), [d, v], hybrid%o, hybrid%s)
+            d_local = [d_local, hybrid%s]
+            hybrid%s = d_local
           end if
         end do
 
-        if (.not. any(v == o)) o = [v, o]
-        s = [v, s_local]
+        if (.not. any(v == hybrid%o)) hybrid%o = [v, hybrid%o]
+        s = [v, hybrid%s]
+        o = hybrid%o
       end block
 
     end subroutine