source: XMLIO_V2/dev/dev_rv/src/xmlio/fortran/ixmlioserver.f90 @ 154

! --------------------------------------------- !
! IXMLIOSERVER !
! GESTION DES ENTREES-SORTIES !
! --------------------------------------------- !



MODULE IXMLIOSERVER
   USE ISO_C_BINDING

   ! Ne jamais modifier les valeurs internes de ce type dans le code fortran.
   TYPE XHandle
      INTEGER(kind = C_INTPTR_T) :: daddr
   END TYPE XHandle

   ! enum XDType
   INTEGER(kind = C_INT), PARAMETER :: NOTYPE = 0
   INTEGER(kind = C_INT), PARAMETER :: DTREATMENT = 1, DDATE = 2, CALENDAR = 3, ECONTEXT = 4
   INTEGER(kind = C_INT), PARAMETER :: EAXIS = 5 , EDOMAIN = 6 , EFIELD = 7 , EFILE = 8 , EGRID = 9
   INTEGER(kind = C_INT), PARAMETER :: GAXIS = 10, GDOMAIN = 11, GFIELD = 12, GFILE = 13, GGRID = 14

   ! enum XCalendarType
   INTEGER(kind = C_INT), PARAMETER :: D360 = 0 , ALLLEAP = 1 , NOLEAP = 2 , JULIAN = 3 , GREGORIAN = 4

   TYPE XDate
      INTEGER :: year, month, day, hour, minute, second
   END TYPE XDate

   TYPE XDuration
      REAL(kind = 8) :: year, month, day, hour, minute, second
   END TYPE XDuration

   ! Autres constantes
   TYPE(XHandle) , PARAMETER :: NULLHANDLE = XHandle(0)

   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99

      SUBROUTINE xios_handle_create(ret, dtype, idt, idt_size) BIND(C)
         import C_CHAR, C_INTPTR_T, C_INT
         INTEGER (kind = C_INTPTR_T) :: ret
         INTEGER (kind = C_INT), VALUE :: dtype
         CHARACTER(kind = C_CHAR), DIMENSION(*) :: idt
         INTEGER (kind = C_INT), VALUE :: idt_size
      END SUBROUTINE xios_handle_create

      SUBROUTINE xios_set_timestep(ts_year, ts_month, ts_day, &
                                   ts_hour, ts_minute, ts_second) BIND(C)
         import C_DOUBLE
         REAL (kind = C_DOUBLE), VALUE :: ts_year, ts_month, ts_day, &
                                          ts_hour, ts_minute, ts_second
      END SUBROUTINE xios_set_timestep

      SUBROUTINE xios_update_calendar(step) BIND(C)
         import C_INT
         INTEGER (kind = C_INT), VALUE :: step
      END SUBROUTINE xios_update_calendar

      SUBROUTINE xios_xml_tree_add(parent_, parent_type, child_, child_type, child_id, child_id_size) BIND(C)
         import C_CHAR, C_INT, C_INTPTR_T
         INTEGER (kind = C_INTPTR_T), VALUE :: parent_
         INTEGER (kind = C_INT), VALUE :: parent_type
         INTEGER (kind = C_INTPTR_T) :: child_
         INTEGER (kind = C_INT), VALUE :: child_type
         CHARACTER(kind = C_CHAR), DIMENSION(*) :: child_id
         INTEGER (kind = C_INT), VALUE :: child_id_size
      END SUBROUTINE xios_xml_tree_add

      SUBROUTINE xios_xml_tree_show(filename, filename_size) BIND(C)
         import C_CHAR, C_INT
         CHARACTER(kind = C_CHAR), DIMENSION(*) :: filename
         INTEGER (kind = C_INT), VALUE :: filename_size
      END SUBROUTINE xios_xml_tree_show

      SUBROUTINE xios_xml_parse_file(filename, filename_size) BIND(C)
         import C_CHAR, C_INT
         CHARACTER(kind = C_CHAR), DIMENSION(*) :: filename
         INTEGER (kind = C_INT), VALUE :: filename_size
      END SUBROUTINE xios_xml_Parse_File

      SUBROUTINE xios_xml_parse_string(xmlcontent, xmlcontent_size) BIND(C)
         import C_CHAR, C_INT
         CHARACTER(kind = C_CHAR), DIMENSION(*) :: xmlcontent
         INTEGER (kind = C_INT), VALUE :: xmlcontent_size
      END SUBROUTINE xios_xml_Parse_String

      SUBROUTINE xios_context_set_current(context, withswap) BIND(C)
         import C_BOOL, C_INT, C_INTPTR_T
         INTEGER (kind = C_INTPTR_T), VALUE :: context
         LOGICAL (kind = C_BOOL), VALUE :: withswap
      END SUBROUTINE xios_context_set_current

      SUBROUTINE xios_context_create(context, context_id, context_id_size, calendar_type, &
                                     year, month, day, hour, minute, second) BIND(C)
         import C_CHAR, C_INT, C_INTPTR_T
         INTEGER (kind = C_INTPTR_T) :: context
         CHARACTER(kind = C_CHAR), DIMENSION(*) :: context_id
         INTEGER (kind = C_INT), VALUE :: context_id_size
         INTEGER (kind = C_INT), VALUE :: calendar_type, year, month, day, hour, minute, second
      END SUBROUTINE xios_context_create

      SUBROUTINE xios_dtreatment_start(context_hdl, filetype) BIND(C)
         import C_INTPTR_T, C_INT
         INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
         INTEGER (kind = C_INT), VALUE :: filetype
      END SUBROUTINE xios_dtreatment_start

      SUBROUTINE xios_dtreatment_end() BIND(C)
         ! Sans argument
      END SUBROUTINE xios_dtreatment_end

      SUBROUTINE xios_write_data(fieldid, fieldid_size, data_k8, data_Xsize, data_Ysize, data_Zsize) BIND(C)
         import C_INT, C_CHAR, C_PTR, C_FLOAT, C_DOUBLE, C_BOOL
         CHARACTER(kind = C_CHAR), DIMENSION(*) :: fieldid
         INTEGER (kind = C_INT), VALUE :: fieldid_size
         REAL(kind = C_DOUBLE), DIMENSION(*) :: data_k8
         INTEGER (kind = C_INT), VALUE :: data_Xsize, data_Ysize, data_Zsize
      END SUBROUTINE xios_write_data
