2078150095

Committed 03 Oct 2025 09:14AM UTC coverage: 6.981% (+0.1%) from 6.855%

Build # 2078150095

Build Type

push

gitlab-ci

Committed by David Dickinson

Commit Message

Merged in experimental/user_controlled_output_base_name_in_file_utils (pull request #204)

Run Details

741 of 10615 relevant lines covered (6.98%)

16211.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

37.65

/file_utils.fpp

# include "define.inc"

!> Various utilities for working with input and output files, as well as some
!> shims/backfills for standard features not present in older compilers.
!>
!> This module is responsible for setting up the label for the run,
!> [[file_utils:run_name]], as well as opening the main input file, the error
!> file, and the exit reason file.
!>
!> Most of the procedures in this module deal with files, and are therefore not
!> MPI/thread safe, and you must manually guard any opens/closes.
module file_utils
  use constants, only: run_name_size
  use iso_fortran_env, only: std_error_unit => error_unit, stdout_unit => output_unit
  implicit none

  private

  public :: init_file_utils, init_job_name, finish_file_utils, initialized
  public :: run_name, list_name, dirname, basename, split_dir_and_base, mkdir
  public :: input_unit_exist, input_unit, error_unit, stdout_unit
  public :: init_error_unit, init_exit_reason_unit, init_input_unit, exit_reason_unit
  public :: get_input_unit, append_output_file, open_output_file, close_output_file
  public :: get_indexed_namelist_unit, num_input_lines, replace_all_tabs

  !> Label for the run. Usually this is the input file without any
  !> extensions. Set by [[init_run_name]]. Used to derive output file names
  character(run_name_size) :: run_name = 'unknown'
  !> The full input file name, set by [[get_input_filename]] or what
  !> is passed to init_file_utils
  character(run_name_size) :: arun_name = 'unknown'
  !> The current job name if we've forked -- the actual list job or
  !> ensemble case we're running. See [[job_manage(module)]]
  character(run_name_size) :: job_name = 'unknown'
  !> Label for the list run, taken from the command line typically. Only
  !> set if ends in .list, otherwise 'unknown'
  character(run_name_size) :: list_name = 'unknown'
  !> Input base name. Name of the actual input file for this job.
  character(run_name_size) :: input_name = 'unknown'
  !> Note, as we should always use newunit and this always returns negative units
  !> we just pick some positive value here. This relies a bit on us never manually
  !> specifying the unit elsewhere.
  integer, parameter :: invalid_unit = 49
  !> Unit number for main input file (actually a copy we make which has comments
  !> stripped and `!include` files included).
  integer :: input_unit_no = invalid_unit
  !> Unit number for main error file
  integer :: error_unit_no = std_error_unit
  !> Unit number for exit reason file
  integer :: exit_reason_unit_no = stdout_unit
  !> Number of lines in input file
  integer :: num_input_lines
  !> Is module initialized?
  logical :: initialized = .false.

  !> Local type for recording the unit and file name of files. Used in the
  !> include functionality to track the heirarchy of included files.
  type stack_type
     character(len=:), allocatable :: file_name
     integer :: unit = invalid_unit
  end type stack_type

contains

  !> Read the [[file_utils:run_name]] from the command line (if not given), and determine
  !> from the extension whether this is a list run (i.e. a list of runs has been
  !> given). If so or if this is a run with multiple ensembles, open the list
  !> description. If not, open the error file and call [[init_input_unit]]
  subroutine init_file_utils (list, input, error, trin_run, name, output_base_name, &
       n_ensembles, input_file, remove_comments)
    use optionals, only: get_option_with_default
    implicit none
    !> True if the input file is a list run file (see [[is_input_file_list]])
    logical, intent (out) :: list
    !> If true, open the input file and strip comments (default: true)
    logical, intent (in), optional :: input
    !> If true, open the error output file (default: true)
    logical, intent (in), optional :: error
    !> If present, regardless of value, sets `list` to false
    logical, intent (in), optional :: trin_run
    !> Set [[file_utils:run_name]] if `input` is false or `trin_run` is present
    character(len = *), intent (in), optional :: name
    !> Set [[file_utils:output_name]] used as the base for output file. If not present
    !> then default to run_name
    character(len = *), intent (in), optional :: output_base_name
    !> Number of run ensembles. If greater than 1, sets [[file_utils:list_name]] and
    !> doesn't open any files
    integer, intent (in), optional :: n_ensembles
    !> Use given input filename instead of reading from command line
    character(len = *), intent (in), optional :: input_file
    !> Do we want to strip comments from the input file as we read it.
    logical, intent(in), optional :: remove_comments
    logical :: inp, err

    inp = get_option_with_default(input, .true.)
    err = get_option_with_default(error, .true.)
    arun_name = trim(get_option_with_default(name, "unknown"))

    if (inp .and. .not. get_option_with_default(trin_run, .false.)) then
       ! Note we can't (easily) use get_option_with_default here
       ! as the default, would be the return of get_input_filename()
       ! but this function can call mp_abort and this could trigger
       ! even if input_file is passed and hence we don't need get_input_filename
       if (present(input_file)) then
          arun_name = input_file
       else
          arun_name = get_input_filename()
       endif
    end if

    list = is_input_file_list(arun_name)

    if (list .or. (get_option_with_default(n_ensembles, 1) > 1)) then
       list_name = arun_name
    else
       call init_run_name(arun_name, output_base_name)
       if (run_name /= input_name) call mkdir(run_name)
       call init_error_unit (err)
       call init_exit_reason_unit (err)
       call init_input_unit (inp, remove_comments)
    end if
    initialized = .true.
  end subroutine init_file_utils

  !> Return the input filename as set by the command line
  function get_input_filename () result(input_filename)
    use mp, only : mp_abort
    implicit none
    character(run_name_size) :: input_filename
    character(len=50) :: error_message
    integer :: filename_length, ierr

    if (command_argument_count() == 0) call mp_abort("No input file provided", .true.)

    call get_command_argument(1, input_filename, filename_length, ierr)
    if (ierr /= 0) then
      write(error_message, '(A, I0)') "Couldn't get input file name, error code: ", ierr
      call mp_abort(error_message, to_screen=.true.)
    end if
  end function get_input_filename

  !> Returns true if [[input_filename]] is a list input: that is, if it ends in `.list`
  pure logical function is_input_file_list(input_filename)
    character(len=*), intent(in) :: input_filename
    integer :: filename_length
    filename_length = len_trim(input_filename)
    if (filename_length > 5) then
       is_input_file_list = (input_filename(filename_length-4:filename_length) == ".list")
    else
       is_input_file_list = .false.
    endif
  end function is_input_file_list

  !> This is called for a non Trinity or list run - it checks that the input
  !> file name ends in `.in`, chops the extension off and stores it in
  !> [[file_utils:arun_name]]. It also assigns the pointer
  !> [[file_utils:run_name]] to [[file_utils:arun_name]].
  subroutine init_run_name(arun_name, output_base_name)
    use optionals, only: get_option_with_default
    implicit none
    character(len = *), intent(in out) :: arun_name
    character(len = *), intent(in), optional :: output_base_name
    integer :: l
    l = len_trim (arun_name)
    if (l > 3)then
       if (arun_name(l-2:l) == ".in") arun_name = arun_name(1:l-3)
    end if
    input_name = arun_name
    run_name = get_option_with_default(output_base_name, arun_name)
  end subroutine init_run_name

  !> Set [[file_utils:run_name]] and [[file_utils:job_name]] to `jobname`. Used
  !> by [[job_manage(module)]] when forking (i.e. list mode or ensembles)
  subroutine init_job_name (jobname)
    implicit none
    character(len=*), intent (in) :: jobname
    job_name = trim(jobname)
    call init_run_name(job_name)
  end subroutine init_job_name

  !> Returns a modified file path of form <dir><prefix><base><extension> for input file
  !> path of form <dir><base>.
  pure function get_modified_file_path(file_path, prefix, extension) result(file_name)
    use optionals, only: get_option_with_default
    character(len = *), intent(in) :: file_path
    character(len = *), intent (in), optional :: extension, prefix
    character(len = :), allocatable :: file_name
    file_name = dirname(file_path) // get_option_with_default(prefix, '') // &
         basename(file_path) // get_option_with_default(extension, '')
  end function get_modified_file_path

  !> Open an output file to write (replacing any existing) whose name is
  !> `<run_name>.<ext>`, and set `unit` to the unit number of that output
  !> file. If the binary flag is true, a binary file is opened
  subroutine open_output_file (unit, ext, prefix, binary)
    use optionals, only: get_option_with_default
    implicit none
    !> Unit number of opened file
    integer, intent (out) :: unit
    !> ext is file extension to open, appended to [[file_utils:run_name]]
    character (len = *), intent(in) :: ext
    !> Prefix is added to the start of the filename, after any directory part
    character (len = *), intent(in), optional :: prefix
    !> If true, then open a binary (unformatted) file
    logical, intent(in), optional :: binary
    character(len = :), allocatable :: file_name
    character(len=11) :: formtxt
    file_name = get_modified_file_path(run_name, prefix, ext)
    formtxt = "formatted"
    if (get_option_with_default(binary, .false.)) formtxt = "unformatted"
    open(newunit=unit, file=file_name, status="replace", action="write", form=trim(formtxt))
  end subroutine open_output_file

  !> Open an output file to write (appending if existing) whose name is
  !> `<run_name>.<ext>`, and set `unit` to the unit number of that
  !> output file. If the optional `run_name_in` variable is present, this
  !> replaces run_name as the root of the output file.
  subroutine append_output_file (unit, ext, prefix, run_name_in)
    use optionals, only: get_option_with_default
    implicit none
    !> Unit number of opened file, in append mode
    integer, intent (out) :: unit
    !> File extension to open, appended to [[file_utils:run_name]]
    character (*), intent (in) :: ext, prefix
    !> Optional root name for the output file. If not specified,
    !> [[file_utils:run_name]] is used as the root.
    character (*), intent (in), optional :: run_name_in
    character(len=:), allocatable :: file_name
    logical :: exists
    file_name = get_modified_file_path(get_option_with_default(run_name_in, run_name), &
         prefix, ext)
    inquire(file=file_name, exist=exists)
    if (exists) then
       open(newunit=unit, file=trim(file_name), status="old", position="append", &
            action="write")
    else
      open(newunit=unit, file=trim(file_name), status="new", action="write")
    end if
  end subroutine append_output_file

  !> Close the file associated with `unit`
  !>
  !> FIXME: Remove
  subroutine close_output_file (unit)
    implicit none
    !> Unit of file to close
    integer, intent (in) :: unit
    close (unit=unit)
  end subroutine close_output_file

  !> Open error file and record associated lun/unit
  subroutine init_error_unit (open_it)
    use mp, only : set_default_error_file_unit
    implicit none
    !> If true, open the file, otherwise do nothing
    logical, intent (in) :: open_it
    error_unit_no = invalid_unit
    if (run_name /= "unknown" .and. open_it) &
       call open_output_file (error_unit_no, ".error")
    ! Set mp's error file so that we don't have to set it in every
    ! call to mp_abort
    call set_default_error_file_unit(error_unit_no)
  end subroutine init_error_unit

  !> Open exit_reason file and record associated lun/unit
  subroutine init_exit_reason_unit (open_it)
    implicit none
    !> If true, open the file, otherwise do nothing
    logical, intent (in) :: open_it
    exit_reason_unit_no = invalid_unit
    if (run_name /= "unknown" .and. open_it) &
       call open_output_file (exit_reason_unit_no, ".exit_reason")
  end subroutine init_exit_reason_unit

  !> Replaces each horizontal tab with a single space
  subroutine replace_all_tabs (line)
    use iso_c_binding, only: C_HORIZONTAL_TAB
    implicit none
    !> Text to modify in-place
    character(*), intent (in out) :: line
    integer :: tab_location, length, counter
    tab_location = scan(line, C_HORIZONTAL_TAB)
    length = len(line)
    counter = 1
    do while (tab_location > 0 .and. counter <= length)
       !Replace tab with a single space
       line(tab_location:tab_location) = ' '
       !Update tab_location
       tab_location = scan(line, C_HORIZONTAL_TAB)
       counter = counter+1
    end do
  end subroutine replace_all_tabs

  !> Replaces all leading tabs with space.
  !> Note we consider any tabs appearing before the first non-space/tab character.
  subroutine replace_leading_tabs (line)
    use iso_c_binding, only: C_HORIZONTAL_TAB
    implicit none
    !> Text to modify in-place
    character(*), intent (in out) :: line
    integer :: tab_location, i, length
    tab_location = scan(line, C_HORIZONTAL_TAB)
    ! If there are no tabs in the line then return immediately
    if (tab_location == 0) return

    length = len(line)

    ! Consider each character in turn
    do i = 1, length
       if (line(i:i) == ' ') then
          ! If it is a space then just move to next character
          cycle
       else if (line(i:i) == C_HORIZONTAL_TAB) then
          ! If it is a tab replace with a space and move to next character
          line(i:i) = ' '
          cycle
       else
          ! We've reached a non-space/tab character so can stop checking
          exit
       end if
    end do
  end subroutine replace_leading_tabs
  
  !> Remove Fortran comments (`!`) from `line`
  subroutine strip_comments (line)
    implicit none
    !> Text to modify in-place
    character(*), intent (in out) :: line
    logical :: in_single_quotes, in_double_quotes
    integer :: i, length

    length = len_trim(line)
    i = 1
    in_single_quotes = .false.
    in_double_quotes = .false.
    loop: do
       if (in_single_quotes) then
          if (line(i:i) == "'") in_single_quotes = .false.
       else if (in_double_quotes) then
          if (line(i:i) == '"') in_double_quotes = .false.
       else
          select case (line(i:i))
          case ("'")
             in_single_quotes = .true.
          case ('"')
             in_double_quotes = .true.
          case ("!")
             i = i - 1
             exit loop
          end select
       end if
       if (i >= length) exit loop
       i = i + 1
    end do loop
    line = line(1:i)
  end subroutine strip_comments

  !> Create a directory based on the passed path. We obtain the dirname
  !> from path_like so one may pass the path to a file and only the directory
  !> up to the file will be created.
  subroutine mkdir(path_like, make_parents)
    use optionals, only: get_option_with_default
    character(len = *), intent(in) :: path_like
    logical, intent(in), optional :: make_parents
    character(len = :), allocatable :: command, dir
    ! Note here we hard code the command name, this _could_ be
    ! defined at compile time or determined based on run time properties
    command = 'mkdir'
    dir = dirname(path_like)
    if (len_trim(dir) == 0) return
    if (get_option_with_default(make_parents, .true.)) command = command // " -p "
    call execute_command_line(command // dir)
  end subroutine mkdir

  !> Takes a path like string and tries to split it into a dirname and basename
  pure subroutine split_dir_and_base(path_like, separator, dirname, basename)
    use optionals, only: get_option_with_default
    character(len = *), intent(in) :: path_like
    character, intent(in), optional :: separator
    character(len = :), allocatable, intent(out), optional :: dirname, basename
    integer :: ind_separator
    ind_separator = index(path_like, get_option_with_default(separator, '/'), .true.)

    if (ind_separator == 0) then
       ! No separator found
       if (present(dirname)) dirname = ''
       if (present(basename)) basename = trim(path_like)
    else
       if (present(dirname)) dirname = trim(path_like(1:ind_separator))
       if (present(basename)) then
          ! Check that path_like isn't just a directory path, i.e. that there _is_ a file
          if (ind_separator < len_trim(path_like)) then
             basename = trim(path_like(ind_separator+1:))
          else
             basename = ''
          end if
       end if
    end if
  end subroutine split_dir_and_base

  !> Returns the dirname of a passed path like string. Will be '' if path just a file
  pure function dirname(path_like, separator)
    use optionals, only: get_option_with_default
    character(len = *), intent(in) :: path_like
    character, intent(in), optional :: separator
    character(len = :), allocatable :: dirname
    call split_dir_and_base(path_like, separator, dirname = dirname)
  end function dirname

  !> Returns the basename of a passed path like string. Will be '' if path just a dir
  pure function basename(path_like, separator)
    use optionals, only: get_option_with_default
    character(len = *), intent(in) :: path_like
    character, intent(in), optional :: separator
    character(len = :), allocatable :: basename
    call split_dir_and_base(path_like, separator, basename = basename)
  end function basename

  !> Opens the input file, strip out any comments and write them into the file
  !> `.<run_name>.in`. Check for includes, read any lines from the includes,
  !> strip any comments from them and add them to the same file.
  subroutine init_input_unit (open_it, remove_comments)
    use optionals, only: get_option_with_default
    implicit none
    !> If true, open the file, otherwise do nothing
    logical, intent(in) :: open_it
    logical, intent(in), optional :: remove_comments
    integer :: in_unit, out_unit, iostat, stack_ptr
    character(500) :: line
    integer, parameter :: stack_size = 10
    type(stack_type), dimension(0:stack_size) :: stack
    logical :: already_opened
    character(len=75) :: non_end_error_message
    character(len=:), allocatable :: include_file

    if (.not. open_it) then
       input_unit_no = invalid_unit
       return
    end if

    open(newunit=in_unit, file=get_modified_file_path(trim(input_name), extension = ".in"), &
         status="old", action="read", iostat=iostat)
    if (iostat /= 0) call close_stack_and_abort( &
         "Couldn't open input file: " // trim(input_name) // ".in")

    open(newunit = out_unit, file=get_modified_file_path(run_name, ".", ".in"))
    input_unit_no = out_unit

    iostat = 0 ;  num_input_lines = 0 ; stack_ptr = 0
    stack(stack_ptr) = stack_type(unit = in_unit, file_name = trim(input_name))

    do
       read (unit=in_unit, fmt="(a)", iostat=iostat) line

       ! It appears that we're using iostat / =0 to identify when
       ! we've reached the end of the current file. This therefore
       ! ignores any other possible errors. We should perhaps instead
       ! first check if iostat_is_end(iostat), if so proceed as we
       ! have here else if iostat /= 0 we have some other error and
       ! should consider aborting. Currently we just display an error
       ! message but carry on as usual.
       if (iostat /= 0) then
          if (.not. is_iostat_end(iostat)) then
             write(non_end_error_message, '(A, I0)') &
                  "Error encountered whilst reading input file with code ", iostat
             call close_stack_and_abort(non_end_error_message)
          end if
          if (stack_ptr <= 0) exit
          close (unit=in_unit)
          iostat = 0
          stack_ptr = stack_ptr - 1
          in_unit = stack(stack_ptr)%unit
          cycle
       end if

       if (line(1:9) == "!include ") then
          if (stack_ptr >= stack_size) call close_stack_and_abort( &
               "!include ignored: nesting too deep: " // trim(line))

          ! Check if we've already opened this file, if so assume this
          ! is a circular dependency and abort. Note we add the dirname of the
          ! input file (and not run_name) in order to allow relative paths which
          ! are resolved relative to the input file and not relative to where we
          ! have run from.
          include_file = dirname(stack(stack_ptr)%file_name) // trim(line(10:))
          inquire(file = include_file, opened = already_opened)
          if (already_opened) call close_stack_and_abort( &
               "Circular dependency with " // trim(line))

          open(newunit=in_unit, file=include_file, status="old", action="read", iostat=iostat)

          stack_ptr = stack_ptr + 1
          stack(stack_ptr)%unit = in_unit ; stack(stack_ptr)%file_name = include_file

          ! Here we assume that any problem with the above open is due
          ! to the file being "unreadable". This could also end up
          ! catching circular dependencies in our includes as the
          ! fortran standard forbids having the same file open with
          ! different file units (although some compilers may allow
          ! this as an extension). To help the user we first detect if
          ! this file has already been opened and if so warn for
          ! circular dependency. Here we therefore deal with all other
          ! errors.
          if (iostat /= 0) call close_stack_and_abort( &
               "!include ignored: file unreadable: " // trim(line))
          cycle
       end if
       if (get_option_with_default(remove_comments, .false.)) call strip_comments (line)
       call replace_leading_tabs(line)
       write (unit=out_unit, fmt="(a)") trim(line)
       num_input_lines = num_input_lines + 1
    end do
    close (unit=in_unit)
  contains
    !> Close all open files and abort run
    subroutine close_stack_and_abort(error_message)
      use mp, only : mp_abort
      !> Error message to print to screen and log in error file
      character(len=*), intent(in) :: error_message
      integer :: i
      do i = 0, stack_ptr
        if (unit_is_open(stack(i)%unit)) close(stack(i)%unit)
      end do
      call mp_abort(error_message, to_screen=.true.)
    end subroutine close_stack_and_abort
  end subroutine init_input_unit

  !> Close any files opened by [[init_file_utils]]
  subroutine finish_file_utils
    implicit none
    if (unit_is_open(input_unit_no)) then
       close (unit=input_unit_no, status = 'delete')
       input_unit_no = invalid_unit
    end if
    if (unit_is_open(error_unit_no) .and. error_unit_no /= std_error_unit) then
       close (unit=error_unit_no)
       error_unit_no = std_error_unit
    end if
    if (unit_is_open(exit_reason_unit_no) .and. exit_reason_unit_no /= stdout_unit) then
       close (unit=exit_reason_unit_no)
       exit_reason_unit_no = stdout_unit
    end if
    initialized = .false.
  end subroutine finish_file_utils

  !> Small wrapper to determine if a unit is open
  logical function unit_is_open(unit) result(opened)
    integer, intent(in) :: unit
    inquire(unit = unit, opened = opened)
  end function unit_is_open

  !> Rewind the input file to start of namelist `nml`, and return the unit of
  !> the file opened by [[init_input_unit]]
  integer function input_unit(nml, exist)
    implicit none
    !> Name of namelist to find start of
    character(*), intent (in) :: nml
    !> Was `nml` was found in the input file?
    logical, intent(out), optional :: exist
    integer :: iostat
    character(500) :: line
    input_unit = input_unit_no
    if (present(exist)) exist = .true.
    if (unit_is_open(input_unit_no)) then
       rewind (unit=input_unit_no)
       do
          read (unit=input_unit_no, fmt="(a)", iostat=iostat) line
          if (iostat /= 0) then
             rewind (unit=input_unit_no)
             exit
          end if
          if (trim(adjustl(line)) == "&"//nml) then
             backspace (unit=input_unit_no)
             return
          end if
       end do
    end if
    if (present(exist)) then
       exist = .false.
    else
       write (unit=error_unit_no, fmt="('Couldn''t find namelist: ',a)") nml
       write (unit=*, fmt="('Couldn''t find namelist: ',a)") nml
    end if
  end function input_unit

  !> Similar to [[input_unit]] but set `exist` to true if `nml` was found in the
  !> input file, and false otherwise
  integer function input_unit_exist (nml, exist)
    implicit none
    !> Name of namelist to find start of
    character(*), intent (in) :: nml
    !> Was `nml` was found in the input file?
    logical, intent(out) :: exist
    input_unit_exist = input_unit(nml, exist)
  end function input_unit_exist

  !> Returns the file unit number associated with the error file
  pure integer function error_unit ()
    implicit none
    error_unit = error_unit_no
  end function error_unit

  !> Returns the file unit number associated with the exit_reason file
  pure integer function exit_reason_unit ()
    implicit none
    exit_reason_unit = exit_reason_unit_no
  end function exit_reason_unit

  !> Returns the file unit number associated with the input file
  !>
  !> @note This is a subroutine unlike the functions used for error_unit
  !> and exit_reason_unit. We should think about making these consistent.
  pure subroutine get_input_unit (unit)
    implicit none
    integer, intent (out) :: unit
    unit = input_unit_no
  end subroutine get_input_unit

  !> Copy namelist, `<nml>_<index_in>`, from the input file to namelist `NML` in
  !> a temporary file with unit `unit`
  subroutine get_indexed_namelist_unit (unit, nml, index_in, exist)
    implicit none
    !> Unit of new temporary file containing the indexed namelist
    integer, intent (out) :: unit
    !> Name of indexed namelist to copy
    character (*), intent (in) :: nml
    !> Index number of namelist to copy
    integer, intent (in) :: index_in
    !> Does the indexed namelist exist or not?
    logical, intent (out) :: exist
    character(500) :: line
    integer :: iunit, iostat
    write (line, '(A,"_",I0)') nml, index_in
    iunit = input_unit_exist(trim(line), exist)
    unit = invalid_unit
    if (.not. exist) then
       write(stdout_unit,*) "get_indexed_namelist: following namelist not found ",trim(line)
       return
    end if

    open(newunit = unit, file=get_modified_file_path(run_name, ".", ".scratch"))
    read (unit=iunit, fmt="(a)") line
    write (unit=unit, fmt="('&',a)") nml

    do
       read (unit=iunit, fmt="(a)", iostat=iostat) line
       if (iostat /= 0 .or. trim(adjustl(line)) == "/") exit
       write (unit=unit, fmt="(a)") trim(line)
    end do
    write (unit=unit, fmt="('/')")
    rewind (unit=unit)
  end subroutine get_indexed_namelist_unit
end module file_utils

gyrokinetics / utils / 2078150095

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous