scrip_iounitsmod Module Reference

Functions/Subroutines
subroutine, public	scrip_iounitsget (iunit)
subroutine, public	scrip_iounitsrelease (iunit)
subroutine, public	scrip_iounitsreserve (iunit)
subroutine, public	scrip_iounitsredirect (iunit, filename)
subroutine, public	scrip_iounitsflush (iunit)

Variables
integer(scrip_i4), parameter, public	scrip_stdin = 5
integer(scrip_i4), parameter, public	scrip_stdout = 6
integer(scrip_i4), parameter, public	scrip_stderr = 6
character(9), parameter, public	scrip_delimformat = "(72('-'))"
character(5), parameter, public	scrip_blankformat = "(' ')"

Function/Subroutine Documentation

scrip_iounitsflush()

subroutine, public scrip_iounitsmod::scrip_iounitsflush

(

integer (scrip_i4), intent(in)

iunit

)

Definition at line 351 of file scrip_iounitsmod.f90.

 
    ! !DESCRIPTION:
    ! This routine enables a user to flush the output from an IO unit
    ! (typically stdout) to force output when the system is buffering
    ! such output. Because this system function is system dependent,
    ! we only support this wrapper and users are welcome to insert the
    ! code relevant to their local machine.
    !
    ! !REVISION HISTORY:
    ! same as module
 
    ! !INPUT PARAMETER:
 
    integer (SCRIP_i4), intent(in) :: &
         iunit ! i/o unit to be flushed
 
    !EOP
    !BOC
    !-----------------------------------------------------------------------
    !
    ! insert your system code here
    !
    !-----------------------------------------------------------------------
 
    !-----------------------------------------------------------------------
    !EOC
 

scrip_iounitsget()

subroutine, public scrip_iounitsmod::scrip_iounitsget

(

integer (scrip_i4), intent(out)

iunit

)

Definition at line 89 of file scrip_iounitsmod.f90.

 
    ! !DESCRIPTION:
    ! This routine returns the next available i/o unit and marks it as
    ! in use to prevent any later use.
    ! Note that {\em all} processors must call this routine even if only
    ! the master task is doing the i/o. This is necessary insure that
    ! the units remain synchronized for other parallel I/O functions.
    !
    ! !REVISION HISTORY:
    ! same as module
 
    ! !OUTPUT PARAMETERS:
 
    integer (SCRIP_i4), intent(out) :: &
         iunit ! next free i/o unit
 
    !EOP
    !BOC
    !-----------------------------------------------------------------------
    !
    ! local variables
    !
    !-----------------------------------------------------------------------
 
    integer (SCRIP_i4) :: n ! dummy loop index
 
    logical (SCRIP_Logical) :: alreadyInUse
 
    !-----------------------------------------------------------------------
    !
    ! check to see if units initialized and initialize if necessary
    !
    !-----------------------------------------------------------------------
 
    if (.not. scrip_iounitsinitialized) then
      scrip_iounitsinuse = .false.
      scrip_iounitsinuse(scrip_stdin) = .true.
      scrip_iounitsinuse(scrip_stdout) = .true.
      scrip_iounitsinuse(scrip_stderr) = .true.
 
      scrip_iounitsinitialized = .true.
    endif
 
    !-----------------------------------------------------------------------
    !
    ! find next free unit
    !
    !-----------------------------------------------------------------------
 
    srch_units: do n=scrip_iounitsminunits, scrip_iounitsmaxunits
      if (.not. scrip_iounitsinuse(n)) then ! I found one, I found one
 
        !*** make sure not in use by library or calling routines
        INQUIRE (unit=n,opened=alreadyinuse)
 
        if (.not. alreadyinuse) then
          iunit = n ! return the free unit number
          scrip_iounitsinuse(iunit) = .true. ! mark iunit as being in use
          exit srch_units
        else
          !*** if inquire shows this unit in use, mark it as
          !*** in use to prevent further queries
          scrip_iounitsinuse(n) = .true.
        endif
      endif
    end do srch_units
 
    if (iunit > scrip_iounitsmaxunits) &
         stop 'SCRIP_IOUnitsGet: No free units'
 
    !-----------------------------------------------------------------------
    !EOC
 

References scrip_stderr, scrip_stdin, and scrip_stdout.

scrip_iounitsredirect()

subroutine, public scrip_iounitsmod::scrip_iounitsredirect	(	integer (scrip_i4), intent(in)	iunit,
		character (*), intent(in)	filename
	)

Definition at line 295 of file scrip_iounitsmod.f90.

 
    ! !DESCRIPTION:
    ! This routine enables a user to redirect stdin, stdout, stderr to
    ! a file instead of to the terminal. It is only permitted for these
    ! special units. The SCRIP IO file operators should be used for
    ! normal I/O.
    ! Note that {\em all} processors must call this routine even if only
    ! the master task is doing the i/o. This is necessary insure that
    ! the units remains synchronized for other parallel I/O functions.
    !
    ! !REVISION HISTORY:
    ! same as module
 
    ! !INPUT PARAMETER:
 
    integer (SCRIP_i4), intent(in) :: &
         iunit ! i/o unit to be redirected to file
 
    character (*), intent(in) :: &
         filename ! filename, including path, to which
    ! i/o should be directed
 
    !EOP
    !BOC
    !-----------------------------------------------------------------------
    !
    ! check for proper unit number and open file
    !
    !-----------------------------------------------------------------------
 
    if (iunit == scrip_stdin) then ! open input file for stdin
      open(unit=iunit, file=filename, status='old', form='formatted')
 
    else if (iunit == scrip_stdout) then ! open output file for stdout
      open(unit=iunit, file=filename, status='unknown', form='formatted')
 
    else if (iunit == scrip_stderr .and. scrip_stderr /= scrip_stdout) then
      ! open output file for stderr
      open(unit=iunit, file=filename, status='unknown', form='formatted')
 
    else
      stop 'SCRIP_IOUnitsRedirect: invalid unit'
 
    endif
 
    !-----------------------------------------------------------------------
    !EOC
 