SUBROUTINE xios_set_axis_name(axis_hdl, ftype ,name ,name_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: name
 INTEGER (kind = C_INT) :: name_size
 END SUBROUTINE xios_set_axis_name

SUBROUTINE xios_set_axis_standard_name(axis_hdl, ftype ,standard_name ,standard_name_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: standard_name
 INTEGER (kind = C_INT) :: standard_name_size
 END SUBROUTINE xios_set_axis_standard_name

SUBROUTINE xios_set_axis_long_name(axis_hdl, ftype ,long_name ,long_name_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: long_name
 INTEGER (kind = C_INT) :: long_name_size
 END SUBROUTINE xios_set_axis_long_name

SUBROUTINE xios_set_axis_unit(axis_hdl, ftype ,unit ,unit_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: unit
 INTEGER (kind = C_INT) :: unit_size
 END SUBROUTINE xios_set_axis_unit

SUBROUTINE xios_set_axis_size(axis_hdl, ftype ,size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 INTEGER (kind = C_INT) :: size
 END SUBROUTINE xios_set_axis_size

SUBROUTINE xios_set_axis_zvalue(axis_hdl, ftype ,zvalue ,zvalue_extent1) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 REAL(kind = C_DOUBLE), DIMENSION(*) :: zvalue
 INTEGER (kind = C_INT) :: zvalue_extent1
 END SUBROUTINE xios_set_axis_zvalue

SUBROUTINE xios_set_field_name(field_hdl, ftype ,name ,name_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: name
 INTEGER (kind = C_INT) :: name_size
 END SUBROUTINE xios_set_field_name

SUBROUTINE xios_set_field_standard_name(field_hdl, ftype ,standard_name ,standard_name_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: standard_name
 INTEGER (kind = C_INT) :: standard_name_size
 END SUBROUTINE xios_set_field_standard_name

SUBROUTINE xios_set_field_long_name(field_hdl, ftype ,long_name ,long_name_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: long_name
 INTEGER (kind = C_INT) :: long_name_size
 END SUBROUTINE xios_set_field_long_name

SUBROUTINE xios_set_field_unit(field_hdl, ftype ,unit ,unit_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: unit
 INTEGER (kind = C_INT) :: unit_size
 END SUBROUTINE xios_set_field_unit

SUBROUTINE xios_set_field_operation(field_hdl, ftype ,operation ,operation_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: operation
 INTEGER (kind = C_INT) :: operation_size
 END SUBROUTINE xios_set_field_operation

SUBROUTINE xios_set_field_freq_op(field_hdl, ftype ,freq_op ,freq_op_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: freq_op
 INTEGER (kind = C_INT) :: freq_op_size
 END SUBROUTINE xios_set_field_freq_op

SUBROUTINE xios_set_field_level(field_hdl, ftype ,level) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 INTEGER (kind = C_INT) :: level
 END SUBROUTINE xios_set_field_level

SUBROUTINE xios_set_field_prec(field_hdl, ftype ,prec) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 INTEGER (kind = C_INT) :: prec
 END SUBROUTINE xios_set_field_prec

SUBROUTINE xios_set_field_enabled(field_hdl, ftype ,enabled) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 LOGICAL (kind = C_BOOL) :: enabled
 END SUBROUTINE xios_set_field_enabled

SUBROUTINE xios_set_field_domain_ref(field_hdl, ftype ,domain_ref ,domain_ref_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: domain_ref
 INTEGER (kind = C_INT) :: domain_ref_size
 END SUBROUTINE xios_set_field_domain_ref

SUBROUTINE xios_set_field_axis_ref(field_hdl, ftype ,axis_ref ,axis_ref_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: axis_ref
 INTEGER (kind = C_INT) :: axis_ref_size
 END SUBROUTINE xios_set_field_axis_ref

SUBROUTINE xios_set_field_grid_ref(field_hdl, ftype ,grid_ref ,grid_ref_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: grid_ref
 INTEGER (kind = C_INT) :: grid_ref_size
 END SUBROUTINE xios_set_field_grid_ref

SUBROUTINE xios_set_field_zoom_ref(field_hdl, ftype ,zoom_ref ,zoom_ref_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: zoom_ref
 INTEGER (kind = C_INT) :: zoom_ref_size
 END SUBROUTINE xios_set_field_zoom_ref

SUBROUTINE xios_set_field_field_ref(field_hdl, ftype ,field_ref ,field_ref_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: field_ref
 INTEGER (kind = C_INT) :: field_ref_size
 END SUBROUTINE xios_set_field_field_ref

SUBROUTINE xios_set_context_calendar_type(context_hdl, ftype ,calendar_type ,calendar_type_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: calendar_type
 INTEGER (kind = C_INT) :: calendar_type_size
 END SUBROUTINE xios_set_context_calendar_type

SUBROUTINE xios_set_context_start_date(context_hdl, ftype ,start_date ,start_date_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: start_date
 INTEGER (kind = C_INT) :: start_date_size
 END SUBROUTINE xios_set_context_start_date

SUBROUTINE xios_set_domain_name(domain_hdl, ftype ,name ,name_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: name
 INTEGER (kind = C_INT) :: name_size
 END SUBROUTINE xios_set_domain_name

SUBROUTINE xios_set_domain_standard_name(domain_hdl, ftype ,standard_name ,standard_name_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: standard_name
 INTEGER (kind = C_INT) :: standard_name_size
 END SUBROUTINE xios_set_domain_standard_name

SUBROUTINE xios_set_domain_long_name(domain_hdl, ftype ,long_name ,long_name_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: long_name
 INTEGER (kind = C_INT) :: long_name_size
 END SUBROUTINE xios_set_domain_long_name

SUBROUTINE xios_set_domain_ni_glo(domain_hdl, ftype ,ni_glo) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 INTEGER (kind = C_INT) :: ni_glo
 END SUBROUTINE xios_set_domain_ni_glo

SUBROUTINE xios_set_domain_nj_glo(domain_hdl, ftype ,nj_glo) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 INTEGER (kind = C_INT) :: nj_glo
 END SUBROUTINE xios_set_domain_nj_glo

SUBROUTINE xios_set_domain_ibegin(domain_hdl, ftype ,ibegin) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 INTEGER (kind = C_INT) :: ibegin
 END SUBROUTINE xios_set_domain_ibegin

SUBROUTINE xios_set_domain_iend(domain_hdl, ftype ,iend) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 INTEGER (kind = C_INT) :: iend
 END SUBROUTINE xios_set_domain_iend

SUBROUTINE xios_set_domain_ni(domain_hdl, ftype ,ni) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 INTEGER (kind = C_INT) :: ni
 END SUBROUTINE xios_set_domain_ni

SUBROUTINE xios_set_domain_jbegin(domain_hdl, ftype ,jbegin) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 INTEGER (kind = C_INT) :: jbegin
 END SUBROUTINE xios_set_domain_jbegin

SUBROUTINE xios_set_domain_jend(domain_hdl, ftype ,jend) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 INTEGER (kind = C_INT) :: jend
 END SUBROUTINE xios_set_domain_jend

SUBROUTINE xios_set_domain_nj(domain_hdl, ftype ,nj) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 INTEGER (kind = C_INT) :: nj
 END SUBROUTINE xios_set_domain_nj

SUBROUTINE xios_set_domain_mask(domain_hdl, ftype ,mask ,mask_extent1 ,mask_extent2) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 LOGICAL(kind = C_BOOL), DIMENSION(*) :: mask
 INTEGER (kind = C_INT) :: mask_extent1
 INTEGER (kind = C_INT) :: mask_extent2
 END SUBROUTINE xios_set_domain_mask

SUBROUTINE xios_set_domain_data_dim(domain_hdl, ftype ,data_dim) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 INTEGER (kind = C_INT) :: data_dim
 END SUBROUTINE xios_set_domain_data_dim

SUBROUTINE xios_set_domain_data_ni(domain_hdl, ftype ,data_ni) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 INTEGER (kind = C_INT) :: data_ni
 END SUBROUTINE xios_set_domain_data_ni

SUBROUTINE xios_set_domain_data_nj(domain_hdl, ftype ,data_nj) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 INTEGER (kind = C_INT) :: data_nj
 END SUBROUTINE xios_set_domain_data_nj

SUBROUTINE xios_set_domain_data_ibegin(domain_hdl, ftype ,data_ibegin) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 INTEGER (kind = C_INT) :: data_ibegin
 END SUBROUTINE xios_set_domain_data_ibegin

SUBROUTINE xios_set_domain_data_jbegin(domain_hdl, ftype ,data_jbegin) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 INTEGER (kind = C_INT) :: data_jbegin
 END SUBROUTINE xios_set_domain_data_jbegin

SUBROUTINE xios_set_domain_data_n_index(domain_hdl, ftype ,data_n_index) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 INTEGER (kind = C_INT) :: data_n_index
 END SUBROUTINE xios_set_domain_data_n_index

SUBROUTINE xios_set_domain_data_i_index(domain_hdl, ftype ,data_i_index ,data_i_index_extent1) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 INTEGER(kind = C_INT), DIMENSION(*) :: data_i_index
 INTEGER (kind = C_INT) :: data_i_index_extent1
 END SUBROUTINE xios_set_domain_data_i_index

SUBROUTINE xios_set_domain_data_j_index(domain_hdl, ftype ,data_j_index ,data_j_index_extent1) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 INTEGER(kind = C_INT), DIMENSION(*) :: data_j_index
 INTEGER (kind = C_INT) :: data_j_index_extent1
 END SUBROUTINE xios_set_domain_data_j_index

SUBROUTINE xios_set_domain_lonvalue(domain_hdl, ftype ,lonvalue ,lonvalue_extent1) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 REAL(kind = C_DOUBLE), DIMENSION(*) :: lonvalue
 INTEGER (kind = C_INT) :: lonvalue_extent1
 END SUBROUTINE xios_set_domain_lonvalue

SUBROUTINE xios_set_domain_latvalue(domain_hdl, ftype ,latvalue ,latvalue_extent1) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 REAL(kind = C_DOUBLE), DIMENSION(*) :: latvalue
 INTEGER (kind = C_INT) :: latvalue_extent1
 END SUBROUTINE xios_set_domain_latvalue

SUBROUTINE xios_set_file_name(file_hdl, ftype ,name ,name_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: name
 INTEGER (kind = C_INT) :: name_size
 END SUBROUTINE xios_set_file_name

SUBROUTINE xios_set_file_description(file_hdl, ftype ,description ,description_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: description
 INTEGER (kind = C_INT) :: description_size
 END SUBROUTINE xios_set_file_description

SUBROUTINE xios_set_file_output_freq(file_hdl, ftype ,output_freq ,output_freq_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: output_freq
 INTEGER (kind = C_INT) :: output_freq_size
 END SUBROUTINE xios_set_file_output_freq

SUBROUTINE xios_set_file_output_level(file_hdl, ftype ,output_level) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 INTEGER (kind = C_INT) :: output_level
 END SUBROUTINE xios_set_file_output_level

SUBROUTINE xios_set_file_enabled(file_hdl, ftype ,enabled) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 LOGICAL (kind = C_BOOL) :: enabled
 END SUBROUTINE xios_set_file_enabled

SUBROUTINE xios_set_grid_name(grid_hdl, ftype ,name ,name_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: grid_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: name
 INTEGER (kind = C_INT) :: name_size
 END SUBROUTINE xios_set_grid_name

SUBROUTINE xios_set_grid_description(grid_hdl, ftype ,description ,description_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: grid_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: description
 INTEGER (kind = C_INT) :: description_size
 END SUBROUTINE xios_set_grid_description

SUBROUTINE xios_set_grid_domain_ref(grid_hdl, ftype ,domain_ref ,domain_ref_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: grid_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: domain_ref
 INTEGER (kind = C_INT) :: domain_ref_size
 END SUBROUTINE xios_set_grid_domain_ref

SUBROUTINE xios_set_grid_axis_ref(grid_hdl, ftype ,axis_ref ,axis_ref_size) BIND(C)
 USE ISO_C_BINDING
 INTEGER (kind = C_INTPTR_T), VALUE :: grid_hdl
 INTEGER (kind = C_INT), VALUE :: ftype
 CHARACTER(kind = C_CHAR), DIMENSION(*) :: axis_ref
 INTEGER (kind = C_INT) :: axis_ref_size
 END SUBROUTINE xios_set_grid_axis_ref

   END INTERFACE
   CONTAINS ! Fonctions disponibles pour les utilisateurs.
   SUBROUTINE handle_create(ret, dtype, idt)
      TYPE(XHandle), INTENT(OUT) :: ret
      INTEGER, INTENT(IN) :: dtype
      CHARACTER(len = *), INTENT(IN) :: idt
      CALL xios_handle_create(ret%daddr, dtype, idt, len(idt))
   END SUBROUTINE handle_create
   SUBROUTINE set_timestep(timestep)
      TYPE(XDuration), INTENT(IN):: timestep
      CALL xios_set_timestep(timestep%year, timestep%month , timestep%day, &
                             timestep%hour, timestep%minute, timestep%second)
   END SUBROUTINE set_timestep
   SUBROUTINE update_calendar(step)
      INTEGER, INTENT(IN):: step
      IF (step < 1) THEN
         PRINT *, "L'argument 'step' ne peut être négatif ou nul"
         STOP
      END IF
      CALL xios_update_calendar(step)
   END SUBROUTINE update_calendar
   SUBROUTINE xml_tree_add(parent_hdl, parent_type, child_hdl, child_type, child_id)
      TYPE(XHandle), INTENT(IN) :: parent_hdl
      TYPE(XHandle), INTENT(OUT) :: child_hdl
      INTEGER, INTENT(IN) :: child_type, parent_type
      CHARACTER(len = *), OPTIONAL, INTENT(IN) :: child_id
      child_hdl = NULLHANDLE
      IF (PRESENT(child_id)) THEN
         CALL xios_xml_tree_add(parent_hdl%daddr, parent_type, child_hdl%daddr, child_type, child_id, len(child_id))
      ELSE
         CALL xios_xml_tree_add(parent_hdl%daddr, parent_type, child_hdl%daddr, child_type, "NONE", -1)
      END IF
   END SUBROUTINE xml_tree_add
   SUBROUTINE xml_tree_show(filename)
      CHARACTER(len = *), OPTIONAL, INTENT(IN) :: filename
      IF (PRESENT(filename)) THEN
         CALL xios_xml_tree_show(filename, len(filename))
      ELSE
         CALL xios_xml_tree_show("NONE", -1)
      END IF
   END SUBROUTINE xml_tree_show
   SUBROUTINE xml_parse_file(filename)
      CHARACTER(len = *), INTENT(IN) :: filename
      CALL xios_xml_Parse_File(filename, len(filename))
   END SUBROUTINE xml_Parse_File
   SUBROUTINE xml_parse_string(xmlcontent)
      CHARACTER(len = *), INTENT(IN) :: xmlcontent
      CALL xios_xml_Parse_String(xmlcontent, len(xmlcontent))
   END SUBROUTINE xml_Parse_String
   SUBROUTINE context_set_current(context, withswap)
      TYPE(XHandle), INTENT(IN) :: context
      LOGICAL (kind = 1), OPTIONAL, INTENT(IN) :: withswap
      LOGICAL (kind = 1) :: wswap
      IF (PRESENT(withswap)) THEN
         wswap = withswap
      ELSE
         wswap = .FALSE.
      END IF
      CALL xios_context_set_current(context%daddr, wswap)
   END SUBROUTINE context_set_current
   SUBROUTINE context_create(context_hdl, context_id, calendar_type, init_date)
      TYPE(XHandle), INTENT(OUT) :: context_hdl
      CHARACTER(len = *), INTENT(IN) :: context_id
      INTEGER, INTENT(IN) :: calendar_type
      TYPE(XDate), INTENT(IN), OPTIONAL :: init_date
      IF (PRESENT(init_date)) THEN
         CALL xios_context_create(context_hdl%daddr, context_id, len(context_id), calendar_type, &
                                  init_date%year, init_date%month, init_date%day, &
                                  init_date%hour, init_date%minute, init_date%second)
      ELSE
         CALL xios_context_create(context_hdl%daddr, context_id, len(context_id), calendar_type, &
                                 0, 1, 1, 0, 0, 0)
      END IF
   END SUBROUTINE context_create
   SUBROUTINE dtreatment_start(context_hdl, filetype)
      TYPE(XHandle), INTENT(IN), VALUE :: context_hdl
      INTEGER, INTENT(IN), OPTIONAL :: filetype
      INTEGER :: filetype_
      IF (PRESENT(filetype)) THEN
         filetype_ = filetype
      ELSE
         filetype_ = NETCDF4
      END IF
         CALL context_set_current(context_hdl)
         CALL xios_dtreatment_start(context_hdl%daddr, filetype_)
   END SUBROUTINE dtreatment_start
   SUBROUTINE dtreatment_end(context_hdl)
      TYPE(XHandle), INTENT(IN), VALUE :: context_hdl
      CALL context_set_current(context_hdl)
      CALL xios_dtreatment_end()
   END SUBROUTINE dtreatment_end
   SUBROUTINE write_data (fieldid, &
                          data1d_k8, data2d_k8, data3d_k8)
      CHARACTER(len = *), INTENT(IN) :: fieldid
      REAL(kind = 8), DIMENSION(*), OPTIONAL, INTENT(IN) :: data1d_k8(:), data2d_k8(:,:), data3d_k8(:,:,:)
      IF((.NOT. PRESENT(data1d_k8)) .AND. &
         (.NOT. PRESENT(data2d_k8)) .AND. &
         (.NOT. PRESENT(data3d_k8))) THEN
         PRINT *, "(F2003 interface) Veuillez spécifier des données à écrire !"
         STOP
      END IF
      IF (PRESENT (data1d_k8)) THEN
         CALL xios_write_data(fieldid, len(fieldid), data1d_k8, &
                              size(data1d_k8, 1), -1, -1)
      ELSE IF (PRESENT (data2d_k8)) THEN
         CALL xios_write_data(fieldid, len(fieldid), data2d_k8, &
                              size(data2d_k8, 1), size(data2d_k8, 2), -1)
      ELSE IF (PRESENT (data3d_k8)) THEN
         CALL xios_write_data(fieldid, len(fieldid), data3d_k8, &
                              size(data3d_k8, 1), size(data3d_k8, 2), size(data3d_k8, 3))
      END IF
   END SUBROUTINE
   SUBROUTINE set_axis_attributes( axis_hdl, ftype &
,name_ &
,standard_name_ &
,long_name_ &
,unit_ &
,size_ &
,zvalue_ &
   )
      TYPE(XHandle) :: axis_hdl
      INTEGER (kind = C_INT) :: ftype
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: name_
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: standard_name_
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: long_name_
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: unit_
INTEGER, OPTIONAL, INTENT(IN) :: size_
REAL(kind = 8), dimension(*), OPTIONAL, INTENT(IN) :: zvalue_(:)
IF (PRESENT(name_)) THEN
 CALL xios_set_axis_name(axis_hdl%daddr, ftype, name_, len(name_))
 END IF

IF (PRESENT(standard_name_)) THEN
 CALL xios_set_axis_standard_name(axis_hdl%daddr, ftype, standard_name_, len(standard_name_))
 END IF

IF (PRESENT(long_name_)) THEN
 CALL xios_set_axis_long_name(axis_hdl%daddr, ftype, long_name_, len(long_name_))
 END IF

IF (PRESENT(unit_)) THEN
 CALL xios_set_axis_unit(axis_hdl%daddr, ftype, unit_, len(unit_))
 END IF

IF (PRESENT(size_)) THEN
 CALL xios_set_axis_size(axis_hdl%daddr, ftype, size_)
 END IF

IF (PRESENT(zvalue_)) THEN
 CALL xios_set_axis_zvalue(axis_hdl%daddr, ftype, zvalue_, size(zvalue_, 1))
 END IF

   END SUBROUTINE set_axis_attributes
   SUBROUTINE set_field_attributes( field_hdl, ftype &
,name_ &
,standard_name_ &
,long_name_ &
,unit_ &
,operation_ &
,freq_op_ &
,level_ &
,prec_ &
,enabled_ &
,domain_ref_ &
,axis_ref_ &
,grid_ref_ &
,zoom_ref_ &
,field_ref_ &
   )
      TYPE(XHandle) :: field_hdl
      INTEGER (kind = C_INT) :: ftype
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: name_
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: standard_name_
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: long_name_
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: unit_
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: operation_
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: freq_op_
INTEGER, OPTIONAL, INTENT(IN) :: level_
INTEGER, OPTIONAL, INTENT(IN) :: prec_
LOGICAL(kind = 1), OPTIONAL, INTENT(IN) :: enabled_
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: domain_ref_
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: axis_ref_
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: grid_ref_
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: zoom_ref_
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: field_ref_
IF (PRESENT(name_)) THEN
 CALL xios_set_field_name(field_hdl%daddr, ftype, name_, len(name_))
 END IF

IF (PRESENT(standard_name_)) THEN
 CALL xios_set_field_standard_name(field_hdl%daddr, ftype, standard_name_, len(standard_name_))
 END IF

IF (PRESENT(long_name_)) THEN
 CALL xios_set_field_long_name(field_hdl%daddr, ftype, long_name_, len(long_name_))
 END IF

IF (PRESENT(unit_)) THEN
 CALL xios_set_field_unit(field_hdl%daddr, ftype, unit_, len(unit_))
 END IF

IF (PRESENT(operation_)) THEN
 CALL xios_set_field_operation(field_hdl%daddr, ftype, operation_, len(operation_))
 END IF

IF (PRESENT(freq_op_)) THEN
 CALL xios_set_field_freq_op(field_hdl%daddr, ftype, freq_op_, len(freq_op_))
 END IF

IF (PRESENT(level_)) THEN
 CALL xios_set_field_level(field_hdl%daddr, ftype, level_)
 END IF

IF (PRESENT(prec_)) THEN
 CALL xios_set_field_prec(field_hdl%daddr, ftype, prec_)
 END IF

IF (PRESENT(enabled_)) THEN
 CALL xios_set_field_enabled(field_hdl%daddr, ftype, enabled_)
 END IF

IF (PRESENT(domain_ref_)) THEN
 CALL xios_set_field_domain_ref(field_hdl%daddr, ftype, domain_ref_, len(domain_ref_))
 END IF

IF (PRESENT(axis_ref_)) THEN
 CALL xios_set_field_axis_ref(field_hdl%daddr, ftype, axis_ref_, len(axis_ref_))
 END IF

IF (PRESENT(grid_ref_)) THEN
 CALL xios_set_field_grid_ref(field_hdl%daddr, ftype, grid_ref_, len(grid_ref_))
 END IF

IF (PRESENT(zoom_ref_)) THEN
 CALL xios_set_field_zoom_ref(field_hdl%daddr, ftype, zoom_ref_, len(zoom_ref_))
 END IF

IF (PRESENT(field_ref_)) THEN
 CALL xios_set_field_field_ref(field_hdl%daddr, ftype, field_ref_, len(field_ref_))
 END IF

   END SUBROUTINE set_field_attributes
   SUBROUTINE set_context_attributes( context_hdl, ftype &
,calendar_type_ &
,start_date_ &
   )
      TYPE(XHandle) :: context_hdl
      INTEGER (kind = C_INT) :: ftype
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: calendar_type_
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: start_date_
IF (PRESENT(calendar_type_)) THEN
 CALL xios_set_context_calendar_type(context_hdl%daddr, ftype, calendar_type_, len(calendar_type_))
 END IF

IF (PRESENT(start_date_)) THEN
 CALL xios_set_context_start_date(context_hdl%daddr, ftype, start_date_, len(start_date_))
 END IF

   END SUBROUTINE set_context_attributes
   SUBROUTINE set_domain_attributes( domain_hdl, ftype &
,name_ &
,standard_name_ &
,long_name_ &
,ni_glo_ &
,nj_glo_ &
,ibegin_ &
,iend_ &
,ni_ &
,jbegin_ &
,jend_ &
,nj_ &
,mask_ &
,data_dim_ &
,data_ni_ &
,data_nj_ &
,data_ibegin_ &
,data_jbegin_ &
,data_n_index_ &
,data_i_index_ &
,data_j_index_ &
,lonvalue_ &
,latvalue_ &
   )
      TYPE(XHandle) :: domain_hdl
      INTEGER (kind = C_INT) :: ftype
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: name_
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: standard_name_
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: long_name_
INTEGER, OPTIONAL, INTENT(IN) :: ni_glo_
INTEGER, OPTIONAL, INTENT(IN) :: nj_glo_
INTEGER, OPTIONAL, INTENT(IN) :: ibegin_
INTEGER, OPTIONAL, INTENT(IN) :: iend_
INTEGER, OPTIONAL, INTENT(IN) :: ni_
INTEGER, OPTIONAL, INTENT(IN) :: jbegin_
INTEGER, OPTIONAL, INTENT(IN) :: jend_
INTEGER, OPTIONAL, INTENT(IN) :: nj_
LOGICAL(kind = 1), dimension(*), OPTIONAL, INTENT(IN) :: mask_(:,:)
INTEGER, OPTIONAL, INTENT(IN) :: data_dim_
INTEGER, OPTIONAL, INTENT(IN) :: data_ni_
INTEGER, OPTIONAL, INTENT(IN) :: data_nj_
INTEGER, OPTIONAL, INTENT(IN) :: data_ibegin_
INTEGER, OPTIONAL, INTENT(IN) :: data_jbegin_
INTEGER, OPTIONAL, INTENT(IN) :: data_n_index_
INTEGER, dimension(*), OPTIONAL, INTENT(IN) :: data_i_index_(:)
INTEGER, dimension(*), OPTIONAL, INTENT(IN) :: data_j_index_(:)
REAL(kind = 8), dimension(*), OPTIONAL, INTENT(IN) :: lonvalue_(:)
REAL(kind = 8), dimension(*), OPTIONAL, INTENT(IN) :: latvalue_(:)
IF (PRESENT(name_)) THEN
 CALL xios_set_domain_name(domain_hdl%daddr, ftype, name_, len(name_))
 END IF

IF (PRESENT(standard_name_)) THEN
 CALL xios_set_domain_standard_name(domain_hdl%daddr, ftype, standard_name_, len(standard_name_))
 END IF

IF (PRESENT(long_name_)) THEN
 CALL xios_set_domain_long_name(domain_hdl%daddr, ftype, long_name_, len(long_name_))
 END IF

IF (PRESENT(ni_glo_)) THEN
 CALL xios_set_domain_ni_glo(domain_hdl%daddr, ftype, ni_glo_)
 END IF

IF (PRESENT(nj_glo_)) THEN
 CALL xios_set_domain_nj_glo(domain_hdl%daddr, ftype, nj_glo_)
 END IF

IF (PRESENT(ibegin_)) THEN
 CALL xios_set_domain_ibegin(domain_hdl%daddr, ftype, ibegin_)
 END IF

IF (PRESENT(iend_)) THEN
 CALL xios_set_domain_iend(domain_hdl%daddr, ftype, iend_)
 END IF

IF (PRESENT(ni_)) THEN
 CALL xios_set_domain_ni(domain_hdl%daddr, ftype, ni_)
 END IF

IF (PRESENT(jbegin_)) THEN
 CALL xios_set_domain_jbegin(domain_hdl%daddr, ftype, jbegin_)
 END IF

IF (PRESENT(jend_)) THEN
 CALL xios_set_domain_jend(domain_hdl%daddr, ftype, jend_)
 END IF

IF (PRESENT(nj_)) THEN
 CALL xios_set_domain_nj(domain_hdl%daddr, ftype, nj_)
 END IF

IF (PRESENT(mask_)) THEN
 CALL xios_set_domain_mask(domain_hdl%daddr, ftype, mask_, size(mask_, 1), size(mask_, 2))
 END IF

IF (PRESENT(data_dim_)) THEN
 CALL xios_set_domain_data_dim(domain_hdl%daddr, ftype, data_dim_)
 END IF

IF (PRESENT(data_ni_)) THEN
 CALL xios_set_domain_data_ni(domain_hdl%daddr, ftype, data_ni_)
 END IF

IF (PRESENT(data_nj_)) THEN
 CALL xios_set_domain_data_nj(domain_hdl%daddr, ftype, data_nj_)
 END IF

IF (PRESENT(data_ibegin_)) THEN
 CALL xios_set_domain_data_ibegin(domain_hdl%daddr, ftype, data_ibegin_)
 END IF

IF (PRESENT(data_jbegin_)) THEN
 CALL xios_set_domain_data_jbegin(domain_hdl%daddr, ftype, data_jbegin_)
 END IF

IF (PRESENT(data_n_index_)) THEN
 CALL xios_set_domain_data_n_index(domain_hdl%daddr, ftype, data_n_index_)
 END IF

IF (PRESENT(data_i_index_)) THEN
 CALL xios_set_domain_data_i_index(domain_hdl%daddr, ftype, data_i_index_, size(data_i_index_, 1))
 END IF

IF (PRESENT(data_j_index_)) THEN
 CALL xios_set_domain_data_j_index(domain_hdl%daddr, ftype, data_j_index_, size(data_j_index_, 1))
 END IF

IF (PRESENT(lonvalue_)) THEN
 CALL xios_set_domain_lonvalue(domain_hdl%daddr, ftype, lonvalue_, size(lonvalue_, 1))
 END IF

IF (PRESENT(latvalue_)) THEN
 CALL xios_set_domain_latvalue(domain_hdl%daddr, ftype, latvalue_, size(latvalue_, 1))
 END IF

   END SUBROUTINE set_domain_attributes
   SUBROUTINE set_grid_attributes( grid_hdl, ftype &
,name_ &
,description_ &
,domain_ref_ &
,axis_ref_ &
   )
      TYPE(XHandle) :: grid_hdl
      INTEGER (kind = C_INT) :: ftype
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: name_
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: description_
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: domain_ref_
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: axis_ref_
IF (PRESENT(name_)) THEN
 CALL xios_set_grid_name(grid_hdl%daddr, ftype, name_, len(name_))
 END IF

IF (PRESENT(description_)) THEN
 CALL xios_set_grid_description(grid_hdl%daddr, ftype, description_, len(description_))
 END IF

IF (PRESENT(domain_ref_)) THEN
 CALL xios_set_grid_domain_ref(grid_hdl%daddr, ftype, domain_ref_, len(domain_ref_))
 END IF

IF (PRESENT(axis_ref_)) THEN
 CALL xios_set_grid_axis_ref(grid_hdl%daddr, ftype, axis_ref_, len(axis_ref_))
 END IF

   END SUBROUTINE set_grid_attributes
   SUBROUTINE set_file_attributes( file_hdl, ftype &
,name_ &
,description_ &
,output_freq_ &
,output_level_ &
,enabled_ &
   )
      TYPE(XHandle) :: file_hdl
      INTEGER (kind = C_INT) :: ftype
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: name_
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: description_
CHARACTER(len = *), OPTIONAL, INTENT(IN) :: output_freq_
INTEGER, OPTIONAL, INTENT(IN) :: output_level_
LOGICAL(kind = 1), OPTIONAL, INTENT(IN) :: enabled_
IF (PRESENT(name_)) THEN
 CALL xios_set_file_name(file_hdl%daddr, ftype, name_, len(name_))
 END IF

IF (PRESENT(description_)) THEN
 CALL xios_set_file_description(file_hdl%daddr, ftype, description_, len(description_))
 END IF

IF (PRESENT(output_freq_)) THEN
 CALL xios_set_file_output_freq(file_hdl%daddr, ftype, output_freq_, len(output_freq_))
 END IF

IF (PRESENT(output_level_)) THEN
 CALL xios_set_file_output_level(file_hdl%daddr, ftype, output_level_)
 END IF

IF (PRESENT(enabled_)) THEN
 CALL xios_set_file_enabled(file_hdl%daddr, ftype, enabled_)
 END IF

   END SUBROUTINE set_file_attributes
END MODULE IXMLIOSERVER