bytes_io_mod.F90

Go to the documentation of this file.

MODULE bytes_io_mod !**** Interface to BYTES_IO

!     Purpose.
!     --------
!     Fortran 90 Interface to calling byte IO 

!     Author.
!     -------
!        W.Deconinck and M.Hamrud     ECMWF

!     Modifications.
!     --------------
!        Original: 2016-01-28

!     ------------------------------------------------------------------

USE parkind1 , ONLY : jprd, jpim, jpib, jprb, jprm
USE yomhook  , ONLY : lhook, dr_hook
#ifdef SFX_MPI
USE mpl_module, ONLY : mpl_abort
#endif

IMPLICIT NONE

PRIVATE :: jprd, jpim, jpib, jprb, jprm
PRIVATE :: lhook, dr_hook
#ifdef SFX_MPI
PRIVATE :: mpl_abort
#endif
PRIVATE

INTERFACE bytes_io_read
MODULE PROCEDURE bytes_io_read_jpim_int
MODULE PROCEDURE bytes_io_read_jpim_int_array
MODULE PROCEDURE bytes_io_read_jpim_real4
MODULE PROCEDURE bytes_io_read_jpim_real4_array
MODULE PROCEDURE bytes_io_read_jpim_real8
MODULE PROCEDURE bytes_io_read_jpim_real8_array
MODULE PROCEDURE bytes_io_read_jpim_char_array

MODULE PROCEDURE bytes_io_read_jpib_int
MODULE PROCEDURE bytes_io_read_jpib_int_array
MODULE PROCEDURE bytes_io_read_jpib_real4
MODULE PROCEDURE bytes_io_read_jpib_real4_array
MODULE PROCEDURE bytes_io_read_jpib_real8
MODULE PROCEDURE bytes_io_read_jpib_real8_array
MODULE PROCEDURE bytes_io_read_jpib_char_array
END INTERFACE

INTERFACE bytes_io_write
MODULE PROCEDURE bytes_io_write_jpim_int
MODULE PROCEDURE bytes_io_write_jpim_int_array
MODULE PROCEDURE bytes_io_write_jpim_real4
MODULE PROCEDURE bytes_io_write_jpim_real4_array
MODULE PROCEDURE bytes_io_write_jpim_real8
MODULE PROCEDURE bytes_io_write_jpim_real8_array
MODULE PROCEDURE bytes_io_write_jpim_char_array

MODULE PROCEDURE bytes_io_write_jpib_int
MODULE PROCEDURE bytes_io_write_jpib_int_array
MODULE PROCEDURE bytes_io_write_jpib_real4
MODULE PROCEDURE bytes_io_write_jpib_real4_array
MODULE PROCEDURE bytes_io_write_jpib_real8
MODULE PROCEDURE bytes_io_write_jpib_real8_array
MODULE PROCEDURE bytes_io_write_jpib_char_array
END INTERFACE

PUBLIC :: bytes_io_open
PUBLIC :: bytes_io_close
PUBLIC :: bytes_io_write
PUBLIC :: bytes_io_read
PUBLIC :: bytes_io_seek
PUBLIC :: bytes_io_tell

INTEGER, PARAMETER, PUBLIC :: jpbytes_io_success=0
INTEGER, PARAMETER :: jpbytes_io_could_not_open_file=-1
INTEGER, PARAMETER :: jpbytes_io_could_not_close_file=-1
INTEGER, PARAMETER :: jpbytes_io_invalid_file_name=-2
INTEGER, PARAMETER :: jpbytes_io_invalid_open_mode=-3
INTEGER, PARAMETER :: jpbytes_io_end_of_file=-1
INTEGER, PARAMETER :: jpbytes_io_seek_error=-2
INTEGER, PARAMETER :: jpbytes_io_read_jpim_error=-2
INTEGER, PARAMETER :: jpbytes_io_write_jpim_error=-1

CONTAINS


SUBROUTINE bytes_io_open(KFILE,CDPATH,CDMODE,KRET)
INTEGER(KIND=JPIM),INTENT(OUT)  :: KFILE
CHARACTER(LEN=*)  ,INTENT(IN)   :: CDPATH
CHARACTER(LEN=1)  ,INTENT(IN)   :: CDMODE
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET
INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_OPEN',0,zhook_handle)
CALL c_bytes_io_open(kfile,cdpath,cdmode,iret)
IF(PRESENT(kret)) THEN
  kret = iret
