Refactoring-6: Replace global variables with procedure arguments

Author: connoraird

episodes/7-refactoring-fortran/solution/src/game_of_life.f90

@@ -8,14 +8,10 @@ program game_of_life
 
     implicit none
 
-    !! Board args
-    integer, parameter :: max_generations = 100, max_nrows = 100, max_ncols = 100
-    integer :: nrow, ncol, generation_number
-    integer, dimension(:,:), allocatable :: current_board, new_board
-    logical :: steady_state = .false.
-
-    !> Whether to animate the board
     logical, parameter :: animate = .true.
+    integer, dimension(:,:), allocatable :: starting_board
+    integer :: generation_number
+    logical :: steady_state = .false.
 
     !! CLI args
     character(len=:), allocatable :: executable_name, input_filename
@@ -30,9 +26,9 @@ program game_of_life
         stop
     end if
 
-    call read_model_from_file()
+    call read_model_from_file(input_filename, starting_board)
 
-    call find_steady_state()
+    call find_steady_state(steady_state, generation_number, starting_board, animate)
 
     if (steady_state) then
         write(*,'(a,i6,a)') "Reached steady after ", generation_number, " generations"
@@ -43,7 +39,7 @@ program game_of_life
 contains
 
     !> Read a cli arg at a given index and return it as a string (character array)
-    recursive subroutine read_cli_arg(arg_index, arg)
+    subroutine read_cli_arg(arg_index, arg)
         !> The index of the cli arg to try and read
         integer, intent(in) :: arg_index
         !> The string into which to store the cli arg
@@ -59,12 +55,16 @@ recursive subroutine read_cli_arg(arg_index, arg)
     end subroutine read_cli_arg
 
     !> Populate the board from a provided file
-    subroutine read_model_from_file()
+    subroutine read_model_from_file(input_filename, board)
+        character(len=:), allocatable, intent(in) :: input_filename
+        integer, dimension(:,:), allocatable, intent(out) :: board
+
         !> A flag to indicate if reading the file was successful
         character(len=:), allocatable :: io_error_message
 
         ! Board definition args
-        integer :: row
+        integer :: row, nrow, ncol
+        integer, parameter :: max_nrows = 100, max_ncols = 100
 
         ! File IO args
         integer :: input_file_io, iostat
@@ -98,12 +98,12 @@ subroutine read_model_from_file()
 
         if (.not. allocated(io_error_message)) then
 
-            allocate(current_board(nrow, ncol))
+            allocate(board(nrow, ncol))
 
             read(input_file_io,'(a)') text_to_discard ! Skip next line
             ! Populate the boards starting state
             do row = 1, nrow
-                read(input_file_io,*) current_board(row, :)
+                read(input_file_io,*) board(row, :)
             end do
 
         end if
@@ -118,14 +118,27 @@ subroutine read_model_from_file()
     end subroutine read_model_from_file
 
     !> Find the steady state of the Game of Life board
-    subroutine find_steady_state()
+    subroutine find_steady_state(steady_state, generation_number, input_board, animate)
+        !> Whether the board has reached a steady state
+        logical, intent(out) :: steady_state
+        !> The number of generations that have been processed
+        integer, intent(out) :: generation_number
+        !> The starting state of the board
+        integer, dimension(:,:), allocatable, intent(in) :: input_board
+        !> Whether to animate the board
+        logical, intent(in) :: animate
+
+        integer, dimension(:,:), allocatable :: current_board, new_board
+        integer, parameter :: max_generations = 100
 
         !! Animation args
         integer, dimension(8) :: date_time_values
         integer :: mod_ms_step
         integer, parameter :: ms_per_step = 250
 
-        allocate(new_board(size(current_board,1), size(current_board, 2)))
+        allocate(current_board(size(input_board,1), size(input_board, 2)))
+        allocate(new_board(size(input_board,1), size(input_board, 2)))
+        current_board = input_board
         new_board = 0
 
         ! Clear the terminal screen
@@ -143,10 +156,10 @@ subroutine find_steady_state()
             end if
 
             if (mod_ms_step == 0) then
-                call evolve_board()
-                call check_for_steady_state()
+                call evolve_board(current_board, new_board)
+                call check_for_steady_state(steady_state, current_board, new_board)
                 current_board = new_board
-                if (animate) call draw_board()
+                if (animate) call draw_board(current_board)
 
                 generation_number = generation_number + 1
             end if
@@ -155,8 +168,16 @@ subroutine find_steady_state()
     end subroutine find_steady_state
 
     !> Evolve the board into the state of the next iteration
-    subroutine evolve_board()
-        integer :: row, col, sum
+    subroutine evolve_board(current_board, new_board)
+        !> The current state of the board
+        integer, dimension(:,:), allocatable, intent(in) :: current_board
+        !> The new state of the board
+        integer, dimension(:,:), allocatable, intent(inout) :: new_board
+
+        integer :: row, col, sum, nrow, ncol
+
+        nrow = size(current_board, 1)
+        ncol = size(current_board, 2)
 
         do row=2, nrow-1
             do col=2, ncol-1
@@ -185,8 +206,18 @@ subroutine evolve_board()
     end subroutine evolve_board
 
     !> Check if we have reached steady state, i.e. current and new board match
-    subroutine check_for_steady_state()
-        integer :: row, col
+    subroutine check_for_steady_state(steady_state, current_board, new_board)
+        !> Whether the board has reached a steady state
+        logical, intent(out) :: steady_state
+        !> The current state of the board
+        integer, dimension(:,:), allocatable, intent(in) :: current_board
+        !> The new state of the board
+        integer, dimension(:,:), allocatable, intent(inout) :: new_board
+
+        integer :: row, col, nrow, ncol
+
+        nrow = size(current_board, 1)
+        ncol = size(current_board, 2)
 
         do row=1, nrow
             do col=1, ncol
@@ -200,17 +231,25 @@ subroutine check_for_steady_state()
     end subroutine check_for_steady_state
 
     !> Output the current board to the terminal
-    subroutine draw_board()
-        integer :: row, col
-        character(nrow) :: output
+    subroutine draw_board(board)
+        !> The current state of the board
+        integer, dimension(:,:), allocatable, intent(in) :: board
+
+        integer :: row, col, nrow, ncol
+        character(:), allocatable :: output
+
+        nrow = size(board, 1)
+        ncol = size(board, 2)
+
+        allocate(character(nrow) :: output)
 
         ! Clear the terminal screen
         call system("clear")
 
         do row=1, nrow
             output = ""
             do col=1, ncol
-                if (current_board(row,col) == 1) then
+                if (board(row,col) == 1) then
                     output = trim(output)//"#"
                 else
                     output = trim(output)//"."