References file(), scrip_stderr, scrip_stdin, and scrip_stdout.

scrip_iounitsrelease()

subroutine, public scrip_iounitsmod::scrip_iounitsrelease

(

integer (scrip_i4), intent(in)

iunit

)

Definition at line 170 of file scrip_iounitsmod.f90.

 
    ! !DESCRIPTION:
    ! This routine releases an i/o unit (marks it as available).
    ! Note that {\em all} processors must call this routine even if only
    ! the master task is doing the i/o. This is necessary insure that
    ! the units remain synchronized for other parallel I/O functions.
    !
    ! !REVISION HISTORY:
    ! same as module
 
    ! !INPUT PARAMETER:
 
    integer (SCRIP_i4), intent(in) :: &
         iunit ! i/o unit to be released
 
    !EOP
    !BOC
    !-----------------------------------------------------------------------
    !
    ! check for proper unit number
    !
    !-----------------------------------------------------------------------
 
    if (iunit < 1 .or. iunit > scrip_iounitsmaxunits) then
      stop 'SCRIP_IOUnitsRelease: bad unit'
    endif
 
    !-----------------------------------------------------------------------
    !
    ! mark the unit as not in use
    !
    !-----------------------------------------------------------------------
 
    scrip_iounitsinuse(iunit) = .false. ! that was easy...
 
    !-----------------------------------------------------------------------
    !EOC
 

scrip_iounitsreserve()

subroutine, public scrip_iounitsmod::scrip_iounitsreserve

(

integer (scrip_i4), intent(in)

iunit

)

Definition at line 216 of file scrip_iounitsmod.f90.

 
    ! !DESCRIPTION:
    ! This routine marks an IO unit as in use to reserve its use
    ! for purposes outside of SCRIP IO. This is necessary for
    ! cases where you might be importing code developed elsewhere
    ! that performs its own I/O and open/closes units.
    ! Note that {\em all} processors must call this routine even if only
    ! the master task is doing the i/o. This is necessary insure that
    ! the units remains synchronized for other parallel I/O functions.
    !
    ! !REVISION HISTORY:
    ! same as module
 
    ! !INPUT PARAMETER:
 
    integer (SCRIP_i4), intent(in) :: &
         iunit ! i/o unit to be reserved
 
    !EOP
    !BOC
    !-----------------------------------------------------------------------
    !
    ! local variables
    !
    !-----------------------------------------------------------------------
 
    logical (SCRIP_Logical) :: alreadyInUse
 
    !-----------------------------------------------------------------------
    !
    ! check for proper unit number
    !
    !-----------------------------------------------------------------------
 
    if (iunit < scrip_iounitsminunits .or. &
         iunit > scrip_iounitsmaxunits) then
      stop 'SCRIP_IOUnitsReserve: invalid unit'
    endif
 
    !-----------------------------------------------------------------------
    !
    ! check to see if SCRIP already using this unit
    !
    !-----------------------------------------------------------------------
 
    if (scrip_iounitsinuse(iunit)) then
      stop 'SCRIP_IOUnitsReserve: unit already in use by SCRIP'
    endif
 
    !-----------------------------------------------------------------------
    !
    ! check to see if others already using this unit
    !
    !-----------------------------------------------------------------------
 
    INQUIRE (unit=iunit, opened=alreadyinuse)
    if (alreadyinuse) then
      stop 'SCRIP_IOUnitsReserve: unit already in use by others'
    endif
 
    !-----------------------------------------------------------------------
    !
    ! mark the unit as in use
    !
    !-----------------------------------------------------------------------
 
    scrip_iounitsinuse(iunit) = .true.
 
    !-----------------------------------------------------------------------
    !EOC
 

Variable Documentation

scrip_blankformat

character (5), parameter, public scrip_iounitsmod::scrip_blankformat = "(' ')"

Definition at line 57 of file scrip_iounitsmod.f90.

  character (5), parameter, public :: &
       SCRIP_blankFormat = "(' ')"

Referenced by scrip_errormod::scrip_errorprint().

scrip_delimformat

character (9), parameter, public scrip_iounitsmod::scrip_delimformat = "(72('-'))"

Definition at line 54 of file scrip_iounitsmod.f90.

  character (9), parameter, public :: &
       SCRIP_delimFormat = "(72('-'))"

Referenced by scrip_errormod::scrip_errorprint().

scrip_stderr

integer (scrip_i4), parameter, public scrip_iounitsmod::scrip_stderr = 6

Definition at line 47 of file scrip_iounitsmod.f90.

Referenced by scrip_errormod::scrip_errorprint(), scrip_iounitsget(), and scrip_iounitsredirect().

scrip_stdin

integer (scrip_i4), parameter, public scrip_iounitsmod::scrip_stdin = 5

Definition at line 47 of file scrip_iounitsmod.f90.

  integer (SCRIP_i4), parameter, public :: &
       SCRIP_stdin = 5, &! reserved unit for standard input
       scrip_stdout = 6, &! reserved unit for standard output
       scrip_stderr = 6 ! reserved unit for standard error

Referenced by scrip_iounitsget(), and scrip_iounitsredirect().

scrip_stdout

integer (scrip_i4), parameter, public scrip_iounitsmod::scrip_stdout = 6

Definition at line 47 of file scrip_iounitsmod.f90.

Referenced by scrip_grids::grid_init(), scrip_interface::scrip(), scrip_errormod::scrip_errorprint(), scrip_iounitsget(), and scrip_iounitsredirect().