diff options
| -rw-r--r-- | fortran/src/H5Tff.f90 | 2102 |
1 files changed, 2030 insertions, 72 deletions
diff --git a/fortran/src/H5Tff.f90 b/fortran/src/H5Tff.f90 index 344bfd8..42a60d2 100644 --- a/fortran/src/H5Tff.f90 +++ b/fortran/src/H5Tff.f90 @@ -3,11 +3,36 @@ ! MODULE H5T - USE H5FORTRAN_TYPES - USE H5FORTRAN_FLAGS + USE H5GLOBAL CONTAINS +!---------------------------------------------------------------------- +! Name: h5topen_f +! +! Purpose: Opens named datatype. +! +! Inputs: +! loc_id - location identifier +! name - a datatype name +! Outputs: +! type_id - datatype identifier +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5topen_f(loc_id, name, type_id, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: loc_id ! File or group identifier @@ -16,11 +41,54 @@ INTEGER(HID_T), INTENT(OUT) :: type_id ! Datatype identifier INTEGER, INTENT(OUT) :: hdferr ! Error code INTEGER :: namelen ! Name length - INTEGER, EXTERNAL :: h5topen_c + +! INTEGER, EXTERNAL :: h5topen_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5topen_c(loc_id, name, namelen, type_id) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TOPEN_C'::h5topen_c + !DEC$ATTRIBUTES reference ::name + INTEGER(HID_T), INTENT(IN) :: loc_id + CHARACTER(LEN=*), INTENT(IN) :: name + INTEGER :: namelen + INTEGER(HID_T), INTENT(OUT) :: type_id + END FUNCTION h5topen_c + END INTERFACE + namelen = LEN(name) hdferr = h5topen_c(loc_id, name, namelen, type_id) END SUBROUTINE h5topen_f +!---------------------------------------------------------------------- +! Name: h5tcommit_f +! +! Purpose: Commits a transient datatype to a file, creating a +! new named datatype. +! +! Inputs: +! loc_id - location identifier +! name - name of the datatype to be stored +! at the specified location +! type_id - identifier of a datatype to be stored +! Outputs: +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tcommit_f(loc_id, name, type_id, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: loc_id ! File or group identifier @@ -29,11 +97,51 @@ INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier INTEGER, INTENT(OUT) :: hdferr ! Error code INTEGER :: namelen ! Name length - INTEGER, EXTERNAL :: h5tcommit_c + +! INTEGER, EXTERNAL :: h5tcommit_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tcommit_c(loc_id, name, namelen, type_id) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TCOMMIT_C'::h5tcommit_c + !DEC$ATTRIBUTES reference ::name + INTEGER(HID_T), INTENT(IN) :: loc_id + CHARACTER(LEN=*), INTENT(IN) :: name + INTEGER :: namelen + INTEGER(HID_T), INTENT(IN) :: type_id + END FUNCTION h5tcommit_c + END INTERFACE + namelen = LEN(name) hdferr = h5tcommit_c(loc_id, name, namelen, type_id) END SUBROUTINE h5tcommit_f +!---------------------------------------------------------------------- +! Name: h5tcopy_f +! +! Purpose: iCreates a copy of exisiting datatype. +! +! Inputs: +! type_id - datatype identifier +! Outputs: +! new_type_id - identifier of datatype's copy +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tcopy_f(type_id, new_type_id, hdferr) IMPLICIT NONE @@ -41,10 +149,50 @@ INTEGER(HID_T), INTENT(OUT) :: new_type_id ! Identifier of datatype's copy INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tcopy_c + +! INTEGER, EXTERNAL :: h5tcopy_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tcopy_c(type_id, new_type_id) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TCOPY_C'::h5tcopy_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER(HID_T), INTENT(OUT) :: new_type_id + END FUNCTION h5tcopy_c + END INTERFACE + hdferr = h5tcopy_c(type_id, new_type_id) END SUBROUTINE h5tcopy_f +!---------------------------------------------------------------------- +! Name: h5tequal_f +! +! Purpose: Determines whether two datatype identifiers refer +! to the same datatype. +! +! Inputs: +! type1_id - datatype identifier +! type2_id - datatype identifier +! Outputs: +! flag - TRUE/FALSE flag to indicate +! if two datatypes are equal +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tequal_f(type1_id, type2_id, flag, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type1_id ! Datatype identifier @@ -53,21 +201,103 @@ ! datatypes are equal INTEGER, INTENT(OUT) :: hdferr ! Error code INTEGER :: c_flag - INTEGER, EXTERNAL :: h5tequal_c + +! INTEGER, EXTERNAL :: h5tequal_c +! MS FORTRAN needs explicit interface for C functions called here + INTERFACE + INTEGER FUNCTION h5tequal_c(type1_id, type2_id, c_flag) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TEQUAL_C'::h5tequal_c + INTEGER(HID_T), INTENT(IN) :: type1_id + INTEGER(HID_T), INTENT(IN) :: type2_id + INTEGER :: c_flag + END FUNCTION h5tequal_c + END INTERFACE + flag = .FALSE. hdferr = h5tequal_c(type1_id, type2_id, c_flag) if(c_flag .gt. 0) flag = .TRUE. END SUBROUTINE h5tequal_f +!---------------------------------------------------------------------- +! Name: h5tclose_f +! +! Purpose: Releases a datatype. +! +! Inputs: +! type_id - datatype identifier +! Outputs: +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tclose_f(type_id, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tclose_c + +! INTEGER, EXTERNAL :: h5tclose_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tclose_c(type_id) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TCLOSE_C'::h5tclose_c + INTEGER(HID_T), INTENT(IN) :: type_id + END FUNCTION h5tclose_c + END INTERFACE + hdferr = h5tclose_c(type_id) END SUBROUTINE h5tclose_f +!---------------------------------------------------------------------- +! Name: h5tget_class_f +! +! Purpose: Returns the datatype class identifier. +! +! Inputs: +! type_id - datatype identifier +! Outputs: +! class - class, possible values are: +! H5T_NO_CLASS_F (-1) +! H5T_INTEGER_F (0) +! H5T_FLOAT_F (1) +! H5T_TIME_F (2) +! H5T_STRING_F (3) +! H5T_BITFIELD_F (4) +! H5T_OPAQUE_F (5) +! H5T_COMPOUND_F (6) +! H5T_REFERENCE_F (7) +! H5T_ENUM_F (8) +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tget_class_f(type_id, class, hdferr) IMPLICIT NONE @@ -85,30 +315,145 @@ ! H5T_REFERENCE_F (7) ! H5T_ENUM_F (8) INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tget_class_c + +! INTEGER, EXTERNAL :: h5tget_class_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tget_class_c(type_id, class) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TGET_CLASS_C'::h5tget_class_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER, INTENT(OUT) :: class + END FUNCTION h5tget_class_c + END INTERFACE + hdferr = h5tget_class_c(type_id, class) END SUBROUTINE h5tget_class_f +!---------------------------------------------------------------------- +! Name: h5tget_size_f +! +! Purpose: Returns the size of a datatype. +! +! Inputs: +! type_id - datatype identifier +! Outputs: +! size - datatype size +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tget_size_f(type_id, size, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier INTEGER(SIZE_T), INTENT(OUT) :: size ! Datatype size INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tget_size_c + +! INTEGER, EXTERNAL :: h5tget_size_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tget_size_c(type_id, size) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TGET_SIZE_C'::h5tget_size_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER, INTENT(OUT) :: size + END FUNCTION h5tget_size_c + END INTERFACE + hdferr = h5tget_size_c(type_id, size) END SUBROUTINE h5tget_size_f +!---------------------------------------------------------------------- +! Name: h5tset_size_f +! +! Purpose: Sets the total size for an atomic datatype. +! +! Inputs: +! type_id - datatype identifier +! size - size of the datatype +! Outputs: +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tset_size_f(type_id, size, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier INTEGER(SIZE_T), INTENT(IN) :: size ! Datatype size INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tset_size_c + +! INTEGER, EXTERNAL :: h5tset_size_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tset_size_c(type_id, size) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TSET_SIZE_C'::h5tset_size_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER, INTENT(IN) :: size + END FUNCTION h5tset_size_c + END INTERFACE + hdferr = h5tset_size_c(type_id, size) END SUBROUTINE h5tset_size_f +!---------------------------------------------------------------------- +! Name: h5tget_order_f +! +! Purpose: Returns the byte order of an atomic datatype. +! +! Inputs: +! type_id - datatype identifier +! Outputs: +! order - byte order for the datatype, possible +! values are: +! H5T_ORDER_LE_F +! H5T_ORDER_BE_F +! H5T_ORDER_VAX_F (not implemented yet) +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tget_order_f(type_id, order, hdferr) IMPLICIT NONE @@ -119,10 +464,51 @@ ! H5T_ORDER_BE_F ! H5T_ORDER_VAX_F INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tget_order_c + +! INTEGER, EXTERNAL :: h5tget_order_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tget_order_c(type_id, order) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TGET_ORDER_C'::h5tget_order_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER, INTENT(OUT) :: order + END FUNCTION h5tget_order_c + END INTERFACE + hdferr = h5tget_order_c(type_id, order) END SUBROUTINE h5tget_order_f +!---------------------------------------------------------------------- +! Name: h5tset_order_f +! +! Purpose: Sets the byte ordering of an atomic datatype. +! +! Inputs: +! type_id - datatype identifier +! order - datatype byte order +! Possible values are: +! H5T_ORDER_LE_F +! H5T_ORDER_BE_F +! H5T_ORDER_VAX_F (not implemented yet) +! Outputs: +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tset_order_f(type_id, order, hdferr) IMPLICIT NONE @@ -133,49 +519,242 @@ ! H5T_ORDER_BE_F ! H5T_ORDER_VAX_F INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tset_order_c + +! INTEGER, EXTERNAL :: h5tset_order_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tset_order_c(type_id, order) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TSET_ORDER_C'::h5tset_order_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER, INTENT(IN) :: order + END FUNCTION h5tset_order_c + END INTERFACE + hdferr = h5tset_order_c(type_id, order) END SUBROUTINE h5tset_order_f +!---------------------------------------------------------------------- +! Name: h5tget_precision_f +! +! Purpose: Returns the precision of an atomic datatype. +! +! Inputs: +! type_id - datatype identifier +! Outputs: +! precision - precision of the datatype +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tget_precision_f(type_id, precision, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier INTEGER(SIZE_T), INTENT(OUT) :: precision ! Datatype precision INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tget_precision_c + +! INTEGER, EXTERNAL :: h5tget_precision_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tget_precision_c (type_id, precision) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TGET_PRECISION_C'::h5tget_precision_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER(SIZE_T), INTENT(OUT) :: precision + END FUNCTION h5tget_precision_c + END INTERFACE + hdferr = h5tget_precision_c(type_id, precision) END SUBROUTINE h5tget_precision_f +!---------------------------------------------------------------------- +! Name: h5tset_precision_f +! +! Purpose: Sets the precision of an atomic datatype. +! +! Inputs: +! type_id - datatype identifier +! precision - datatype precision +! Outputs: +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tset_precision_f(type_id, precision, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier INTEGER(SIZE_T), INTENT(IN) :: precision ! Datatype precision INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tset_precision_c + +! INTEGER, EXTERNAL :: h5tset_precision_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tset_precision_c (type_id, precision) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TSET_PRECISION_C'::h5tset_precision_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER(SIZE_T), INTENT(IN) :: precision + END FUNCTION h5tset_precision_c + END INTERFACE + hdferr = h5tset_precision_c(type_id, precision) END SUBROUTINE h5tset_precision_f +!---------------------------------------------------------------------- +! Name: h5tget_offset_f +! +! Purpose: Retrieves the bit offset of the first significant bit. +! +! Inputs: +! type_id - datatype identifier +! Outputs: +! offset - offset value +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tget_offset_f(type_id, offset, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier INTEGER(SIZE_T), INTENT(OUT) :: offset ! Datatype bit offset of the ! first significant bit INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tget_offset_c + +! INTEGER, EXTERNAL :: h5tget_offset_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tget_offset_c(type_id, offset) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TGET_OFFSET_C'::h5tget_offset_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER(SIZE_T), INTENT(OUT) :: offset + END FUNCTION h5tget_offset_c + END INTERFACE + hdferr = h5tget_offset_c(type_id, offset) END SUBROUTINE h5tget_offset_f +!---------------------------------------------------------------------- +! Name: h5tset_offset_f +! +! Purpose: Sets the bit offset of the first significant bit. +! +! Inputs: +! type_id - datatype identifier +! offset - offset value +! Outputs: +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tset_offset_f(type_id, offset, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier INTEGER(SIZE_T), INTENT(IN) :: offset ! Datatype bit offset of the ! first significant bit INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tset_offset_c + +! INTEGER, EXTERNAL :: h5tset_offset_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tset_offset_c(type_id, offset) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TSET_OFFSET_C'::h5tset_offset_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER(SIZE_T), INTENT(IN) :: offset + END FUNCTION h5tset_offset_c + END INTERFACE + hdferr = h5tset_offset_c(type_id, offset) END SUBROUTINE h5tset_offset_f +!---------------------------------------------------------------------- +! Name: h5tget_pad_f +! +! Purpose: Retrieves the padding type of the least and +! most-significant bit padding. +! +! Inputs: +! type_id - datatype identifier +! Outputs: +! lsbpad - least-significant bit padding type +! msbpad - most-significant bit padding type +! Possible values of padding type are: +! H5T_PAD_ERROR_F = -1 +! H5T_PAD_ZERO_F = 0 +! H5T_PAD_ONE_F = 1 +! H5T_PAD_BACKGROUND_F = 2 +! H5T_PAD_NPAD_F = 3 +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tget_pad_f(type_id, lsbpad, msbpad, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier @@ -191,10 +770,55 @@ ! H5T_PAD_NPAD_F = 3 INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tget_pad_c + +! INTEGER, EXTERNAL :: h5tget_pad_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tget_pad_c(type_id, lsbpad, msbpad) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TGET_PAD_C'::h5tget_pad_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER, INTENT(OUT) :: lsbpad + INTEGER, INTENT(OUT) :: msbpad + END FUNCTION h5tget_pad_c + END INTERFACE + hdferr = h5tget_pad_c(type_id, lsbpad, msbpad) END SUBROUTINE h5tget_pad_f +!---------------------------------------------------------------------- +! Name: h5tset_pad_f +! +! Purpose: Sets the least and most-significant bits padding types. +! +! Inputs: +! type_id - datatype identifier +! lsbpad - least-significant bit padding type +! msbpad - most-significant bit padding type +! Possible values of padding type are: +! H5T_PAD_ERROR_F = -1 +! H5T_PAD_ZERO_F = 0 +! H5T_PAD_ONE_F = 1 +! H5T_PAD_BACKGROUND_F = 2 +! H5T_PAD_NPAD_F = 3 +! Outputs: +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tset_pad_f(type_id, lsbpad, msbpad, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier @@ -209,10 +833,53 @@ ! H5T_PAD_ERROR_F = -1 ! H5T_PAD_NPAD_F = 3 INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tset_pad_c + +! INTEGER, EXTERNAL :: h5sget_pad_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tset_pad_c(type_id, lsbpad, msbpad) + USE H5GLOBAL + INTEGER(HID_T), INTENT(IN) :: type_id + !MS$ATTRIBUTES C,reference,alias:'_H5TSET_PAD_C'::h5tset_pad_c + INTEGER, INTENT(IN) :: lsbpad + INTEGER, INTENT(IN) :: msbpad + END FUNCTION h5tset_pad_c + END INTERFACE + hdferr = h5tset_pad_c(type_id, lsbpad, msbpad) END SUBROUTINE h5tset_pad_f +!---------------------------------------------------------------------- +! Name: h5tget_sign_f +! +! Purpose: Retrieves the sign type for an integer type. +! +! Inputs: +! type_id - datatype identifier +! Outputs: +! sign - sign type +! Possible values are: +! Unsigned integer type H5T_SGN_NONE_F = 0 +! Two's complement signed integer type +! H5T_SGN_2_F = 1 +! or error value: H5T_SGN_ERROR_F=-1 +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tget_sign_f(type_id, sign, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier @@ -223,10 +890,52 @@ !H5T_SGN_2_F = 1 !or error value: H5T_SGN_ERROR_F=-1 INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tget_sign_c + +! INTEGER, EXTERNAL :: h5tget_sign_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tget_sign_c(type_id, sign) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TGET_SIGN_C'::h5tget_sign_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER, INTENT(OUT) :: sign + END FUNCTION h5tget_sign_c + END INTERFACE + hdferr = h5tget_sign_c(type_id, sign) END SUBROUTINE h5tget_sign_f +!---------------------------------------------------------------------- +! Name: h5tset_sign_f +! +! Purpose: Sets the sign proprety for an integer type. +! +! Inputs: +! type_id - datatype identifier +! sign - sign type +! Possible values are: +! Unsigned integer type H5T_SGN_NONE_F = 0 +! Two's complement signed integer type +! H5T_SGN_2_F = 1 +! or error value: H5T_SGN_ERROR_F=-1 +! Outputs: +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tset_sign_f(type_id, sign, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier @@ -237,10 +946,50 @@ !H5T_SGN_2_F = 1 !or error value: H5T_SGN_ERROR_F=-1 INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tset_sign_c + +! INTEGER, EXTERNAL :: h5tset_sign_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tset_sign_c(type_id, sign) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TSET_SIGN_C'::h5tset_sign_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER, INTENT(IN) :: sign + END FUNCTION h5tset_sign_c + END INTERFACE + hdferr = h5tset_sign_c(type_id, sign) END SUBROUTINE h5tset_sign_f +!---------------------------------------------------------------------- +! Name: h5tget_fields_f +! +! Purpose: Retrieves floating point datatype bit field information. +! +! Inputs: +! type_id - datatype identifier +! Outputs: +! epos - exponent bit-position +! esize - size of exponent in bits +! mpos - mantissa position +! msize - size of mantissa in bits +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tget_fields_f(type_id, epos, esize, mpos, msize, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier @@ -250,10 +999,53 @@ INTEGER, INTENT(OUT) :: msize ! size of mantissa in bits INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tget_fields_c - hdferr = h5tget_fields_c(type_id, epos, esize, mpos, msize, hdferr) +! INTEGER, EXTERNAL :: h5tget_fields_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tget_fields_c(type_id, epos, esize, mpos, msize) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TGET_FIELDS_C'::h5tget_fields_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER, INTENT(OUT) :: epos + INTEGER, INTENT(OUT) :: esize + INTEGER, INTENT(OUT) :: mpos + INTEGER, INTENT(OUT) :: msize + END FUNCTION h5tget_fields_c + END INTERFACE + + hdferr = h5tget_fields_c(type_id, epos, esize, mpos, msize) END SUBROUTINE h5tget_fields_f +!---------------------------------------------------------------------- +! Name: h5tset_fields_f +! +! Purpose: Sets locations and sizes of floating point bit fields. +! +! Inputs: +! type_id - datatype identifier +! epos - exponent bit-position +! esize - size of exponent in bits +! mpos - mantissa position +! msize - size of mantissa in bits +! hdferr: - error code +! Outputs: +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tset_fields_f(type_id, epos, esize, mpos, msize, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier @@ -263,29 +1055,146 @@ INTEGER, INTENT(IN) :: msize ! size of mantissa in bits INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tset_fields_c +! INTEGER, EXTERNAL :: h5tset_fields_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tset_fields_c(type_id, epos, esize, mpos, msize) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TSET_FIELDS_C'::h5tset_fields_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER, INTENT(IN) :: epos + INTEGER, INTENT(IN) :: esize + INTEGER, INTENT(IN) :: mpos + INTEGER, INTENT(IN) :: msize + END FUNCTION h5tset_fields_c + END INTERFACE + hdferr = h5tset_fields_c(type_id, epos, esize, mpos, msize) END SUBROUTINE h5tset_fields_f +!---------------------------------------------------------------------- +! Name: h5tget_ebias_f +! +! Purpose: Retrieves the exponent bias of a floating-point type. +! +! Inputs: +! type_id - datatype identifier +! Outputs: +! ebias - datatype exponent bias +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tget_ebias_f(type_id, ebias, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier INTEGER(SIZE_T), INTENT(OUT) :: ebias ! Datatype exponent bias of a floating-point type INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tget_ebias_c + +! INTEGER, EXTERNAL :: h5tget_ebias_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tget_ebias_c(type_id, ebias) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TGET_EBIAS_C'::h5tget_ebias_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER(SIZE_T), INTENT(OUT) :: ebias + END FUNCTION h5tget_ebias_c + END INTERFACE + hdferr = h5tget_ebias_c(type_id, ebias) END SUBROUTINE h5tget_ebias_f +!---------------------------------------------------------------------- +! Name: h5tset_ebias_f +! +! Purpose: Sets the exponent bias of a floating-point type. +! +! Inputs: +! type_id - datatype identifier +! ebias - datatype exponent bias +! Outputs: +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tset_ebias_f(type_id, ebias, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier INTEGER(SIZE_T), INTENT(IN) :: ebias !Datatype exponent bias of a floating-point type INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tset_ebias_c + +! INTEGER, EXTERNAL :: h5tset_ebias_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tset_ebias_c(type_id, ebias) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TSET_EBIAS_C'::h5tset_ebias_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER(SIZE_T), INTENT(IN) :: ebias + END FUNCTION h5tset_ebias_c + END INTERFACE + hdferr = h5tset_ebias_c(type_id, ebias) END SUBROUTINE h5tset_ebias_f +!---------------------------------------------------------------------- +! Name: h5tget_norm_f +! +! Purpose: Retrieves mantissa normalization of a floating-point +! datatype. +! +! Inputs: +! type_id - datatype identifier +! Outputs: +! norm - normalization types, valid values are: +! H5T_NORM_IMPLIED_F(0) +! H5T_NORM_MSBSET_F(1) +! H5T_NORM_NONE_F(2) +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tget_norm_f(type_id, norm, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier @@ -296,10 +1205,50 @@ !mantissa is always 1, H5T_NORM_NONE_F(2) !Mantissa is not normalize INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tget_norm_c + +! INTEGER, EXTERNAL :: h5tget_norm_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tget_norm_c(type_id, norm) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TGET_NORM_C'::h5tget_norm_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER, INTENT(OUT) :: norm + END FUNCTION h5tget_norm_c + END INTERFACE + hdferr = h5tget_norm_c(type_id, norm) END SUBROUTINE h5tget_norm_f +!---------------------------------------------------------------------- +! Name: h5tset_norm_f +! +! Purpose: Sets the mantissa normalization of a floating-point datatype. +! +! Inputs: +! type_id - datatype identifier +! norm - normalization types, valid values are: +! H5T_NORM_IMPLIED_F(0) +! H5T_NORM_MSBSET_F(1) +! H5T_NORM_NONE_F(2) +! Outputs: +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tset_norm_f(type_id, norm, hdferr) IMPLICIT NONE @@ -311,10 +1260,52 @@ !mantissa is always 1, H5T_NORM_NONE_F(2) !Mantissa is not normalize INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tset_norm_c + +! INTEGER, EXTERNAL :: h5tset_norm_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tset_norm_c(type_id, norm) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TSET_NORM_C'::h5tset_norm_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER, INTENT(IN) :: norm + END FUNCTION h5tset_norm_c + END INTERFACE + hdferr = h5tset_norm_c(type_id, norm) END SUBROUTINE h5tset_norm_f +!---------------------------------------------------------------------- +! Name: h5tget_inpad_f +! +! Purpose: Retrieves the internal padding type for unused bits +! in floating-point datatypes. +! +! Inputs: +! type_id - datatype identifier +! Outputs: +! padtype - padding type for unused bits +! Possible values of padding type are: +! H5T_PAD_ZERO_F = 0 +! H5T_PAD_ONE_F = 1 +! H5T_PAD_BACKGROUND_F = 2 +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tget_inpad_f(type_id, padtype, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier @@ -326,10 +1317,51 @@ ! H5T__PAD_BACKGROUND_F = 2 INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tget_inpad_c + +! INTEGER, EXTERNAL :: h5tget_inpad_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tget_inpad_c(type_id, padtype) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TGET_INPAD_C'::h5tget_inpad_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER, INTENT(OUT) :: padtype + END FUNCTION h5tget_inpad_c + END INTERFACE + hdferr = h5tget_inpad_c(type_id, padtype) END SUBROUTINE h5tget_inpad_f +!---------------------------------------------------------------------- +! Name: h5tset_inpad_f +! +! Purpose: Fills unused internal floating point bits. +! +! Inputs: +! type_id - datatype identifier +! padtype - padding type for unused bits +! Possible values of padding type are: +! H5T_PAD_ZERO_F = 0 +! H5T_PAD_ONE_F = 1 +! H5T_PAD_BACKGROUND_F = 2 +! Outputs: +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tset_inpad_f(type_id, padtype, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier @@ -340,10 +1372,49 @@ ! H5T__PAD_ONE_F = 1 ! H5T__PAD_BACKGROUND_F = 2 INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tset_inpad_c + +! INTEGER, EXTERNAL :: h5tset_inpad_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tset_inpad_c(type_id, padtype) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TSET_INPAD_C'::h5tset_inpad_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER, INTENT(IN) :: padtype + END FUNCTION h5tset_inpad_c + END INTERFACE + hdferr = h5tset_inpad_c(type_id, padtype) END SUBROUTINE h5tset_inpad_f +!---------------------------------------------------------------------- +! Name: h5tget_cset_f +! +! Purpose: Retrieves the character set type of a string datatype. +! +! Inputs: +! type_id - datatype identifier +! Outputs: +! cset - character set type of a string datatype +! Possible values of padding type are: +! H5T_CSET_ASCII_F = 0 +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tget_cset_f(type_id, cset, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier @@ -351,10 +1422,49 @@ ! Possible values of padding type are: !H5T_CSET_ASCII_F = 0 INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tget_cset_c + +! INTEGER, EXTERNAL :: h5tget_cset_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tget_cset_c(type_id, cset) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TGET_CSET_C'::h5tget_cset_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER, INTENT(OUT) :: cset + END FUNCTION h5tget_cset_c + END INTERFACE + hdferr = h5tget_cset_c(type_id, cset) END SUBROUTINE h5tget_cset_f +!---------------------------------------------------------------------- +! Name: h5tset_cset_f +! +! Purpose: Sets character set to be used. +! +! Inputs: +! type_id - datatype identifier +! cset - character set type of a string datatype +! Possible values of padding type are: +! H5T_CSET_ASCII_F = 0 +! Outputs: +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tset_cset_f(type_id, cset, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier @@ -362,69 +1472,298 @@ !Possible values of padding type are: !H5T_CSET_ASCII_F = 0 INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tset_cset_c + +! INTEGER, EXTERNAL :: h5tset_cset_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tset_cset_c(type_id, cset) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TSET_CSET_C'::h5tset_cset_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER, INTENT(IN) :: cset + END FUNCTION h5tset_cset_c + END INTERFACE + hdferr = h5tset_cset_c(type_id, cset) END SUBROUTINE h5tset_cset_f +!---------------------------------------------------------------------- +! Name: h5tget_strpad_f +! +! Purpose: Retrieves the storage mechanism for a string datatype. +! +! Inputs: +! type_id - datatype identifier +! Outputs: +! strpad - storage method for a string datatype +! Possible values are: +! H5T_STR_NULLTERM_F, +! H5T_STR_NULLPAD_F, +! H5T_STR_SPACEPAD_F +! H5T_STR_ERROR_F +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tget_strpad_f(type_id, strpad, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier - INTEGER, INTENT(OUT) :: strpad ! string padding method for a string datatype - ! Possible values of padding type are: - !Pad with zeros (as C does): H5T_STR_NULL_F(0), - !Pad with spaces (as FORTRAN does): - !H5T_STR_SPACE_F(1) + INTEGER, INTENT(OUT) :: strpad INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tget_strpad_c + +! INTEGER, EXTERNAL :: h5tget_strpad_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tget_strpad_c(type_id, strpad) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TGET_STRPAD_C'::h5tget_strpad_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER, INTENT(OUT) :: strpad + END FUNCTION h5tget_strpad_c + END INTERFACE + hdferr = h5tget_strpad_c(type_id, strpad) END SUBROUTINE h5tget_strpad_f +!---------------------------------------------------------------------- +! Name: h5tset_strpad_f +! +! Purpose: Defines the storage mechanism for character strings. +! +! Inputs: +! type_id - datatype identifier +! strpad - storage method for a string datatype +! Possible values are: +! H5T_STR_NULLTERM_F, +! H5T_STR_NULLPAD_F, +! H5T_STR_SPACEPAD_F +! H5T_STR_ERROR_F +! Outputs: +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tset_strpad_f(type_id, strpad, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier INTEGER, INTENT(IN) :: strpad ! string padding method for a string datatype - ! Possible values of padding type are: - !Pad with zeros (as C does): H5T_STR_NULL_F(0), - !Pad with spaces (as FORTRAN does): - !H5T_STR_SPACE_F(1) INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tset_strpad_c + +! INTEGER, EXTERNAL :: h5tset_strpad_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tset_strpad_c(type_id, strpad) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TSET_STRPAD_C'::h5tset_strpad_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER, INTENT(IN) :: strpad + END FUNCTION h5tset_strpad_c + END INTERFACE + hdferr = h5tset_strpad_c(type_id, strpad) END SUBROUTINE h5tset_strpad_f +!---------------------------------------------------------------------- +! Name: h5tget_nmembers_f +! +! Purpose: Retrieves the number of fields in a compound datatype. +! +! Inputs: +! type_id - datatype identifier +! Outputs: +! num_members - number of members +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tget_nmembers_f(type_id, num_members, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier INTEGER, INTENT(OUT) :: num_members !number of fields in a compound datatype INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tget_nmembers_c + +! INTEGER, EXTERNAL :: h5tget_nmembers_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tget_nmembers_c(type_id, num_members) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TGET_NMEMBERS_C'::h5tget_nmembers_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER, INTENT(OUT) :: num_members + END FUNCTION h5tget_nmembers_c + END INTERFACE + hdferr = h5tget_nmembers_c(type_id, num_members) END SUBROUTINE h5tget_nmembers_f +!---------------------------------------------------------------------- +! Name: h5tget_member_name_f +! +! Purpose: Retrieves the name of a field of a compound datatype. +! +! Inputs: +! type_id - datatype identifier +! index - filed index (0-based) +! Outputs: +! member_name - buffer to hold member's name +! namelen - name lenght +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tget_member_name_f(type_id,index, member_name, namelen, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier INTEGER, INTENT(IN) :: index !Field index (0-based) of the field name to retrieve CHARACTER(LEN=*), INTENT(OUT) :: member_name !name of a field of !a compound datatype - INTEGER, INTENT(OUT) :: namelen ! Length the name + INTEGER, INTENT(OUT) :: namelen ! Length of the name INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tget_member_name_c + +! INTEGER, EXTERNAL :: h5tget_member_name_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tget_member_name_c(type_id, index, member_name, namelen) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TGET_MEMBER_NAME_C'::h5tget_member_name_c + !DEC$ATTRIBUTES reference :: member_name + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER, INTENT(IN) :: index + CHARACTER(LEN=*), INTENT(OUT) :: member_name + INTEGER, INTENT(OUT) :: namelen + END FUNCTION + END INTERFACE + hdferr = h5tget_member_name_c(type_id, index, member_name, namelen) END SUBROUTINE h5tget_member_name_f +!---------------------------------------------------------------------- +! Name: h5tget_member_offset_f +! +! Purpose: Retrieves the offset of a field of a compound datatype. +! +! Inputs: +! type_id - datatype identifier +! member_no - number of the field +! Outputs: +! offset - byte offset of the requested field +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tget_member_offset_f(type_id, member_no, offset, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier INTEGER, INTENT(IN) :: member_no !Number of the field !whose offset is requested - INTEGER(SIZE_T), INTENT(OUT) :: offset !byte offset of the the beginning of the field + INTEGER(SIZE_T), INTENT(OUT) :: offset !byte offset of the beginning of the field INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tget_member_offset_c + +! INTEGER, EXTERNAL :: h5tget_member_offset_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tget_member_offset_c(type_id, member_no, offset ) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5Tget_member_offset_C'::h5tget_member_offset_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER, INTENT(IN) :: member_no + INTEGER(SIZE_T), INTENT(OUT) :: offset + END FUNCTION h5tget_member_offset_c + END INTERFACE + hdferr = h5tget_member_offset_c(type_id, member_no, offset ) END SUBROUTINE h5tget_member_offset_f +!---------------------------------------------------------------------- +! Name: h5tget_member_dim_f +! +! Purpose: This function is not supported in hdf5-1.4.* +! +! Inputs: +! Outputs: +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + ! SUBROUTINE h5tget_member_dims_f(type_id, field_idx,dims, field_dims, perm, hdferr) ! IMPLICIT NONE ! INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier @@ -442,6 +1781,32 @@ ! ! END SUBROUTINE h5tget_member_dims_f +!---------------------------------------------------------------------- +! Name: h5tget_array_dims_f +! +! Purpose: Returns sizes of array dimensions. +! +! Inputs: +! type_id - array datatype identifier +! Outputs: +! dims - buffer to store array datatype +! dimensions +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tget_array_dims_f(type_id, dims, hdferr) IMPLICIT NONE @@ -449,22 +1814,96 @@ INTEGER(HSIZE_T),DIMENSION(*), INTENT(OUT) :: dims !buffer to store array datatype ! dimensions INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tget_array_dims_c + +! INTEGER, EXTERNAL :: h5tget_array_dims_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tget_array_dims_c(type_id, dims) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TGET_ARRAY_DIMS_C'::h5tget_array_dims_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER(HSIZE_T),DIMENSION(*), INTENT(OUT) :: dims + END FUNCTION h5tget_array_dims_c + END INTERFACE + hdferr = h5tget_array_dims_c(type_id, dims) END SUBROUTINE h5tget_array_dims_f +!---------------------------------------------------------------------- +! Name: h5tget_array_ndims_f +! +! Purpose: Returns the rank of an array datatype. +! +! Inputs: +! type_id - array datatype identifier +! Outputs: +! ndims - number of array dimensions +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tget_array_ndims_f(type_id, ndims, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Array datatype identifier INTEGER, INTENT(OUT) :: ndims ! number of array dimensions INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tget_array_ndims_c + +! INTEGER, EXTERNAL :: h5tget_array_ndims_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tget_array_ndims_c(type_id, ndims) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TGET_ARRAY_NDIMS_C'::h5tget_array_ndims_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER, INTENT(OUT) :: ndims + END FUNCTION h5tget_array_ndims_c + END INTERFACE + hdferr = h5tget_array_ndims_c(type_id, ndims) END SUBROUTINE h5tget_array_ndims_f +!---------------------------------------------------------------------- +! Name: h5tget_super_f +! +! Purpose: Returns the base datatype from which a datatype is derived. +! +! Inputs: +! type_id - datatype identifier +! Outputs: +! base_type_id - identifier of the base type +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tget_super_f(type_id, base_type_id, hdferr) IMPLICIT NONE @@ -472,11 +1911,50 @@ INTEGER(HID_T), INTENT(OUT) :: base_type_id ! identifier of the datatype ! from which datatype (type_id) was derived INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tget_super_c + +! INTEGER, EXTERNAL :: h5tget_super_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tget_super_c(type_id, base_type_id) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TGET_SUPER_C'::h5tget_super_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER(HID_T), INTENT(OUT) :: base_type_id + END FUNCTION h5tget_super_c + END INTERFACE + hdferr = h5tget_super_c(type_id, base_type_id) END SUBROUTINE h5tget_super_f +!---------------------------------------------------------------------- +! Name: h5tget_member_type_f +! +! Purpose: Returns the datatype of the specified member. +! +! Inputs: +! type_id - compound datatype identifier +! field_idx - field index (0-based) +! +! Outputs: +! datatype - idnetifier of the member's datatype +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tget_member_type_f(type_id, field_idx, datatype, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier @@ -484,47 +1962,204 @@ INTEGER(HID_T), INTENT(OUT) :: datatype !identifier of a copy of !the datatype of the field INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tget_member_type_c + +! INTEGER, EXTERNAL :: h5tget_member_type_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tget_member_type_c(type_id, field_idx , datatype) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TGET_MEMBER_TYPE_C'::h5tget_member_type_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER, INTENT(IN) :: field_idx + INTEGER(HID_T), INTENT(OUT) :: datatype + END FUNCTION h5tget_member_type_c + END INTERFACE + hdferr = h5tget_member_type_c(type_id, field_idx , datatype) END SUBROUTINE h5tget_member_type_f +!---------------------------------------------------------------------- +! Name: h5tcreate_f +! +! Purpose: Creates a new dataype +! +! Inputs: +! class - datatype class, possible values are: +! H5T_COMPOUND_F +! H5T_ENUM_F +! H5T_OPAQUE_F +! size - datattype size +! Outputs: +! type_id - datatype identifier +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tcreate_f(class, size, type_id, hdferr) IMPLICIT NONE - INTEGER, INTENT(IN) :: class ! Datatype class cna be one of - ! H5T_COMPOUND_F (6) - ! H5T_ENUM_F (8) - ! H5T_OPAQUE_F (9) + INTEGER, INTENT(IN) :: class ! Datatype class can be one of + ! H5T_COMPOUND_F + ! H5T_ENUM_F + ! H5T_OPAQUE_F INTEGER(SIZE_T), INTENT(IN) :: size ! Size of the datatype INTEGER(HID_T), INTENT(OUT) :: type_id ! Datatype identifier INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tcreate_c + +! INTEGER, EXTERNAL :: h5tcreate_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tcreate_c(class, size, type_id) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TCREATE_C'::h5tcreate_c + INTEGER, INTENT(IN) :: class + INTEGER(SIZE_T), INTENT(IN) :: size + INTEGER(HID_T), INTENT(OUT) :: type_id + END FUNCTION h5tcreate_c + END INTERFACE hdferr = h5tcreate_c(class, size, type_id) END SUBROUTINE h5tcreate_f +!---------------------------------------------------------------------- +! Name: h5tinsert_f +! +! Purpose: Adds a new member to a compound datatype. +! +! Inputs: +! type_id - compound dattype identifier +! name - name of the field to insert +! offset - start of the member in an instance of +! the compound datatype +! field_id - datatype identifier of the field to insert +! Outputs: +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tinsert_f(type_id, name, offset, field_id, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier CHARACTER(LEN=*), INTENT(IN) :: name !Name of the field to insert - INTEGER(SIZE_T), INTENT(IN) :: offset !Offset in memory structure of the field to insert + INTEGER(SIZE_T), INTENT(IN) :: offset !start of the member in an instance of + !the compound datatype INTEGER(HID_T), INTENT(IN) :: field_id !datatype identifier of the new member INTEGER, INTENT(OUT) :: hdferr ! Error code INTEGER :: namelen - INTEGER, EXTERNAL :: h5tinsert_c + +! INTEGER, EXTERNAL :: h5tinsert_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tinsert_c(type_id, name, namelen, offset, field_id) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TINSERT_C'::h5tinsert_c + !DEC$ATTRIBUTES reference :: name + INTEGER(HID_T), INTENT(IN) :: type_id + CHARACTER(LEN=*), INTENT(IN) :: name + INTEGER(SIZE_T), INTENT(IN) :: offset + INTEGER(HID_T), INTENT(IN) :: field_id + INTEGER :: namelen + END FUNCTION h5tinsert_c + END INTERFACE + namelen = LEN(name) hdferr = h5tinsert_c(type_id, name, namelen, offset, field_id ) END SUBROUTINE h5tinsert_f +!---------------------------------------------------------------------- +! Name: h5tpack_f +! +! Purpose: Recursively removes padding from within a compound datatype. +! +! Inputs: +! type_id - compound datatype identifier +! Outputs: +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tpack_f(type_id, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tpack_c + +! INTEGER, EXTERNAL :: h5tpack_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tpack_c(type_id) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TPACK_C'::h5tpack_c + INTEGER(HID_T), INTENT(IN) :: type_id + END FUNCTION h5tpack_c + END INTERFACE + hdferr = h5tpack_c(type_id) END SUBROUTINE h5tpack_f +!---------------------------------------------------------------------- +! Name: h5tinsert_array_f +! +! Purpose: This function is not available on hdf5-1.4.* +! +! Inputs: +! Outputs: +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + ! SUBROUTINE h5tinsert_array_f(parent_id,name,offset, ndims, dims, member_id, hdferr, perm) ! IMPLICIT NONE ! INTEGER(HID_T), INTENT(IN) :: parent_id ! identifier of the parent compound datatype @@ -550,6 +2185,34 @@ ! end if ! ! END SUBROUTINE h5tinsert_array_f + +!---------------------------------------------------------------------- +! Name: h5tarray_create_f +! +! Purpose: Creates an array datatype object. +! +! Inputs: +! base_id - datatype identifier for the array +! base datatype +! rank - rank of the array +! dims - array dimension sizes +! Outputs: +! type_id - array datatype identifier +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- SUBROUTINE h5tarray_create_f(base_id, rank, dims, type_id, hdferr) IMPLICIT NONE @@ -559,11 +2222,51 @@ INTEGER(HID_T), INTENT(OUT) :: type_id ! identifier of the array datatype INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tarray_create_c - hdferr = h5tarray_create_c(base_id, rank, dims, type_id) + +! INTEGER, EXTERNAL :: h5tarray_create_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tarray_create_c(base_id, rank, dims, type_id) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TARRAY_CREATE_C'::h5tarray_create_c + INTEGER(HID_T), INTENT(IN) :: base_id + INTEGER, INTENT(IN) :: rank + INTEGER(HSIZE_T), DIMENSION(*), INTENT(IN) :: dims + INTEGER(HID_T), INTENT(OUT) :: type_id + END FUNCTION h5tarray_create_c + END INTERFACE + + hdferr = h5tarray_create_c(base_id, rank, dims, type_id) END SUBROUTINE h5tarray_create_f +!---------------------------------------------------------------------- +! Name: h5tenum_create_f +! +! Purpose: Creates a new enumeration datatype. +! +! Inputs: +! parent_id - datatype identifier for base datatype +! Outputs: +! new_type_id - datatype identifier for the enumeration +! datatype +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tenum_create_f(parent_id, new_type_id, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: parent_id ! Datatype identifier for @@ -572,9 +2275,45 @@ !datatype identifier for the ! new enumeration datatype INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tenum_create_c + +! INTEGER, EXTERNAL :: h5tenum_create_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tenum_create_c(parent_id, new_type_id) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TENUM_CREATE_C'::h5tenum_create_c + INTEGER(HID_T), INTENT(IN) :: parent_id + INTEGER(HID_T), INTENT(OUT) :: new_type_id + END FUNCTION h5tenum_create_c + END INTERFACE + hdferr = h5tenum_create_c(parent_id, new_type_id) END SUBROUTINE h5tenum_create_f + +!---------------------------------------------------------------------- +! Name: h5tenaum_insert_f +! +! Purpose: Inserts a new enumeration datatype member. +! +! Inputs: +! type_id - datatype identifier +! Outputs: +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- SUBROUTINE h5tenum_insert_f(type_id, name, value, hdferr) IMPLICIT NONE @@ -583,21 +2322,106 @@ INTEGER, INTENT(IN) :: value !value of the new member INTEGER, INTENT(OUT) :: hdferr ! Error code INTEGER :: namelen - INTEGER, EXTERNAL :: h5tenum_insert_c + +! INTEGER, EXTERNAL :: h5tenum_insert_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tenum_insert_c(type_id, name, namelen, value) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TENUM_INSERT_C'::h5tenum_insert_c + !DEC$ATTRIBUTES reference :: name + INTEGER(HID_T), INTENT(IN) :: type_id + CHARACTER(LEN=*), INTENT(IN) :: name + INTEGER, INTENT(IN) :: value + INTEGER :: namelen + END FUNCTION h5tenum_insert_c + END INTERFACE + namelen = LEN(name) hdferr = h5tenum_insert_c(type_id, name, namelen, value) END SUBROUTINE h5tenum_insert_f - SUBROUTINE h5tenum_nameof_f(type_id, name, namelen, value, hdferr) +!---------------------------------------------------------------------- +! Name: h5tenum_nameof_f +! +! Purpose: Returns the symbol name corresponding to a specified +! member of an enumeration datatype. +! +! Inputs: +! type_id - datatype identifier +! value - value of the enumeration datatype +! namelen - name buffer size +! Outputs: +! name - buffer to hold symbol name +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + + SUBROUTINE h5tenum_nameof_f(type_id, value, namelen, name, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier CHARACTER(LEN=*), INTENT(OUT) :: name !Name of the enumeration datatype. INTEGER(SIZE_T), INTENT(IN) :: namelen !length of the name INTEGER, INTENT(IN) :: value !value of the enumeration datatype. INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tenum_nameof_c + +! INTEGER, EXTERNAL :: h5tenum_nameof_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tenum_nameof_c(type_id, value, name, namelen) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5Tenum_nameof_C'::h5tenum_nameof_c + !DEC$ATTRIBUTES reference :: name + INTEGER(HID_T), INTENT(IN) :: type_id + CHARACTER(LEN=*), INTENT(OUT) :: name + INTEGER(SIZE_T), INTENT(IN) :: namelen + INTEGER, INTENT(IN) :: value + END FUNCTION h5tenum_nameof_c + END INTERFACE + hdferr = h5tenum_nameof_c(type_id, value, name, namelen) END SUBROUTINE h5tenum_nameof_f + +!---------------------------------------------------------------------- +! Name: h5tenum_valuof_f +! +! Purpose: Returns the value corresponding to a specified +! member of an enumeration datatype. +! +! Inputs: +! type_id - datatype identifier +! name - symbol name +! Outputs: +! value - value of the enumeration datatype +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- SUBROUTINE h5tenum_valueof_f(type_id, name, value, hdferr) IMPLICIT NONE @@ -606,33 +2430,153 @@ INTEGER, INTENT(OUT) :: value !value of the enumeration datatype. INTEGER, INTENT(OUT) :: hdferr ! Error code INTEGER :: namelen - INTEGER, EXTERNAL :: h5tenum_valueof_c + +! INTEGER, EXTERNAL :: h5tenum_valueof_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tenum_valueof_c(type_id, name, namelen, value) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5Tenum_valueof_C'::h5tenum_valueof_c + !DEC$ATTRIBUTES reference :: name + INTEGER(HID_T), INTENT(IN) :: type_id + CHARACTER(LEN=*), INTENT(IN) :: name + INTEGER(SIZE_T), INTENT(IN) :: namelen + INTEGER, INTENT(OUT) :: value + END FUNCTION h5tenum_valueof_c + END INTERFACE + namelen = LEN(name) hdferr = h5tenum_valueof_c(type_id, name, namelen, value) END SUBROUTINE h5tenum_valueof_f +!---------------------------------------------------------------------- +! Name: h5tget_member_value_f +! +! Purpose: Returns the value of an enumeration datatype member. +! +! Inputs: +! type_id - datatype identifier +! member_no - number of the enumeration datatype member +! Outputs: +! value - value of the enumeration datatype +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tget_member_value_f(type_id, member_no, value, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier INTEGER, INTENT(IN) :: member_no !Number of the enumeration datatype member INTEGER, INTENT(OUT) :: value !value of the enumeration datatype. INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tget_member_value_c + +! INTEGER, EXTERNAL :: h5tget_member_value_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tget_member_value_c(type_id, member_no, value) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TGET_MEMBER_VALUE_C'::h5tget_member_value_c + INTEGER(HID_T), INTENT(IN) :: type_id + INTEGER, INTENT(IN) :: member_no + INTEGER, INTENT(OUT) :: value + END FUNCTION + END INTERFACE + hdferr = h5tget_member_value_c(type_id, member_no, value) END SUBROUTINE h5tget_member_value_f +!---------------------------------------------------------------------- +! Name: h5tset_tag_f +! +! Purpose: Tags an opaque datatype. +! +! Inputs: +! type_id - identifier for opaque datatype +! tag - unique ASCII string with which the opaque +! datatype is to be tagged. +! Outputs: +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tset_tag_f(type_id, tag, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier CHARACTER(LEN=*), INTENT(IN) :: tag !Unique ASCII string with which !the opaque datatype is to be tagged INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER :: namelen - INTEGER, EXTERNAL :: h5tset_tag_c - namelen = LEN(tag) - hdferr = h5tset_tag_c(type_id, tag, namelen) + INTEGER :: taglen + +! INTEGER, EXTERNAL :: h5tset_tag_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tset_tag_c(type_id, tag, namelen) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TSET_TAG_C'::h5tset_tag_c + !DEC$ATTRIBUTES reference :: tag + INTEGER(HID_T), INTENT(IN) :: type_id + CHARACTER(LEN=*), INTENT(IN) :: tag + INTEGER :: taglen + END FUNCTION h5tset_tag_c + END INTERFACE + + taglen = LEN(tag) + hdferr = h5tset_tag_c(type_id, tag, taglen) END SUBROUTINE h5tset_tag_f +!---------------------------------------------------------------------- +! Name: h5tget_tag_f +! +! Purpose: Gets the tag associated with an opaque datatype. +! +! Inputs: +! type_id - identifier for opaque datatype +! Outputs: +! tag - unique ASCII string associated with opaque +! datatype +! hdferr: - error code +! Success: 0 +! Failure: -1 +! Optional parameters: +! NONE +! +! Programmer: Elena Pourmal +! August 12, 1999 +! +! Modifications: Explicit Fortran interfaces were added for +! called C functions (it is needed for Windows +! port). March 7, 2001 +! +! Comment: +!---------------------------------------------------------------------- + SUBROUTINE h5tget_tag_f(type_id, tag,taglen, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: type_id ! Datatype identifier @@ -640,7 +2584,21 @@ !the opaque datatype is to be tagged INTEGER, INTENT(OUT) :: taglen !length of tag INTEGER, INTENT(OUT) :: hdferr ! Error code - INTEGER, EXTERNAL :: h5tget_tag_c + +! INTEGER, EXTERNAL :: h5tget_tag_c +! MS FORTRAN needs explicit interface for C functions called here. +! + INTERFACE + INTEGER FUNCTION h5tget_tag_c(type_id, tag, taglen) + USE H5GLOBAL + !MS$ATTRIBUTES C,reference,alias:'_H5TGET_TAG_C'::h5tget_tag_c + !DEC$ATTRIBUTES reference :: tag + INTEGER(HID_T), INTENT(IN) :: type_id + CHARACTER(LEN=*), INTENT(OUT) :: tag + INTEGER, INTENT(OUT) :: taglen + END FUNCTION h5tget_tag_c + END INTERFACE + hdferr = h5tget_tag_c(type_id, tag, taglen) END SUBROUTINE h5tget_tag_f |