ELSEIF (iret < jpbytes_io_success) THEN
  WRITE(0,*) 'BYTES_IO ',trim(cdpath),' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_OPEN FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_OPEN',1,zhook_handle)
END SUBROUTINE bytes_io_open

SUBROUTINE bytes_io_close(KFILE,KRET)
INTEGER(KIND=JPIM),INTENT(IN)  :: KFILE
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET
INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_CLOSE',0,zhook_handle)
CALL c_bytes_io_close(kfile,iret)
IF(PRESENT(kret)) THEN
  kret = iret
ELSEIF (iret < jpbytes_io_success) THEN
  WRITE(0,*) 'BYTES_IO_CLOSE ',kfile,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_CLOSE FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_CLOSE',1,zhook_handle)
END SUBROUTINE bytes_io_close


SUBROUTINE bytes_io_seek(KFILE,KOFFSET,KWHENCE,KRET)
INTEGER(KIND=JPIM),INTENT(IN) :: KFILE
INTEGER(KIND=JPIM),INTENT(IN) :: KOFFSET 
INTEGER(KIND=JPIM),INTENT(IN) :: KWHENCE
INTEGER(KIND=JPIM),INTENT(OUT), OPTIONAL :: KRET
INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_SEEK',0,zhook_handle)
CALL c_bytes_io_seek(kfile,koffset,kwhence,iret)
IF(PRESENT(kret)) THEN
  kret=iret
ELSEIF(iret < jpbytes_io_success) THEN
  WRITE(0,*) 'BYTES_IO_SEEK ',kfile,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_SEEK FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_SEEK',1,zhook_handle)
END SUBROUTINE bytes_io_seek


SUBROUTINE bytes_io_tell(KFILE,KRET)
INTEGER(KIND=JPIM),INTENT(IN) :: KFILE
INTEGER(KIND=JPIM),INTENT(OUT), OPTIONAL :: KRET
INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_SEEK',0,zhook_handle)
CALL c_bytes_io_tell(kfile,iret)
IF(PRESENT(kret)) THEN
  kret=iret
ELSEIF(iret < jpbytes_io_success) THEN
  WRITE(0,*) 'BYTES_IO_TELL ',kfile,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_TELL FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_TELL',1,zhook_handle)
END SUBROUTINE bytes_io_tell

! ============================================
! BYTES_IO_READ_JPIM

SUBROUTINE bytes_io_read_jpim_int(KFILE,KBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
INTEGER(KIND=JPIM),INTENT(OUT)   :: KBUF
INTEGER(KIND=JPIM),INTENT(IN)    :: KBYTES
INTEGER(KIND=JPIM),INTENT(OUT), OPTIONAL   :: KRET
INTEGER(KIND=JPIM) :: IRET,ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIM_INT',0,zhook_handle)
CALL c_bytes_io_read(kfile,kbuf,kbytes,iret)
IF(PRESENT(kret)) THEN
  kret=iret
ELSEIF(iret < jpbytes_io_success .AND. iret < jpbytes_io_end_of_file ) THEN
  WRITE(0,*) 'BYTES_IO_READ_JPIM_INT ',kfile,' ',kbytes,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_READ_JPIM_INT FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIM_INT',1,zhook_handle)
END SUBROUTINE bytes_io_read_jpim_int

SUBROUTINE bytes_io_read_jpim_int_array(KFILE,KBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
INTEGER(KIND=JPIM),INTENT(OUT)   :: KBUF(:)
INTEGER(KIND=JPIM),INTENT(IN)    :: KBYTES
INTEGER(KIND=JPIM),INTENT(OUT), OPTIONAL   :: KRET
INTEGER(KIND=JPIM) :: IRET,ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIM_INT_ARRAY',0,zhook_handle)
CALL c_bytes_io_read(kfile,kbuf,kbytes,iret)
IF(PRESENT(kret)) THEN
  kret=iret
ELSEIF(iret < jpbytes_io_success .AND. iret < jpbytes_io_end_of_file ) THEN
  WRITE(0,*) 'BYTES_IO_READ_JPIM_INT_ARRAY ',kfile,' ',kbytes,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_READ_JPIM_INT_ARRAY FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIM_INT_ARRAY',1,zhook_handle)
END SUBROUTINE bytes_io_read_jpim_int_array

SUBROUTINE bytes_io_read_jpim_real4(KFILE,PBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
REAL(KIND=JPRM),INTENT(OUT)      :: PBUF
INTEGER(KIND=JPIM),INTENT(IN)    :: KBYTES
INTEGER(KIND=JPIM),INTENT(OUT), OPTIONAL   :: KRET
INTEGER(KIND=JPIM) :: IRET,ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIM_REAL4',0,zhook_handle)
CALL c_bytes_io_read(kfile,pbuf,kbytes,iret)
IF(PRESENT(kret)) THEN
  kret=iret
ELSEIF(iret < jpbytes_io_success .AND. iret < jpbytes_io_end_of_file ) THEN
  WRITE(0,*) 'BYTES_IO_READ_JPIM_REAL4 ',kfile,' ',kbytes,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_READ_JPIM_REAL4 FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIM_REAL4',1,zhook_handle)
END SUBROUTINE bytes_io_read_jpim_real4

SUBROUTINE bytes_io_read_jpim_real4_array(KFILE,PBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
REAL(KIND=JPRM),INTENT(OUT)      :: PBUF(:)
INTEGER(KIND=JPIM),INTENT(IN)    :: KBYTES
INTEGER(KIND=JPIM),INTENT(OUT), OPTIONAL   :: KRET
INTEGER(KIND=JPIM) :: IRET,ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIM_REAL4_ARRAY',0,zhook_handle)
CALL c_bytes_io_read(kfile,pbuf,kbytes,iret)
IF(PRESENT(kret)) THEN
  kret=iret
ELSEIF(iret < jpbytes_io_success .AND. iret < jpbytes_io_end_of_file ) THEN
  WRITE(0,*) 'BYTES_IO_READ_JPIM_REAL4_ARRAY ',kfile,' ',kbytes,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_READ_JPIM_REAL4_ARRAY FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIM_REAL4_ARRAY',1,zhook_handle)
END SUBROUTINE bytes_io_read_jpim_real4_array

SUBROUTINE bytes_io_read_jpim_real8(KFILE,PBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
REAL(KIND=JPRD),INTENT(OUT)      :: PBUF
INTEGER(KIND=JPIM),INTENT(IN)    :: KBYTES
INTEGER(KIND=JPIM),INTENT(OUT), OPTIONAL   :: KRET
INTEGER(KIND=JPIM) :: IRET,ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIM_REAL8',0,zhook_handle)
CALL c_bytes_io_read(kfile,pbuf,kbytes,iret)
IF(PRESENT(kret)) THEN
  kret=iret
ELSEIF(iret < jpbytes_io_success .AND. iret < jpbytes_io_end_of_file ) THEN
  WRITE(0,*) 'BYTES_IO_READ_JPIM_REAL8 ',kfile,' ',kbytes,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_READ_JPIM_REAL8 FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIM_REAL8',1,zhook_handle)
END SUBROUTINE bytes_io_read_jpim_real8

SUBROUTINE bytes_io_read_jpim_real8_array(KFILE,PBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
REAL(KIND=JPRD),INTENT(OUT)      :: PBUF(:)
INTEGER(KIND=JPIM),INTENT(IN)    :: KBYTES
INTEGER(KIND=JPIM),INTENT(OUT), OPTIONAL   :: KRET
INTEGER(KIND=JPIM) :: IRET,ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIM_REAL8_ARRAY',0,zhook_handle)
CALL c_bytes_io_read(kfile,pbuf,kbytes,iret)
IF(PRESENT(kret)) THEN
  kret=iret
ELSEIF(iret < jpbytes_io_success .AND. iret < jpbytes_io_end_of_file ) THEN
  WRITE(0,*) 'BYTES_IO_READ_JPIM_REAL8_ARRAY ',kfile,' ',kbytes,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_READ_JPIM_REAL8_ARRAY FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIM_REAL8_ARRAY',1,zhook_handle)
END SUBROUTINE bytes_io_read_jpim_real8_array

SUBROUTINE bytes_io_read_jpim_char_array(KFILE,CDBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
CHARACTER(LEN=1)  ,INTENT(OUT)   :: CDBUF(:)
INTEGER(KIND=JPIM),INTENT(INOUT) :: KBYTES
INTEGER(KIND=JPIM),INTENT(OUT), OPTIONAL   :: KRET
INTEGER(KIND=JPIM) :: IRET,ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIM_CHAR_ARRAY',0,zhook_handle)
CALL c_bytes_io_read(kfile,cdbuf,kbytes,iret)
IF(PRESENT(kret)) THEN
  kret=iret
ELSEIF(iret < jpbytes_io_success .AND. iret < jpbytes_io_end_of_file ) THEN
  WRITE(0,*) 'BYTES_IO_READ_JPIM_CHAR_ARRAY ',kfile,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_READ_JPIM_CHAR_ARRAY FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIM_CHAR_ARRAY',1,zhook_handle)
END SUBROUTINE bytes_io_read_jpim_char_array


! ============================================
! BYTES_IO_WRITE_JPIM

SUBROUTINE bytes_io_write_jpim_int(KFILE,PBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
INTEGER(KIND=JPIM),INTENT(IN)    :: PBUF
INTEGER(KIND=JPIM),INTENT(IN)    :: KBYTES
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET
INTEGER(KIND=JPIM) :: IRET
INTEGER(KIND=JPIM) :: ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIM_INT',0,zhook_handle)

CALL c_bytes_io_write(kfile,pbuf,kbytes,iret)
IF(PRESENT(kret)) THEN
  kret=iret
ENDIF
IF(iret < jpbytes_io_success ) THEN
  WRITE(0,*) 'BYTES_IO_WRITE_JPIM_INT ',kfile,' ',kbytes,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_WRITE_JPIM_INT FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIM_INT',1,zhook_handle)
END SUBROUTINE bytes_io_write_jpim_int

SUBROUTINE bytes_io_write_jpim_int_array(KFILE,PBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
INTEGER(KIND=JPIM),INTENT(IN)    :: PBUF(:)
INTEGER(KIND=JPIM),INTENT(IN)    :: KBYTES
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET
INTEGER(KIND=JPIM) :: IRET
INTEGER(KIND=JPIM) :: ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIM_INT',0,zhook_handle)

CALL c_bytes_io_write(kfile,pbuf,kbytes,iret)
IF(PRESENT(kret)) THEN
  kret=iret
ENDIF
IF(iret < jpbytes_io_success ) THEN
  WRITE(0,*) 'BYTES_IO_WRITE_JPIM_INT ',kfile,' ',kbytes,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_WRITE_JPIM_INT FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIM_INT',1,zhook_handle)
END SUBROUTINE bytes_io_write_jpim_int_array

SUBROUTINE bytes_io_write_jpim_real4(KFILE,PBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
REAL(KIND=JPRM),INTENT(IN)    :: PBUF
INTEGER(KIND=JPIM),INTENT(IN)    :: KBYTES
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET
INTEGER(KIND=JPIM) :: IRET
INTEGER(KIND=JPIM) :: ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIM_REAL4',0,zhook_handle)

CALL c_bytes_io_write(kfile,pbuf,kbytes,iret)
IF(PRESENT(kret)) THEN
  kret=iret
ENDIF
IF(iret < jpbytes_io_success ) THEN
  WRITE(0,*) 'BYTES_IO_WRITE_JPIM_REAL4 ',kfile,' ',kbytes,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_WRITE_JPIM_REAL4 FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIM_REAL4',1,zhook_handle)
END SUBROUTINE bytes_io_write_jpim_real4

SUBROUTINE bytes_io_write_jpim_real4_array(KFILE,PBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
REAL(KIND=JPRM),INTENT(IN)       :: PBUF(:)
INTEGER(KIND=JPIM),INTENT(IN)    :: KBYTES
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET
INTEGER(KIND=JPIM) :: IRET
INTEGER(KIND=JPIM) :: ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIM_REAL4_ARRAY',0,zhook_handle)
CALL c_bytes_io_write(kfile,pbuf,kbytes,iret)
IF(PRESENT(kret)) THEN
  kret=iret
ENDIF
IF(iret < jpbytes_io_success ) THEN
  WRITE(0,*) 'BYTES_IO_WRITE_JPIM_REAL4_ARRAY ',kfile,' ',kbytes,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_WRITE_JPIM_REAL4_ARRAY FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIM_REAL4_ARRAY',1,zhook_handle)
END SUBROUTINE bytes_io_write_jpim_real4_array


SUBROUTINE bytes_io_write_jpim_real8(KFILE,PBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
REAL(KIND=JPRD),INTENT(IN)    :: PBUF
INTEGER(KIND=JPIM),INTENT(IN)    :: KBYTES
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET
INTEGER(KIND=JPIM) :: IRET
INTEGER(KIND=JPIM) :: ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIM_REAL8',0,zhook_handle)
CALL c_bytes_io_write(kfile,pbuf,kbytes,iret)
IF(PRESENT(kret)) THEN
  kret=iret
ENDIF
IF(iret < jpbytes_io_success ) THEN
  WRITE(0,*) 'BYTES_IO_WRITE_JPIM_REAL8 ',kfile,' ',kbytes,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_WRITE_JPIM_REAL8 FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIM_REAL8',1,zhook_handle)
END SUBROUTINE bytes_io_write_jpim_real8

SUBROUTINE bytes_io_write_jpim_real8_array(KFILE,PBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
REAL(KIND=JPRD),INTENT(IN)       :: PBUF(:)
INTEGER(KIND=JPIM),INTENT(IN)    :: KBYTES
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET
INTEGER(KIND=JPIM) :: IRET
INTEGER(KIND=JPIM) :: ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIM_REAL8_ARRAY',0,zhook_handle)
CALL c_bytes_io_write(kfile,pbuf,kbytes,iret)
IF(PRESENT(kret)) THEN
  kret=iret
ENDIF
IF(iret < jpbytes_io_success ) THEN
  WRITE(0,*) 'BYTES_IO_WRITE_JPIM_REAL8_ARRAY ',kfile,' ',kbytes,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_WRITE_JPIM_REAL8_ARRAY FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIM_REAL8_ARRAY',1,zhook_handle)
END SUBROUTINE bytes_io_write_jpim_real8_array

SUBROUTINE bytes_io_write_jpim_char_array(KFILE,CDBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
CHARACTER(LEN=1)  ,INTENT(IN)    :: CDBUF(:)
INTEGER(KIND=JPIM),INTENT(INOUT) :: KBYTES
INTEGER(KIND=JPIM),INTENT(OUT), OPTIONAL :: KRET
INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIM_CHAR_ARRAY',0,zhook_handle)
CALL c_bytes_io_write(kfile,cdbuf,kbytes,iret)
IF(PRESENT(kret)) THEN
  kret=iret
ELSEIF(iret < jpbytes_io_success) THEN
  WRITE(0,*) 'BYTES_IO_WRITE_JPIM_CHAR_ARRAY ',kfile,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_WRITE_JPIM_CHAR_ARRAY FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIM_CHAR_ARRAY',1,zhook_handle)
END SUBROUTINE bytes_io_write_jpim_char_array

! ============================================
! BYTES_IO_READ_JPIB

SUBROUTINE bytes_io_read_jpib_int(KFILE,KBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
INTEGER(KIND=JPIM),INTENT(OUT)   :: KBUF
INTEGER(KIND=JPIB),INTENT(IN)    :: KBYTES
INTEGER(KIND=JPIM),INTENT(OUT), OPTIONAL   :: KRET
INTEGER(KIND=JPIM) :: IRET,ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIB_INT',0,zhook_handle)
CALL c_bytes_io_read(kfile,kbuf,int(kbytes,jpim),iret)
IF(PRESENT(kret)) THEN
  kret=iret
ELSEIF(iret < jpbytes_io_success .AND. iret < jpbytes_io_end_of_file ) THEN
  WRITE(0,*) 'BYTES_IO_READ_JPIB_INT ',kfile,' ',kbytes,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_READ_JPIB_INT FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIB_INT',1,zhook_handle)
END SUBROUTINE bytes_io_read_jpib_int

SUBROUTINE bytes_io_read_jpib_int_array(KFILE,KBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
INTEGER(KIND=JPIM),INTENT(OUT)   :: KBUF(:)
INTEGER(KIND=JPIB),INTENT(IN)    :: KBYTES
INTEGER(KIND=JPIM),INTENT(OUT), OPTIONAL   :: KRET
INTEGER(KIND=JPIM) :: IRET,ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIB_INT_ARRAY',0,zhook_handle)
CALL c_bytes_io_read(kfile,kbuf,int(kbytes,jpim),iret)
IF(PRESENT(kret)) THEN
  kret=iret
ELSEIF(iret < jpbytes_io_success .AND. iret < jpbytes_io_end_of_file ) THEN
  WRITE(0,*) 'BYTES_IO_READ_JPIB_INT_ARRAY ',kfile,' ',kbytes,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_READ_JPIB_INT_ARRAY FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIB_INT_ARRAY',1,zhook_handle)
END SUBROUTINE bytes_io_read_jpib_int_array

SUBROUTINE bytes_io_read_jpib_real4(KFILE,PBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
REAL(KIND=JPRM),INTENT(OUT)      :: PBUF
INTEGER(KIND=JPIB),INTENT(IN)    :: KBYTES
INTEGER(KIND=JPIM),INTENT(OUT), OPTIONAL   :: KRET
INTEGER(KIND=JPIM) :: IRET,ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIB_REAL4',0,zhook_handle)
CALL c_bytes_io_read(kfile,pbuf,int(kbytes,jpim),iret)
IF(PRESENT(kret)) THEN
  kret=iret
ELSEIF(iret < jpbytes_io_success .AND. iret < jpbytes_io_end_of_file ) THEN
  WRITE(0,*) 'BYTES_IO_READ_JPIB_REAL4 ',kfile,' ',kbytes,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_READ_JPIB_REAL4 FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIB_REAL4',1,zhook_handle)
END SUBROUTINE bytes_io_read_jpib_real4

SUBROUTINE bytes_io_read_jpib_real4_array(KFILE,PBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
REAL(KIND=JPRM),INTENT(OUT)      :: PBUF(:)
INTEGER(KIND=JPIB),INTENT(IN)    :: KBYTES
INTEGER(KIND=JPIM),INTENT(OUT), OPTIONAL   :: KRET
INTEGER(KIND=JPIM) :: IRET,ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIB_REAL4_ARRAY',0,zhook_handle)
CALL c_bytes_io_read(kfile,pbuf,int(kbytes,jpim),iret)
IF(PRESENT(kret)) THEN
  kret=iret
ELSEIF(iret < jpbytes_io_success .AND. iret < jpbytes_io_end_of_file ) THEN
  WRITE(0,*) 'BYTES_IO_READ_JPIB_REAL4_ARRAY ',kfile,' ',kbytes,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_READ_JPIB_REAL4_ARRAY FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIB_REAL4_ARRAY',1,zhook_handle)
END SUBROUTINE bytes_io_read_jpib_real4_array

SUBROUTINE bytes_io_read_jpib_real8(KFILE,PBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
REAL(KIND=JPRD),INTENT(OUT)      :: PBUF
INTEGER(KIND=JPIB),INTENT(IN)    :: KBYTES
INTEGER(KIND=JPIM),INTENT(OUT), OPTIONAL   :: KRET
INTEGER(KIND=JPIM) :: IRET,ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIB_REAL8',0,zhook_handle)
CALL c_bytes_io_read(kfile,pbuf,int(kbytes,jpim),iret)
IF(PRESENT(kret)) THEN
  kret=iret
ELSEIF(iret < jpbytes_io_success .AND. iret < jpbytes_io_end_of_file ) THEN
  WRITE(0,*) 'BYTES_IO_READ_JPIB_REAL8 ',kfile,' ',kbytes,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_READ_JPIB_REAL8 FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIB_REAL8',1,zhook_handle)
END SUBROUTINE bytes_io_read_jpib_real8

SUBROUTINE bytes_io_read_jpib_real8_array(KFILE,PBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
REAL(KIND=JPRD),INTENT(OUT)      :: PBUF(:)
INTEGER(KIND=JPIB),INTENT(IN)    :: KBYTES
INTEGER(KIND=JPIM),INTENT(OUT), OPTIONAL   :: KRET
INTEGER(KIND=JPIM) :: IRET,ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIB_REAL8_ARRAY',0,zhook_handle)
CALL c_bytes_io_read(kfile,pbuf,int(kbytes,jpim),iret)
IF(PRESENT(kret)) THEN
  kret=iret
ELSEIF(iret < jpbytes_io_success .AND. iret < jpbytes_io_end_of_file ) THEN
  WRITE(0,*) 'BYTES_IO_READ_JPIB_REAL8_ARRAY ',kfile,' ',kbytes,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_READ_JPIB_REAL8_ARRAY FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIB_REAL8_ARRAY',1,zhook_handle)
END SUBROUTINE bytes_io_read_jpib_real8_array

SUBROUTINE bytes_io_read_jpib_char_array(KFILE,CDBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
CHARACTER(LEN=1)  ,INTENT(OUT)   :: CDBUF(:)
INTEGER(KIND=JPIB),INTENT(IN) :: KBYTES
INTEGER(KIND=JPIM),INTENT(OUT), OPTIONAL   :: KRET
INTEGER(KIND=JPIM) :: IRET,ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIB_CHAR_ARRAY',0,zhook_handle)
CALL c_bytes_io_read(kfile,cdbuf,int(kbytes,jpim),iret)
IF(PRESENT(kret)) THEN
  kret=iret
ELSEIF(iret < jpbytes_io_success .AND. iret < jpbytes_io_end_of_file ) THEN
  WRITE(0,*) 'BYTES_IO_READ_JPIB_CHAR_ARRAY ',kfile,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_READ_JPIB_CHAR_ARRAY FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_READ_JPIB_CHAR_ARRAY',1,zhook_handle)
END SUBROUTINE bytes_io_read_jpib_char_array


! ============================================
! BYTES_IO_WRITE_JPIB

SUBROUTINE bytes_io_write_jpib_int(KFILE,PBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
INTEGER(KIND=JPIM),INTENT(IN)    :: PBUF
INTEGER(KIND=JPIB),INTENT(IN)    :: KBYTES
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET
INTEGER(KIND=JPIM) :: IRET
INTEGER(KIND=JPIM) :: ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIB_INT',0,zhook_handle)

CALL c_bytes_io_write(kfile,pbuf,int(kbytes,jpim),iret)
IF(PRESENT(kret)) THEN
  kret=iret
ENDIF
IF(iret < jpbytes_io_success ) THEN
  WRITE(0,*) 'BYTES_IO_WRITE_JPIB_INT ',kfile,' ',kbytes,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_WRITE_JPIB_INT FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIB_INT',1,zhook_handle)
END SUBROUTINE bytes_io_write_jpib_int

SUBROUTINE bytes_io_write_jpib_int_array(KFILE,PBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
INTEGER(KIND=JPIM),INTENT(IN)    :: PBUF(:)
INTEGER(KIND=JPIB),INTENT(IN)    :: KBYTES
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET
INTEGER(KIND=JPIM) :: IRET
INTEGER(KIND=JPIM) :: ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIB_INT',0,zhook_handle)

CALL c_bytes_io_write(kfile,pbuf,int(kbytes,jpim),iret)
IF(PRESENT(kret)) THEN
  kret=iret
ENDIF
IF(iret < jpbytes_io_success ) THEN
  WRITE(0,*) 'BYTES_IO_WRITE_JPIB_INT ',kfile,' ',kbytes,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_WRITE_JPIB_INT FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIB_INT',1,zhook_handle)
END SUBROUTINE bytes_io_write_jpib_int_array

SUBROUTINE bytes_io_write_jpib_real4(KFILE,PBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
REAL(KIND=JPRM),INTENT(IN)    :: PBUF
INTEGER(KIND=JPIB),INTENT(IN)    :: KBYTES
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET
INTEGER(KIND=JPIM) :: IRET
INTEGER(KIND=JPIM) :: ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIB_REAL4',0,zhook_handle)

CALL c_bytes_io_write(kfile,pbuf,int(kbytes,jpim),iret)
IF(PRESENT(kret)) THEN
  kret=iret
ENDIF
IF(iret < jpbytes_io_success ) THEN
  WRITE(0,*) 'BYTES_IO_WRITE_JPIB_REAL4 ',kfile,' ',kbytes,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_WRITE_JPIB_REAL4 FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIB_REAL4',1,zhook_handle)
END SUBROUTINE bytes_io_write_jpib_real4

SUBROUTINE bytes_io_write_jpib_real4_array(KFILE,PBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
REAL(KIND=JPRM),INTENT(IN)       :: PBUF(:)
INTEGER(KIND=JPIB),INTENT(IN)    :: KBYTES
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET
INTEGER(KIND=JPIM) :: IRET
INTEGER(KIND=JPIM) :: ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIB_REAL4_ARRAY',0,zhook_handle)
CALL c_bytes_io_write(kfile,pbuf,int(kbytes,jpim),iret)
IF(PRESENT(kret)) THEN
  kret=iret
ENDIF
IF(iret < jpbytes_io_success ) THEN
  WRITE(0,*) 'BYTES_IO_WRITE_JPIB_REAL4_ARRAY ',kfile,' ',kbytes,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_WRITE_JPIB_REAL4_ARRAY FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIB_REAL4_ARRAY',1,zhook_handle)
END SUBROUTINE bytes_io_write_jpib_real4_array


SUBROUTINE bytes_io_write_jpib_real8(KFILE,PBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
REAL(KIND=JPRD),INTENT(IN)    :: PBUF
INTEGER(KIND=JPIB),INTENT(IN)    :: KBYTES
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET
INTEGER(KIND=JPIM) :: IRET
INTEGER(KIND=JPIM) :: ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIB_REAL8',0,zhook_handle)
CALL c_bytes_io_write(kfile,pbuf,int(kbytes,jpim),iret)
IF(PRESENT(kret)) THEN
  kret=iret
ENDIF
IF(iret < jpbytes_io_success ) THEN
  WRITE(0,*) 'BYTES_IO_WRITE_JPIB_REAL8 ',kfile,' ',kbytes,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_WRITE_JPIB_REAL8 FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIB_REAL8',1,zhook_handle)
END SUBROUTINE bytes_io_write_jpib_real8

SUBROUTINE bytes_io_write_jpib_real8_array(KFILE,PBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
REAL(KIND=JPRD),INTENT(IN)       :: PBUF(:)
INTEGER(KIND=JPIB),INTENT(IN)    :: KBYTES
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET
INTEGER(KIND=JPIM) :: IRET
INTEGER(KIND=JPIM) :: ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIB_REAL8_ARRAY',0,zhook_handle)
CALL c_bytes_io_write(kfile,pbuf,int(kbytes,jpim),iret)
IF(PRESENT(kret)) THEN
  kret=iret
ENDIF
IF(iret < jpbytes_io_success ) THEN
  WRITE(0,*) 'BYTES_IO_WRITE_JPIB_REAL8_ARRAY ',kfile,' ',kbytes,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_WRITE_JPIB_REAL8_ARRAY FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIB_REAL8_ARRAY',1,zhook_handle)
END SUBROUTINE bytes_io_write_jpib_real8_array

SUBROUTINE bytes_io_write_jpib_char_array(KFILE,CDBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
CHARACTER(LEN=1)  ,INTENT(IN)    :: CDBUF(:)
INTEGER(KIND=JPIB),INTENT(IN) :: KBYTES
INTEGER(KIND=JPIM),INTENT(OUT), OPTIONAL :: KRET
INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIB_CHAR_ARRAY',0,zhook_handle)
CALL c_bytes_io_write(kfile,cdbuf,int(kbytes,jpim),iret)
IF(PRESENT(kret)) THEN
  kret=iret
ELSEIF(iret < jpbytes_io_success) THEN
  WRITE(0,*) 'BYTES_IO_WRITE_JPIB_CHAR_ARRAY ',kfile,' FAILED',iret
#ifdef SFX_MPI
  CALL mpl_abort('BYTES_IO_WRITE_JPIB_CHAR_ARRAY FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('BYTES_IO:BYTES_IO_WRITE_JPIB_CHAR_ARRAY',1,zhook_handle)
END SUBROUTINE bytes_io_write_jpib_char_array

END MODULE bytes_io_mod