yaml_parser_test.F

Go to the documentation of this file.

      MODULE yaml_parser
!
!git $Id$
!================================================== Hernan G. Arango ===
!  Copyright (c) 2002-2025 The ROMS Group                              !
!    Licensed under a MIT/X style license                              !
!    See License_ROMS.md                                               !
!=======================================================================
!                                                                      !
!  This module contains several routines to process input YAML files.  !
!                                                                      !
!  Notice that several Fortran parsers exist for complex and simple    !
!  YAML files coded with Object-Oriented Programming (OOP) principles. !
!  For example, check:                                                 !
!                                                                      !
!   * FCKit  (https://github.com/ecmwf/fckit)                          !
!   * Fortran-YAML (https://github.com/BoldingBruggeman/fortran-yaml)  !
!   * yaFyaml (https://github.com/Goddard-Fortran-Ecosystem/yaFyaml)   !
!                                                                      !
!  However, this YAML parser is more uncomplicated with substantial    !
!  capabilities. It is a hybrid between standard and OOP principles    !
!  but without the need for recurrency, inheritance, polymorphism,     !
!  and containers.                                                     !
!                                                                      !
!  The only constraint is that the YAML file is read twice for         !
!  simplicity. The first read determines the number indentation of     !
!  blanks policy and the length of the collection list(:) pairs object !
!  (CLASS yaml_pair).  It supports:                                    !
!                                                                      !
!   * Single or multiple line comments start with a hash '#'. Also,    !
!     comment after a key/value pair is allowed. All comments are      !
!     skipped during processing.                                       !
!   * Unlimited nested structure (lists, mappings, hierarchies).       !
!     Indentation of whitespace is used to denote structure.           !
!   * Unrestricted schema indentation. However, some schema validators !
!     recommend or impose two whitespace indentations.                 !
!   * A key is followed by a colon to denote a mapping value (like     !
!     ocean_model: ROMS).                                              !
!   * Aliases and Anchors.                                             !
!   * Blocking lists: members are denoted by a leading hyphen and      !
!     space, which is considered as part of the indentation.           !
!   * Flow sequence: a vector list with values enclosed in square      !
!     brackets and separated by a comma-and-space: [val1, ..., valN].  !
!   * Keyword values are processed and stored as strings but converted !
!     to a logical, integer, or floating-point type when appropriate   !
!     during extraction. If derived-type values are needed, the caller !
!     can process such structure outside this module, as shown below.  !
!   * Remove unwanted control characters like tabs and separators      !
!     (ASCII character code 0-31)                                      !
!   * English uppercase and lowercase alphabet, but it can be expanded !
!     to other characters (see yaml_ValueType routine)                 !
!   * Module is self contained, but it has very minimal association to !
!     four ROMS modules.                                               !
!   * Multiple or continuation lines are supported, for example we can !
!     have:                                                            !
!                                                                      !
!       state variables: [sea_surface_height_above_geopotential_datum, !
!                         barotropic_sea_water_x_velocity,             !
!                         barotropic_sea_water_y_velocity,             !
!                         sea_water_x_velocity,                        !
!                         sea_water_y_velocity,                        !
!                         sea_water_potential_temperature,             !
!                         sea_water_practical_salinity]                !
!                                                                      !
!  Usage:                                                              !
!                                                                      !
!    USE yaml_parser_mod, ONLY : yaml_initialize, yaml_get, yaml_tree  !
!                                                                      !
!    TYPE (yaml_tree) :: YML                                           !
!                                                                      !
!    CALL yaml_initialize (YML, 'ocn_coupling.yaml', report)           !
!    status = yaml_get(YML, 'Nimport', Nimport)                        !
!    status = yaml_get(YML, 'import.standard_name', Sstandard)         !
!    status = yaml_get(YML, 'import.standard_name.short_name', S%short)!
!    status = yaml_get(YML, 'import.standard_name.unit', S%units)      !
!    ...                                                               !
!                                                                      !
!    and so on for logical, integer, floating-point, and string        !
!    key/value pairs.                                                  !
!                                                                      !
!    Here, 'Sstandard(1:Nimport) will contain all 'standard_name'      !
!    values for the YAML block 'import:'. Notice that nested keywords  !
!    are concatenated with a period: 'key1.key2.key3' for a three-     !
!    level nested block, similar to how Matlab build structures. The   !
!    key can have more than one word separated by one space. For       !
!    example, we can have 'bulk_flux import.standard_name'. Similarly, !
!    any otherkey/value pair can be extrated from the YML object.      !
!                                                                      !
!=======================================================================
!
!  Define local parameters.
!
      logical :: yaml_master = .true.          ! Master process
      logical :: lreport = .true.              ! dumps YAML dictionaty
!
      integer, parameter :: kind_real = selected_real_kind(12,300)
      integer, parameter :: dp        = selected_real_kind(12,300)
 
      integer, parameter :: yaml_stdout = 6          ! standard output
      integer, parameter :: stdout      = 6          ! standard output
 
      integer, parameter  :: noerror = 0             ! No error flag
 
      integer :: yaml_errflag = 0                    ! error flag
!
!-----------------------------------------------------------------------
!  Structures/Objects to hold YAML dictionary lists with theirs keys and
!  values.
!-----------------------------------------------------------------------
!
!  YAML file key/value pair.
!
      TYPE, PUBLIC :: yaml_pair
 
        logical :: has_alias                      ! alias '*' token
        logical :: has_anchor                     ! anchor '&' token
        logical :: is_block                       ! block '-' list
        logical :: is_sequence                    ! sequence '[]' tokens
!
        logical :: is_logical                     ! logical value
        logical :: is_integer                     ! integer value
        logical :: is_real                        ! numerical value
        logical :: is_string                      ! string value
!
        integer :: id                             ! key/value ID
        integer :: parent_id                      ! parent ID
        integer :: left_padding                   ! indent level: 0,1,..
!
        character (len=:), allocatable :: line    ! YAML line
        character (len=:), allocatable :: key     ! YAML keyword:
        character (len=:), allocatable :: value   ! YAML value(s)
        character (len=:), allocatable :: anchor  ! anchor keyword
 
      END TYPE yaml_pair
!
!  YAML file dictionary tree.
!
      TYPE, PUBLIC :: yaml_tree
 
        logical :: iscreated = .false. ! Object creation switch
 
        integer :: nbranches           ! total number of branches
        integer :: npairs              ! total number of pairs
        integer :: indent              ! blank indentation policy
!
        character (len=:),  allocatable :: filename  ! YAML file name
!
!  YAML file collection pairs, [1:Npairs].
!
        TYPE (yaml_pair), pointer :: list(:)
!
        CONTAINS                       ! CLASS objects
!
        PROCEDURE :: create       => yaml_tree_create
        PROCEDURE :: destroy      => yaml_tree_destroy
        PROCEDURE :: dump         => yaml_tree_dump
        PROCEDURE :: extract      => yaml_tree_extract
        PROCEDURE :: fill         => yaml_tree_fill
        PROCEDURE :: fill_aliases => yaml_tree_fill_aliases
        PROCEDURE :: has          => yaml_tree_has
        PROCEDURE :: read_line    => yaml_tree_read_line
 
      END TYPE yaml_tree
!
!  Public structures that can be used in applications to extract block
!  list YAML constructs. The key may represents a sequence flow [...]
!  with a vector of values. The values can be integers, logicals, reals,
!  or strings.  For example,
!
!  import:
!    - standard_name:       surface_downward_heat_flux_in_sea_water
!      long_name:           surface net heat flux
!      short_name:          shflux
!      data_variables:      [shf, shf_time]
!    - standard_name:       surface_wind_x_stress
!      long_name:           surface zonal wind stress component
!      short_name:          sustr
!      data_variables:      [taux, atm_time]
!    - standard_name:       surface_wind_y_stress
!      long_name:           surface meridional wind stress component
!      short_name:          svstr
!      data_variables:      [tauy, atm_time]
!
!  The extraction is loaded into V, which is a TYPE "yaml_Svec"
!  structure:
!
!    status = yaml_get(YML, 'import.data_variables', V)
!
!  or altenatively
!
!    IF (yaml_Error(yaml_get(YML, 'import.data_variables', V),          &
!   &               NoErr, __LINE__, MyFile)) RETURN
!
!  yielding the following block-list, string structure in a single
!  invocation of the overloaded function "yaml_get":
!
!    V(1)%vector(1)%value = 'shf'
!    V(1)%vector(2)%value = 'shf_time'
!    V(2)%vector(1)%value = 'taux'
!    V(2)%vector(2)%value = 'atm_time'
!    V(3)%vector(1)%value = 'tauy'
!    V(3)%vector(2)%value = 'atm_time'
!
!  It is a compact way to extract similar data blocks.
!
      TYPE, PUBLIC :: yaml_ivec                      ! integer structure
        integer, allocatable :: vector(:)            ! vector values
      END TYPE yaml_ivec
!
      TYPE, PUBLIC :: yaml_lvec                      ! logical structure
        logical, allocatable :: vector(:)            ! vector values
      END TYPE yaml_lvec
!
      TYPE, PUBLIC :: yaml_rvec                      ! real structure
        real (kind_real), allocatable :: vector(:)   ! vector values
      END TYPE yaml_rvec
!
      TYPE, PUBLIC :: yaml_svec                      ! string structure
        character (len=:), allocatable :: value      ! scalar value
        TYPE (yaml_svec),  pointer :: vector(:)      ! recursive vector
      END TYPE yaml_svec                             ! values
!
!  Derived-type structure, extended/inherited from parent "yaml_Svec",
!  is used to extract hierarchies of keys and associated values from
!  YAML dictionary object. The calling program specifies a key-string
!  that may be generated by aggregating nested keys with a period.
!  Also, it can extract flow sequence string element values that are
!  separated by commas.
!
      TYPE, PRIVATE, EXTENDS(yaml_svec) :: yaml_extract
        logical :: has_vector             ! true if loaded vector values
      END TYPE yaml_extract
!
!-----------------------------------------------------------------------
!  Define public overloading API to extract key/value pairs from YAML
!  tree dictionary object accounting to variable type.
!-----------------------------------------------------------------------
!
      INTERFACE yaml_get
        MODULE PROCEDURE yaml_get_i_struc       ! Gets integer structure
        MODULE PROCEDURE yaml_get_l_struc       ! Gets logical structure
        MODULE PROCEDURE yaml_get_r_struc       ! Gets real    structure
        MODULE PROCEDURE yaml_get_s_struc       ! Gets string  structure
!
        MODULE PROCEDURE yaml_get_ivar_0d       ! Gets integer value
        MODULE PROCEDURE yaml_get_ivar_1d       ! Gest integer values
        MODULE PROCEDURE yaml_get_lvar_0d       ! Gets logical value
        MODULE PROCEDURE yaml_get_lvar_1d       ! Gets logical values
        MODULE PROCEDURE yaml_get_rvar_0d       ! Gets real    value
        MODULE PROCEDURE yaml_get_rvar_1d       ! Gets real    values
        MODULE PROCEDURE yaml_get_svar_0d       ! Gets string  value
        MODULE PROCEDURE yaml_get_svar_1d       ! Gets string  values
      END INTERFACE yaml_get
!
!
!-----------------------------------------------------------------------
!  Define generic coupling field to process import and export states.
!-----------------------------------------------------------------------
!
      TYPE couplingfield
        logical :: connected
        logical :: debug_write
!
        real(dp) :: add_offset
        real(dp) :: scale
!
        character (len=:), allocatable :: connected_to
        character (len=:), allocatable :: data_netcdf_vname
        character (len=:), allocatable :: data_netcdf_tname
        character (len=:), allocatable :: destination_grid
        character (len=:), allocatable :: destination_units
        character (len=:), allocatable :: extrapolate_method
        character (len=:), allocatable :: long_name
        character (len=:), allocatable :: map_norm
        character (len=:), allocatable :: map_type
        character (len=:), allocatable :: regrid_method
        character (len=:), allocatable :: source_units
        character (len=:), allocatable :: source_grid
        character (len=:), allocatable :: short_name
        character (len=:), allocatable :: standard_name
!
      END TYPE couplingfield
!
! <><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
!  YAML Tree Post-proccesing Variables and Structures:
!
!  Define generic YAML dictionary, containers, and counters used
!  during processing.
!-----------------------------------------------------------------------
!
      logical :: ldebugmetadata = .true.           ! Debugging switch
!
!  Counters.
!
      integer :: ientry                            ! entry counter
      integer :: nentries                          ! number of entries
!
!  logical scalar dummy values.
!
      logical, allocatable :: ylogical1(:)
!
!  Real scalar dummy values.
!
      real(kind_real), allocatable :: yreal1(:)
      real(kind_real), allocatable :: yreal2(:)
!
!  Derived-type dummy structures for processing string value or set
!  of values from a sequence flow, [val1, ..., valN].
!
      TYPE (yaml_svec), allocatable :: ystring1 (:)
      TYPE (yaml_svec), allocatable :: ystring2 (:)
      TYPE (yaml_svec), allocatable :: ystring3 (:)
      TYPE (yaml_svec), allocatable :: ystring4 (:)
      TYPE (yaml_svec), allocatable :: ystring5 (:)
      TYPE (yaml_svec), allocatable :: ystring6 (:)
      TYPE (yaml_svec), allocatable :: ystring7 (:)
      TYPE (yaml_svec), allocatable :: ystring8 (:)
      TYPE (yaml_svec), allocatable :: ystring9 (:)
      TYPE (yaml_svec), allocatable :: ystring10(:)
      TYPE (yaml_svec), allocatable :: ystring11(:)
      TYPE (yaml_svec), allocatable :: ystring12(:)
!
      PUBLIC  :: cmeps_metadata
      PUBLIC  :: coupling_metadata
      PUBLIC  :: process_yaml
!
! <><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
!
      PUBLIC  :: yaml_assignstring
      PUBLIC  :: yaml_error
      PUBLIC  :: yaml_get
      PUBLIC  :: yaml_initialize
!
      PRIVATE :: yaml_countkeys
      PRIVATE :: yaml_lowercase
      PRIVATE :: yaml_uppercase
      PRIVATE :: yaml_valuetype
!
      PRIVATE
!
!-----------------------------------------------------------------------
!  Local module parameters.
!-----------------------------------------------------------------------
!
      logical, parameter :: ldebugyaml = .false.  ! debugging switch
!
      integer, parameter :: ldim = 8    ! logical Lswitch dimension
      integer, parameter :: lkey = 254  ! Maximum characters per keyword
      integer, parameter :: lmax = 2048 ! Maximum characters per line
      integer, parameter :: noerr = 0   ! no error flag
      integer, parameter :: iunit = 222 ! Fortan unit for reading
!
      character (len=55), dimension(7) :: yaml_errmsg =                 &
     &  (/ ' YAML_PARSER - Blows up ................ yaml_ErrFlag: ',   &
     &     ' YAML_PARSER - Input error ............. yaml_ErrFlag: ',   &
     &     ' YAML_PARSER - Output error ............ yaml_ErrFlag: ',   &
     &     ' YAML_PARSER - I/O error ............... yaml_ErrFlag: ',   &
     &     ' YAML_PARSER - Configuration error ..... yaml_ErrFlag: ',   &
     &     ' YAML_PARSER - Partition error ......... yaml_ErrFlag: ',   &
     &     ' YAML_PARSER - Illegal input parameter . yaml_ErrFlag: ' /)
!
!-----------------------------------------------------------------------
      CONTAINS
!-----------------------------------------------------------------------
!
      FUNCTION yaml_initialize (self, filename, report) RESULT (status)
!
!***********************************************************************
!                                                                      !
!  It creates a YAML tree dictionary object. First, it reads the YAML  !
!  file to determine the indentation policy and length of list oject   !
!  (TYPE yaml_tree).                                                   !
!                                                                      !
!  After the object is allocated, the Fortran unit is rewinded and the !
!  YAML file is read again to populate the keyword values.             !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     self       YAML tree dictionary object (CLASS yaml_tree)         !
!     filename   YAML filename (string)                                !
!     report     Switch to dump to standard output (logical, OPTIONAL) !
!                                                                      !
!  On Ouptut:                                                          !
!                                                                      !
!     self       Allocated and populated YAML object.                  !
!     status     Error flag (integer)                                  !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      class(yaml_tree), intent(inout) :: self
      character (len=*), intent(in   ) :: filename
      logical, optional, intent(in   ) :: report
!
!  Local variable declarations.
!
      logical :: ldump
!
      integer :: lenstr, status
!
      character (len=*), parameter :: myfile =                          &
     &   __FILE__//", yaml_initialize"
!
!-----------------------------------------------------------------------
!  Initialize YAML object.
!-----------------------------------------------------------------------
!
      status=noerr
!
!  Set switch to print the processed YAML key/value pairs to standard
!  ouput.
!
      IF (PRESENT(report)) THEN
        ldump = report
      ELSE
        ldump = .false.
      END IF
!
!  Set YAML file path and name.
!
      IF (yaml_error(yaml_assignstring(self%filename,                   &
     &                                 filename, lenstr),               &
     &               noerr, __line__, myfile)) THEN
        status=yaml_errflag
        RETURN
      END IF
!
!  Create and populate YAML object.
!
      IF (self%IsCreated) CALL self%destroy ()
!
      CALL self%create ()
      IF (yaml_error(yaml_errflag, noerr, __line__, myfile)) THEN
        status=yaml_errflag
        RETURN
      END IF
!
!  Report YAML tree dictionary, for debugging.
!
      IF (ldump) CALL self%dump ()
!
      RETURN
      END FUNCTION yaml_initialize
!
      SUBROUTINE yaml_tree_create (self)
!
!***********************************************************************
!                                                                      !
!  It creates a YAML tree dictionary object. First, it reads the YAML  !
!  file to determine the dimensions of parent and children structures. !
!  After the structures are allocate, the Fortran unit is rewinded and !
!  YAML file is read again to populate the keyword values.             !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     self       YAML tree dictionary object (CLASS yaml_tree)         !
!                                                                      !
!  On Ouptut:                                                          !
!                                                                      !
!     self       Allocated and populated YAML object.                  !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      class(yaml_tree), intent(inout) :: self
!
!  Local variable declarations.
!
      logical :: FirstPass, Lswitch(Ldim)
!
      integer :: Nblanks, Nbranches, Npairs
      integer :: i, io_err, status
!
      character (len=Lkey) :: anchor, io_errmsg, key
      character (len=Lmax) :: line, value
!
      character (len=*), parameter :: MyFile =                          &
     &   __FILE__//", yaml_tree_create"
!
!-----------------------------------------------------------------------
!  Open YAML file for reading.
!-----------------------------------------------------------------------
!
      OPEN (unit=iunit, file=self%filename, form='formatted',           &
     &      status='old', iostat=io_err, iomsg=io_errmsg)
      IF (io_err.ne.0) THEN
        yaml_errflag=5
        IF (yaml_error(yaml_errflag, noerr, __line__, myfile)) THEN
          IF (yaml_master) WRITE (yaml_stdout,10) self%filename,        &
     &                                            trim(io_errmsg)
          RETURN
        END IF
      END IF
!
!  Determine the total number of YAML key/value pairs.
!
      nblanks   = 0
      nbranches = 0
      npairs    = 0
!
      firstpass = .true.
!
      yaml_line : DO WHILE (.true.)
!
        status=self%read_line(nblanks, line, key, value, anchor,        &
     &                        lswitch)
!
        SELECT CASE (status)
          CASE (-1)       ! error condition during reading
            yaml_errflag=5
            IF (yaml_error(yaml_errflag, noerr, __line__, myfile)) THEN
              IF (yaml_master) WRITE (yaml_stdout,20) self%filename,    &
     &                                                trim(line)
              RETURN
            END IF
          CASE (0)        ! end-of-file
            EXIT
          CASE (1)        ! blank or comment line, move to the next line
            cycle
          CASE (2)        ! processed viable line
            npairs=npairs+1
        END SELECT
!
!  If no leading blanks, advance YAML tree branch counter.
!
        IF (nblanks.eq.0) THEN
          nbranches = nbranches+1          ! hierarchy start
        END IF
!
!  On first pass, establish indentation policy: number of blanks.
!
        IF (firstpass.and.(nblanks.gt.0)) THEN
          firstpass=.false.
          self%indent=nblanks
        END IF
!
!  Check for consitent identation policy.  Some YAML validators impose
!  a two-blank spacing policy.
!
        IF (nblanks.gt.0) THEN
          IF (mod(nblanks, self%indent).ne.0) THEN
            yaml_errflag=2
            IF (yaml_error(yaml_errflag, noerr, __line__, myfile)) THEN
              IF (yaml_master) WRITE (yaml_stdout,30) nblanks,          &
     &                                                self%indent
              RETURN
            END IF
          END IF
        END IF
 
      END DO yaml_line
!
!  Rewind unit since we need to reprocess the file again to load the
!  data into the allocated "self%list(1:Npairs)" container.
!
      rewind(iunit)
!
!-----------------------------------------------------------------------
!  Allocate YAML dictionary container.
!-----------------------------------------------------------------------
!
!  Set number of main branches and number of key/values in YAML 'list'.
!
      self%Nbranches=nbranches
      self%Npairs=npairs
!
!  Allocate YAML key/value pair list (TYPE 'yaml_pair') object.
!
      IF (.not.self%IsCreated) THEN
        ALLOCATE ( self%list(npairs) )
        self%IsCreated=.true.
      END IF
!
!-----------------------------------------------------------------------
!  Re-read YAML file again and populate dictionary.
!-----------------------------------------------------------------------
!
      CALL self%fill ()
!
  10  FORMAT (/,' YAML_TREE_CREATE - Unable to open input YAML file: ', &
     &        a,/,20x,'ERROR: ',a)
  20  FORMAT (/,' YAML_TREE_CREATE - Error while reading YAML file: ',  &
     &        a,/,20x,'LINE: ',a)
  30  FORMAT (/,' YAML_TREE_CREATE - Inconsistent indentation, ',       &
     &        'self%indent = ',i0,',  nblanks = ',i0)
  40  FORMAT (/,' YAML_TREE_CREATE - Inconsistent indentation, ',       &
     &        'nblanks = ',i0,', indent blank policy = ',i0,/,20x,      &
     &        'Number of nested collections = ',i0,                     &
     &        ' is greater than 3',/,20x,'Line: ',a)
  50  FORMAT (/,' YAML_TREE_CREATE - Cannot find branches in YAML ',    &
     &        'file: ',a)
!
      RETURN
      END SUBROUTINE yaml_tree_create
!
      SUBROUTINE yaml_tree_destroy (self)
!
!***********************************************************************
!                                                                      !
!  It deallocates/destroys the YAML dictionary object.                 !
!                                                                      !
!  Arguments:                                                          !
!                                                                      !
!     self       YAML tree dictionary object (CLASS yaml_tree)         !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      class(yaml_tree), intent(inout) :: self
!
!  Local variable declarations.
!
      logical :: Lopened
!
!-----------------------------------------------------------------------
!  Deallocate YAML dictionary object.
!-----------------------------------------------------------------------
!
!  If applicable, close YAML Fortran unit.
!
      INQUIRE (unit=iunit, opened=lopened)
      IF (lopened) THEN
        CLOSE (iunit)
      END IF
!
!  Recall that Fortran 2003 standard allows deallocating just the
!  parent object to deallocate all array variables within its scope
!  automatically.
!
      IF (ASSOCIATED(self%list)) THEN
        self%IsCreated=.false.
        DEALLOCATE (self%list)
      END IF
!
      RETURN
      END SUBROUTINE yaml_tree_destroy
!
      SUBROUTINE yaml_tree_dump (self)
!
!***********************************************************************
!                                                                      !
!  It prints the YAML dictionary to standard output for debugging      !
!  purposes.                                                           !
!                                                                      !
!  Arguments:                                                          !
!                                                                      !
!     self       YAML tree dictionary object (CLASS yaml_tree)         !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      class(yaml_tree), intent(in) :: self
!
!  Local variable declarations.
!
      integer :: Lstr, Nblanks, i, indent, padding
!
      character (len=Lkey) :: key
      character (len=Lmax) :: string, value
!
!-----------------------------------------------------------------------
!  Report the contents of the YAML tree directory.
!-----------------------------------------------------------------------
!
      IF (yaml_master) THEN
        WRITE (yaml_stdout,10) self%filename
        indent=self%indent
!
        DO i=1,self%Npairs
          padding=self%list(i)%left_padding
          nblanks=indent*padding
          key=self%list(i)%key
          IF (ALLOCATED(self%list(i)%value)) THEN
            value=self%list(i)%value
            lstr=len_trim(value)
          ELSE
            lstr=0
          END IF
          IF (self%list(i)%is_block) THEN
            IF (lstr.gt.0) THEN
              IF (self%list(i)%is_sequence) THEN
                WRITE (string,20) i, repeat(char(32),nblanks), '- ',    &
     &                            trim(key), ': [', trim(value), ']'
              ELSE
                WRITE (string,30) i, repeat(char(32),nblanks), '- ',    &
     &                            trim(key), ': ', trim(value)
              END IF
            ELSE
              WRITE (string,40) i, repeat(char(32),nblanks), '- ',      &
     &                          trim(key), ':'
            END IF
          ELSE
            IF (lstr.gt.0) THEN
              IF (self%list(i)%is_sequence) THEN
                WRITE (string,30) i, repeat(char(32),nblanks),          &
     &                            trim(key), ': [', trim(value), ']'
              ELSE
                WRITE (string,40) i, repeat(char(32),nblanks),          &
     &                            trim(key), ': ', trim(value)
              END IF
            ELSE
              WRITE (string,50) i, repeat(char(32),nblanks),            &
     &                          trim(key), ':'
            END IF
          END IF
          WRITE (yaml_stdout,60) trim(string)
        END DO
      END IF
!
  10  FORMAT (/,"YAML Tree Dictinary, file: '",a,"'",/,                 &
     &          '==========================',/)
  20  FORMAT ('L=',i4.4,1x,'% ',6a)
  30  FORMAT ('L=',i4.4,1x,'% ',5a)
  40  FORMAT ('L=',i4.4,1x,'% ',4a)
  50  FORMAT ('L=',i4.4,1x,'% ',3a)
  60  FORMAT (a)
!
      RETURN
      END SUBROUTINE yaml_tree_dump
!
      FUNCTION yaml_tree_extract (self, keystring, S) RESULT (status)
!
!***********************************************************************
!                                                                      !
!  It extracts YAML value(s) from processing key-string. The key       !
!  string may be a set of keys aggregated with a period, CHAR(46).     !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     self       YAML tree dictionary object (CLASS yaml_tree)         !
!     keystring  Aggregated YAML keys (string)                         !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     S          Separated YAML key/pair value (TYPE yaml_extract)     !
!     nkeys      Number of extracted keys (integer)                    !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      class(yaml_tree), intent(in) :: self
      character (len=*), intent(in) :: keystring
      TYPE (yaml_extract), allocatable, intent(inout) :: s(:)
!
!  Local variable declarations.
!
      TYPE (yaml_extract), allocatable :: k(:)
!
      logical :: blockflow
!
      integer :: i, ib, ic, ie, ik, ipair, is, j, li, pid
      integer :: lstr, lenstr, nkeys, npairs, nvalues
      integer :: icomma, idot
      integer :: status
!
      integer, allocatable :: p(:)                   ! pair index
!
      character (len=:), allocatable :: kstring      ! key string
      character (len=:), allocatable :: vstring      ! value string
!
      character (len=*), parameter :: myfile =                          &
     &   __FILE__//", yaml_tree_extract"
!
!-----------------------------------------------------------------------
!  Extract YAML key(s) from key-string.
!-----------------------------------------------------------------------
!
      status=noerr
!
!  Count the number keys in key-string, separated by period.
!
      lstr=len_trim(keystring)
      IF (yaml_error(yaml_assignstring(kstring,                         &
     &                                 keystring, lenstr),              &
     &               noerr, __line__, myfile)) RETURN
!
      nkeys=yaml_countkeys(kstring, char(46))
!
!  Allocate key structure.
!
      ALLOCATE ( k(nkeys) )
!
!  Extract keys.
!
      is=1
      DO i=1,nkeys
        idot=index(kstring,char(46),back=.false.)
        ie=idot
        IF (idot.eq.0) THEN
          ie=len_trim(kstring)
        ELSE
          ie=ie-1
        END IF
        IF (yaml_error(yaml_assignstring(k(i)%value,                    &
     &                                   kstring(is:ie), lenstr),       &
     &                 noerr, __line__, myfile)) RETURN
        IF (idot.gt.0) kstring(is:ie+1) = repeat(char(32), ie-is+2)
        kstring=trim(adjustl(kstring))
      END DO
!
!-----------------------------------------------------------------------
!  Determine the number of YAML tree pairs to process and assoicated
!  list array element.
!-----------------------------------------------------------------------
!
!  Check if key-string is a blocking list where any of the members has
!  a leading hyphen as indentation. If blocking, all the pairs with the
!  same key-string are extracted.
!
      blockflow=.false.          ! Switch to process all block membert
      ib=0                       ! block list(s) counter
      ic=0                       ! key/value pair counter
      ik=1                       ! key counter to avoid double DO-loops
!
      DO i=1,self%Npairs
        lstr=len_trim(self%list(i)%key)
        IF ((self%list(i)%key).eq.(k(ik)%value)) THEN
 
          IF (yaml_master.and.ldebugyaml) THEN
            print '(2(a,i0,2a))', 'key ',ik,' = ', trim(k(ik)%value),   &
     &                            ', YAML list ',i,' = ',               &
     &                            trim(self%list(i)%key)
          END IF
 
          pid=self%list(i)%parent_id
          IF (self%list(i)%is_block.or.self%list(pid)%is_block) THEN
            ib=ib+1                             ! advance block counter
          END IF
          IF (ik.eq.nkeys) THEN
            ic=ic+1                             ! advance pair counter
            IF (ib.eq.0) THEN
              li=i                              ! list index to extract
              EXIT                              ! no blocking list found
            ELSE
              blockflow=.true.
            END IF
          ELSE
            ik=ik+1                             ! advance key counter
          END IF
        END IF
        IF (blockflow.and.(self%list(i)%left_padding.eq.0)) THEN
          EXIT                                  ! processed all blocks
        END IF
      END DO
      npairs=ic                                 ! pairs to process
!
!  Allocate pair index array, P.
!
      IF (npairs.ne.0) THEN
        IF (.not.ALLOCATED(p)) ALLOCATE ( p(npairs) )
      ELSE
        yaml_errflag=7
        status=yaml_errflag
        IF (yaml_error(yaml_errflag, noerr, __line__, myfile)) THEN
          IF (yaml_master) WRITE (yaml_stdout,10) keystring,            &
     &                                            self%filename
          RETURN
        END IF
      END IF
!
!  Set pair element(s) to extract.
!
      IF (blockflow) THEN
        ic=0
        ik=1
        DO i=1,self%Npairs
          IF ((self%list(i)%key).eq.(k(ik)%value)) THEN
            IF (ik.eq.nkeys) THEN
              ic=ic+1
              p(ic)=i                           ! multiple pair index
            ELSE
              ik=ik+1
            END IF
          END IF
          IF ((ic.gt.0).and.(self%list(i)%left_padding.eq.0)) THEN
            EXIT                                ! processed all blocks
          END IF
        END DO
      ELSE
        p(1)=li                                 ! single pair index
      END IF
!
!-----------------------------------------------------------------------
!  Extract pair(s) value(s).
!-----------------------------------------------------------------------
!
      DO i=1,npairs
        ipair=p(i)
!
!  Get key-string value.
!
        IF (yaml_error(yaml_assignstring(vstring,                       &
     &                                   self%list(ipair)%value,        &
     &                                   lenstr),                       &
     &                 noerr, __line__, myfile)) RETURN
!
!-----------------------------------------------------------------------
!  Extract/load keys-tring value(s). In a sequence, values are separated
!  by commas.
!-----------------------------------------------------------------------
!
!  Extract pair from a blocking list. Currently, scalar value are
!  allowed. Nested blocking is not supported since it is complicated
!  to process. For example, the following nested blocking lists are
!  not supported.
!
!  branch:
!    - blocklist1: value
!      blocklist1_key1: value
!        - blocklist1A: value                          ! not supported
!
        IF (blockflow) THEN
!
!  Process a block list pair with vector values (flow sequence):
!  S(i)%vector(1)%value  to  S(i)%vector(nvalues)%value
!
          IF (self%list(ipair)%is_sequence) THEN
            lstr=len_trim(vstring)
            nvalues=count((/(vstring(j:j), j=1,lstr)/) == char(44)) + 1
!
            IF (.not.ALLOCATED(s)) THEN
              ALLOCATE ( s(npairs) )                   ! main structure
            END IF
            ALLOCATE ( s(i)%vector(nvalues) )          ! sub-structure
            s(i)%has_vector=.true.
!
            is=1
            DO j=1,nvalues
              icomma=index(vstring,char(44),back=.false.)
              ie=icomma
              IF (icomma.eq.0) THEN
                ie=len_trim(vstring)
              ELSE
                ie=ie-1
              END IF
              IF (yaml_error(yaml_assignstring(s(i)%vector(j)%value,    &
     &                                         vstring(is:ie),          &
     &                                         lenstr),                 &
     &                       noerr, __line__, myfile)) RETURN
 
              IF (yaml_master.and.ldebugyaml) THEN
                print '(3a,2(i0,a),a)', 'keystring = ',trim(keystring), &
     &                               ', S(', i, ')%vector(', j, ') = ', &
     &                               trim(s(i)%vector(j)%value)
              END IF
 
              IF (icomma.gt.0) vstring(is:ie+1)=repeat(char(32),ie-is+2)
              vstring=trim(adjustl(vstring))
            END DO
!
!  Process a block list pair with a scalar value, S(i)%value
!
          ELSE
!
            IF (.not.ALLOCATED(s)) THEN
              ALLOCATE ( s(npairs) )
            END IF
            s(i)%has_vector=.false.
!
            IF (yaml_error(yaml_assignstring(s(i)%value,                &
     &                                       vstring, lenstr),          &
     &                     noerr, __line__, myfile)) RETURN
 
            IF (yaml_master.and.ldebugyaml) THEN
              print '(a,i0,4a)', 'keystring ',i,' = ', trim(keystring), &
     &                           ', value = ', trim(s(i)%value)
            END IF
          END IF
!
!  Otherwise, process a non-block list.
!
        ELSE
!
!         Process a flow sequence:  S(1)%value to S(nvalues)%value.
!
          IF (self%list(ipair)%is_sequence) THEN
            lstr=len_trim(vstring)
            nvalues=count((/(vstring(j:j), j=1,lstr)/) == char(44)) + 1
!
            ALLOCATE ( s(nvalues) )
            s(i)%has_vector=.false.
!
            is=1
            DO j=1,nvalues
              icomma=index(vstring,char(44),back=.false.)
              ie=icomma
              IF (icomma.eq.0) THEN
                ie=len_trim(vstring)
              ELSE
                ie=ie-1
              END IF
              IF (yaml_error(yaml_assignstring(s(j)%value,              &
     &                                         vstring(is:ie),          &
     &                                         lenstr),                 &
     &                       noerr, __line__, myfile)) RETURN
              IF (icomma.gt.0) vstring(is:ie+1)=repeat(char(32),ie-is+2)
              vstring=trim(adjustl(vstring))
 
              IF (yaml_master.and.ldebugyaml) THEN
                print '(a,i0,4a)', 'keystring ',j,' = ',                &
     &                             trim(keystring),                     &
     &                             ', value = ', trim(s(j)%value)
              END IF
            END DO
!
!         Process a single scalar value, S(1)%value.
!
          ELSE
!
            ALLOCATE ( s(1) )
            s(1)%has_vector=.false.
!
            IF (yaml_error(yaml_assignstring(s(1)%value,                &
     &                                       vstring, lenstr),          &
     &                     noerr, __line__, myfile)) RETURN
 
            IF (yaml_master.and.ldebugyaml) THEN
               print '(4a)', 'keystring = ', trim(keystring),           &
     &                       ', value = ', trim(s(1)%value)
            END IF
          END IF
        END IF
      END DO
!
!-----------------------------------------------------------------------
!  Deallocate local variables.
!-----------------------------------------------------------------------
!
      IF (ALLOCATED(k))       DEALLOCATE (k)
      IF (ALLOCATED(p))       DEALLOCATE (p)
      IF (ALLOCATED(kstring)) DEALLOCATE (kstring)
      IF (ALLOCATED(vstring)) DEALLOCATE (vstring)
!
  10  FORMAT (/," YAML_TREE_EXTRACT - Cannot find key-string: '",a,     &
     &        "'",/,21x,'File: ',a)
  20  FORMAT (/," YAML_TREE_EXTRACT - Not supported key-string: '",a,   &
     &        "'",/,21x,'nested sub-blocking in a leading blocking ',   &
     &        'list',/,21x,'File: ',a)
!
      RETURN
      END FUNCTION yaml_tree_extract
!
      SUBROUTINE yaml_tree_fill (self)
!
!***********************************************************************
!                                                                      !
!  It reads YAML file and fills structure with the key/value pairs.    !
!  Both the key and value pairs are strings. The numercal convertions  !
!  are done elsewhere when needed.                                     !
!                                                                      !
!  Arguments:                                                          !
!                                                                      !
!     self       YAML tree dictionary object (CLASS yaml_tree)         !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      class(yaml_tree), intent(inout) :: self
!
!  Local variable declarations.
!
      logical :: Lswitch(Ldim)
!
      integer :: Nblanks, LenStr, left_padding, new_parent, old_parent
      integer :: i, ibranch, icount, ic_alias, ic_anchor, status
!
      character (len=Lkey) :: anchor, key
      character (len=Lmax) :: line, value
!
      character (len=*), parameter :: MyFile =                          &
     &   __FILE__//", yaml_tree_fill"
!
!-----------------------------------------------------------------------
!  Read and populate YAML structure.
!-----------------------------------------------------------------------
!
      ibranch=0
      icount=0
      ic_alias=0
      ic_anchor=0
      new_parent=0
      old_parent=0
!
      yaml_line : DO WHILE (.true.)
!
        status=self%read_line(nblanks, line, key, value, anchor,        &
     &                        lswitch)
!
        SELECT CASE (status)
          CASE (-1)       ! error condition during reading
            yaml_errflag=4
            IF (yaml_error(yaml_errflag, noerr, __line__, myfile)) THEN
              IF (yaml_master) WRITE (yaml_stdout,10) self%filename,    &
     &                                                trim(line)
              RETURN
            END IF
          CASE (0)        ! end-of-file
            EXIT
          CASE (1)        ! blank or comment line, move to the next line
            cycle
          CASE (2)        ! processed viable line
            icount=icount+1
        END SELECT
!
!  Determine structure indices according to the nested levels counters.
!
        IF (nblanks.eq.0) THEN
          ibranch=ibranch+1
          new_parent=icount
          old_parent=icount
        END IF
!
!  Load YAML pair switch identifiers.
!
        self%list(icount)%has_alias   = lswitch(1)
        self%list(icount)%has_anchor  = lswitch(2)
        self%list(icount)%is_block    = lswitch(3)
        self%list(icount)%is_sequence = lswitch(4)
        self%list(icount)%is_logical  = lswitch(5)
        self%list(icount)%is_integer  = lswitch(6)
        self%list(icount)%is_real     = lswitch(7)
        self%list(icount)%is_string   = lswitch(8)
!
        IF (lswitch(1)) ic_alias=ic_alias+1
        IF (lswitch(2)) ic_anchor=ic_anchor+1
!
!  Set left-padding indentation level: 0, 1, 2, ...
!
        left_padding=nblanks/self%indent
        self%list(icount)%left_padding=left_padding
!
!  Load key/value ID and parent ID.
!
        IF (nblanks.gt.0) THEN
          IF (left_padding.gt.self%list(icount-1)%left_padding) THEN
            new_parent=old_parent
            old_parent=icount
          END IF
        END IF
        self%list(icount)%id=icount
        self%list(icount)%parent_id=new_parent
!
!  Allocate and load line, key, and value strings. If applicable, loal
!  anchor value. Notice that it is possible to have keyword without
!  value in the main branches.
!
        IF (yaml_error(yaml_assignstring(self%list(icount)%line,        &
     &                                   line, lenstr),                 &
     &                 noerr, __line__, myfile)) RETURN
!
        IF (yaml_error(yaml_assignstring(self%list(icount)%key,         &
     &                                   key, lenstr),                  &
     &                 noerr, __line__, myfile)) RETURN
!
        IF (len_trim(value).gt.0) THEN
          IF (yaml_error(yaml_assignstring(self%list(icount)%value,     &
     &                                     value, lenstr),              &
     &                   noerr, __line__, myfile)) RETURN
        END IF
!
        IF (lswitch(2).and.len_trim(anchor).gt.0) THEN
          IF (yaml_error(yaml_assignstring(self%list(icount)%anchor,    &
     &                                     anchor, lenstr),             &
     &                   noerr, __line__, myfile)) RETURN
        END IF
!
      END DO yaml_line
!
!  Substitute 'Alias' with 'Anchor' values. Notice that Anchors and
!  Aliases let you identify an item with an 'anchor' in a YAML pair,
!  and then refer to that item with an alias later in the same tile.
!  It is done to avoid repetitions and errors.
!
      IF ((ic_alias.gt.0).and.(ic_anchor.gt.0)) THEN
        CALL self%fill_aliases (ic_alias, ic_anchor)
      END IF
!
!  Close YAML file.
!
      CLOSE (iunit)
!
  10  FORMAT (/,' YAML_TREE_FILL - Error while reading YAML file: ',    &
     &        a,/,18x,'LINE: ',a)
!
      RETURN
      END SUBROUTINE yaml_tree_fill
!
      SUBROUTINE yaml_tree_fill_aliases (self, Nalias, Nanchor)
!
!***********************************************************************
!                                                                      !
!  It replaces the Aliases items with its respective Anchors values in !
!  YAML dictionary.                                                    !
!                                                                      !
!  Arguments:                                                          !
!                                                                      !
!     self       YAML tree dictionary object (CLASS yaml_tree)         !
!     Nalias     Number of Aliases items in YAML file (integer)        !
!     Nanchors   Number of Anchors in YAML file (integer)              !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      class(yaml_tree), intent(inout) :: self
      integer, intent(in) :: Nalias
      integer, intent(in) :: Nanchor
!
!  Local variable declarations.
!
      logical :: Lswitch(Ldim)
!
      integer :: Ialias, LenStr, i, j, ic
!
      character (len=Lkey), dimension(Nanchor) :: AnchorKey, AnchorVal
      character (len=Lmax) :: AliasVal
!
      character (len=*), parameter :: MyFile =                          &
     &   __FILE__//", yaml_tree_fill_aliases"
!
!-----------------------------------------------------------------------
!  Extract Anchors keyword and value.
!-----------------------------------------------------------------------
!
      ic=0
      DO i=1,self%Npairs
        IF (self%list(i)%has_anchor) THEN
          ic=ic+1
          anchorkey(ic)=self%list(i)%anchor
          anchorval(ic)=self%list(i)%value
        END IF
      END DO
!
!-----------------------------------------------------------------------
!  Replace Aliases with associate Anchors values.
!-----------------------------------------------------------------------
!
      DO j=1,self%Npairs
!
!  Get Aliases keyword.
!
        IF (self%list(j)%has_alias) THEN
          aliasval=self%list(j)%value
          ialias=index(aliasval,char(42),back=.false.)    ! alias '*'
          IF (ialias.gt.0) THEN
            aliasval(ialias:ialias)=char(32)              ! blank
            aliasval=trim(adjustl(aliasval))
          END IF
!
!  Replace Aliases with anchor values and update value type.
!
          DO i=1,ic
            IF (trim(aliasval).eq.trim(anchorkey(i))) THEN
              DEALLOCATE (self%list(j)%value)
              IF (yaml_error(yaml_assignstring(self%list(j)%value,      &
     &                                         trim(anchorval(i)),      &
     &                                         lenstr),                 &
     &                       noerr, __line__, myfile)) RETURN
!
              lswitch=.false.
              CALL yaml_valuetype (self%list(j)%value, lswitch)
              self%list(j)%is_logical = lswitch(5)
              self%list(j)%is_integer = lswitch(6)
              self%list(j)%is_real    = lswitch(7)
              self%list(j)%is_string  = lswitch(8)
            END IF
          END DO
        END IF
      END DO
!
      RETURN
      END SUBROUTINE yaml_tree_fill_aliases
!
      FUNCTION yaml_tree_has (self, keystring) RESULT (FoundIt)
!
!***********************************************************************
!                                                                      !
!  It checks if YAML dictionary has requested key string.              !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     self       YAML tree dictionary object (CLASS yaml_tree)         !
!                                                                      !
!     keystring  Requested YAML key-string (string)                    !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     FoundIt    Switch indicating if the key string was found or not  !
!                  in the YAML dictionary.                             !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      class(yaml_tree), intent(inout) :: self
      character (len=*), intent(in   ) :: keystring
!
!  Local variable declarations.
!
      TYPE (yaml_extract), allocatable :: k(:)
!
      logical :: foundit
!
      integer :: lstr, lenstr
      integer :: i, idot, ie, is, j, nkeys
!
      character (len=:), allocatable :: kstring
 
      character (len=*), parameter :: myfile =                          &
     &   __FILE__//", yaml_tree_has"
!
!-----------------------------------------------------------------------
!  Check if requested key-string is available in YAML dictionary
!-----------------------------------------------------------------------
!
      foundit=.false.
!
!  Count number of keys in key-string, separated by period, CHAR(46).
!
      lstr=len_trim(keystring)
      IF (yaml_error(yaml_assignstring(kstring,                         &
     &                                 keystring, lenstr),              &
     &               noerr, __line__, myfile)) RETURN
!
      nkeys=yaml_countkeys(kstring, char(46))
!
!  Check single key.
!
      IF (nkeys.eq.1) THEN
        DO i=1,SIZE(self%list)
          IF (self%list(i)%key.eq.kstring) THEN
            foundit=.true.
            EXIT
          END IF
        END DO
        DEALLOCATE (kstring)
        RETURN
!
!  Otherwise, check for compound key separated by period.
!
      ELSE
        ALLOCATE ( k(nkeys) )
!
!  Extract keys.
!
        is=1
        DO j=1,nkeys
          idot=index(kstring,char(46),back=.false.)
          ie=idot
          IF (idot.eq.0) THEN
            ie=len_trim(kstring)
          ELSE
            ie=ie-1
          END IF
          IF (yaml_error(yaml_assignstring(k(j)%value,                  &
     &                                     kstring(is:ie), lenstr),     &
     &                   noerr, __line__, myfile)) RETURN
          IF (idot.gt.0) kstring(is:ie+1) = repeat(char(32), ie-is+2)
          kstring=trim(adjustl(kstring))
        END DO
!
!  Check for compound key: val1.val2 ...
!  (It fails if any of the compound keys is not found)
!
        is=1
        DO j=1,nkeys
          foundit=.false.
          DO i=is,SIZE(self%list)
            IF (self%list(i)%key.eq.k(j)%value) THEN
              foundit=.true.
              is=i+1
              EXIT
            END IF
          END DO
          IF (.not.foundit) EXIT
        END DO
        DEALLOCATE (k, kstring)
        RETURN
      END IF
!
      END FUNCTION yaml_tree_has
!
      FUNCTION yaml_tree_read_line (self, Nblanks, line, key, value,    &
     &                              anchor, Lswitch)                    &
     &                      result(status)
!
!***********************************************************************
!                                                                      !
!  It reads a single text line from current YAML file. It uses the     !
!  ASCII character set extensively.                                    !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     self       YAML tree dictionary object (CLASS yaml_tree)         !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     Nblanks    YAML leading blanks identation (integer)              !
!                                                                      !
!     line       Current YAML file line (string)                       !
!                                                                      !
!     key        YAML line keyword (string)                            !
!                                                                      !
!     value      YAML line keyword value (string)                      !
!                                                                      !
!     anchor     YAML value ancher keyword (string)                    !
!                                                                      !
!     Lswitch    YAML key/value switches (logical, vector)             !
!                                                                      !
!                  Lswitch(1) = T/F, value has an alias '*' token      !
!                  Lswitch(2) = T/F, value has an anchor '&' token     !
!                  Lswitch(3) = T/F, key/value starts a block '-'      !
!                  Lswitch(4) = T/F, value has sequence '[...]' tokens !
!                  Lswitch(5) = T/F, logical value(s)                  !
!                  Lswitch(6) = T/F, integer value(s)                  !
!                  Lswitch(7) = T/F, floating-point value(s)           !
!                  Lswitch(8) = T/F, string value(s)                   !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      class(yaml_tree), intent(inout) :: self
!
      logical, intent(out) :: lswitch(:)
!
      integer, intent(out) :: nblanks
!
      character (len=*), intent(out) :: line
      character (len=*), intent(out) :: key
      character (len=*), intent(out) :: value
      character (len=*), intent(out) :: anchor
!
!  Local variable declarations.
!
      logical :: lbracket, rbracket
!
      integer :: ialias, ianchor, iblank, icolon, idash, ihash, ispace
      integer :: ibracketl, ibracketr
      integer :: lstr, lstrnext, lstrval, i, j, k
      integer :: status
!
      character (len=Lmax) :: linecopy, next_line
 
      character (len=*), parameter :: myfile =                          &
     &   __FILE__//", yaml_tree_read_line"
!
!-----------------------------------------------------------------------
!  Read a single YAML file line
!-----------------------------------------------------------------------
!
!  Initialize.
!
      status=-1                 ! error condition
!
      DO i=1,len(key)
        key(i:i)=char(32)
      END DO
 
      DO i=1,len(value)
        value(i:i)=char(32)
      END DO
 
      DO i=1,len(anchor)
        anchor(i:i)=char(32)
      END DO
!
      lswitch=.false.
      lbracket=.false.
      rbracket=.false.
!
!  Read in next YAML file line.
!
      READ (iunit,'(a)',err=10,END=20) line
!
!  Replace illegal control characters with a blank space CHAR(32)
!
      lstr=len_trim(line)
 
      DO i=1,len_trim(line)
        j=ichar(line(i:i))
        IF (j.lt.32) THEN
          line(i:i)=char(32)
        END IF
      END DO
      linecopy=trim(adjustl(line))
!
!   Get length of "line". Remove comment after the KEYWORD, if  any.
!   In YAML, a comment starts with a hash (#), CHAR(35).
!
      IF ((lstr.gt.0).and.(linecopy(1:1).ne.char(35))) THEN
        ihash=index(line,char(35),back=.false.)
        IF (ihash.gt.0) THEN
          lstr=ihash-1
          line=trim(line(1:lstr))         ! remove trailing comment
          lstr=len_trim(line)
        END IF
        status=2                          ! viable line
      ELSE
        status=1                          ! blank or commented line,
        RETURN                            ! move to the next line
      END IF
!
!  Find colon sign CHAR(58) and determine the number of leading blank
!  spaces. YAML uses indentations with one or more spaces to describe
!  nested collections (lists, mappings). YAML also uses dash plus space,
!  '- ', as enumerator of block lists.
!
!  It checks if the KEYWORD is a multi-word separated by space.
!
      icolon=index(line,char(58),back=.false.)
      IF (icolon.eq.0) THEN
        status=-1
        yaml_errflag=2
        IF (yaml_master) THEN
          WRITE (yaml_stdout,30) trim(line)
        END IF
        IF (yaml_error(yaml_errflag, noerr, __line__, myfile)) RETURN
      END IF
!
      idash =index(line,char(45),back=.false.)
      IF ((idash.gt.0).and.(idash.lt.icolon)) THEN
        iblank=index(line(1:idash),char(32),back=.true.)
      ELSE
        iblank=index(line(1:icolon),char(32),back=.true.)
        IF (iblank.gt.0) THEN
          k=iblank-1
          IF  ((65.le.ichar(line(1:1))).and.                            &
     &         (ichar(line(1:1)).le.122)) THEN   ! multi-word branch key
            iblank=0
          ELSE IF ((65.le.ichar(line(k:k))).and.                        &
     &             (ichar(line(k:k)).le.122)) THEN ! multi-word pair key
            iblank=index(line(1:k),char(32),back=.true.)
          END IF
        END IF
      END IF
!
!  Set number of YAML line leading blacks.
!
      nblanks=iblank
!
!  Extract key and value pair and return.
!
      IF ((idash.gt.0).and.(idash.lt.icolon)) THEN
        key=trim(adjustl(line(idash+1:icolon-1)))
      ELSE
        key=trim(adjustl(line(1:icolon-1)))
      END IF
      value=trim(adjustl(line(icolon+1:lstr)))
!
!  Check for special YAML tokens in value string and replace with blank.
!
      ialias=index(value,char(42),back=.false.)      ! alias '*'
      IF (ialias.gt.0) THEN
        lswitch(1)=.true.
      END IF
!
      ianchor=index(value,char(38),back=.false.)     ! anchor '&'
      IF (ianchor.gt.0) THEN
        ispace=index(value(ianchor+1:),char(32),back=.false.)
        anchor=value(ianchor+1:ispace)               ! anchor value
        lswitch(2)=.true.
        value(ianchor:ispace)=repeat(char(32),ispace-ianchor+1)
        value=trim(adjustl(value))
      END IF
!
      IF ((idash.gt.0).and.(idash.lt.icolon)) THEN
        lswitch(3)=.true.                            ! block pair '- '
      END IF
!
      ibracketl=index(value,char(91),back=.false.)   ! left  bracket '['
      IF (ibracketl.gt.0) THEN
        lbracket=.true.
        value(ibracketl:ibracketl)=char(32)
        value=trim(adjustl(value))
      END IF
!
      ibracketr=index(value,char(93),back=.false.)   ! right bracket ']'
      IF (ibracketr.gt.0) THEN
        rbracket=.true.
        value(ibracketr:ibracketr)=char(32)
        value=trim(adjustl(value))
      END IF
!
!-----------------------------------------------------------------------
!  If right square bracket is not found, the key values are broken into
!  multiple lines. Process the necessary lines.
!-----------------------------------------------------------------------
!
      IF (.not.rbracket.and.lbracket) THEN
        DO WHILE (.not.rbracket)
          READ (iunit,'(a)',err=10,END=20) next_line
!
!  Replace illegal control characters with a blank space CHAR(32)
!
          DO i=1,len_trim(next_line)
            j=ichar(next_line(i:i))
            IF (j.lt.32) THEN
              next_line(i:i)=char(32)
            END IF
          END DO
          next_line=trim(adjustl(next_line))
!
!  If applicable, remove trailing comments starting with a hash (#),
!  CHAR(35).
!
          ihash=index(next_line,char(35),back=.false.)
          lstrnext=len_trim(next_line)
          IF ((lstrnext.gt.0).and.(ihash.gt.0)) THEN
            lstrnext=ihash-1
            next_line=trim(next_line(1:lstrnext))
            lstrnext=len_trim(next_line)
          END IF
!
!  Aggregate new 'next_line' to previous 'line' and 'value'.
!
          lstr=len_trim(line)
          lstrval=len_trim(value)
          line=line(1:lstr)//char(32)//next_line(1:lstrnext)
          value=value(1:lstrval)//char(32)//next_line(1:lstrnext)
!
          ibracketr=index(value,char(93),back=.false.)
          IF (ibracketr.gt.0) THEN
            rbracket=.true.
            value(ibracketr:ibracketr)=char(32)
            value=trim(adjustl(value))
          END IF
        END DO
      END IF
      IF (lbracket.and.rbracket) lswitch(4)=.true.
!
!-----------------------------------------------------------------------
!  Determine value representation: logical (boolean), numerical
! (integer/reals), or string(s).  Others can be added as needed.
!-----------------------------------------------------------------------
!
      CALL yaml_valuetype (value, lswitch)
!
      RETURN
!
!  Read flow control determines the status flag.
!
  10  status=-1     ! error during reading
  20  status=0      ! end-of-file encoutered
!
  30  FORMAT (/,' YAML_TREE_READ_LINE - Unable to find colon token ',   &
     &        'after key word',/,23x,'LINE: ',a)
 
      END FUNCTION yaml_tree_read_line
!
      FUNCTION yaml_assignstring (OutString, InpString, Lstr)           &
     &                    result(errflag)
!
!=======================================================================
!                                                                      !
!  It assigns allocatable strings. It allocates/reallocates output     !
!  string variable.                                                    !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     InpString    String to be assigned (character)                   !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     OutString    Assigned allocatable string (character)             !
!     Lstr         Length allocated string (integer)                   !
!     ErrFlag      Error flag (integer)                                !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      character (len=:), allocatable, intent(inout) :: outstring
      character (len=*), intent(in) :: inpstring
      integer, intent(out) :: lstr
!
!  Local variable declarations.
!
      integer :: errflag
!
!-----------------------------------------------------------------------
!  Allocate output string to the size of input string.
!-----------------------------------------------------------------------
!
      errflag = -1
!
      lstr=len_trim(inpstring)
      IF (.not.allocated(outstring)) THEN
        allocate ( character(LEN=Lstr) :: outstring, stat=errflag)
      ELSE
        deallocate (outstring)
        allocate ( character(LEN=Lstr) :: outstring, stat=errflag)
      END IF
!
!  Assign requested value.
!
      outstring = inpstring
!
      RETURN
      END FUNCTION yaml_assignstring
!
      FUNCTION yaml_countkeys (string, token) RESULT (nkeys)
!
!=======================================================================
!                                                                      !
!  It counts the number of concatenated key separated by the specified !
!  token during processing extraction from YAML object.  The same task !
!  can be done elegantly as:                                           !
!                                                                      !
!  nkeys=COUNT((/ (string(i:i), i=1,Lstr) /) == token) + 1             !
!                                                                      !
!  But compilier like 'gfortran' cannot handle such abstraction.       !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     string     Aggregated YAML keys (string)                         !
!     token      Key separator (string)                                !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     nkeys      Number of aggregated keys (integer)                   !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      character (len=*), intent(in) :: string
      character (len=*), intent(in) :: token
!
!  Local variable declarations.
!
      integer :: nkeys
      integer :: lstr, i
!
!-----------------------------------------------------------------------
!  Count number of concatenated keys in input string.
!-----------------------------------------------------------------------
!
      nkeys=1
      lstr=len_trim(string)
      DO i=1,lstr
        IF (string(i:i).eq.token) THEN
          nkeys=nkeys+1
        END IF
      END DO
!
      RETURN
      END FUNCTION yaml_countkeys
!
      FUNCTION yaml_error (flag, NoErr, line, routine) RESULT (foundit)
!
!=======================================================================
!                                                                      !
!  It checks YAML execution flag against no-error code and issue a     !
!  message if they are not equal.                                      !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     flag         YAML execution flag (integer)                       !
!     NoErr        No Error code (integer)                             !
!     line         Calling model routine line (integer)                !
!     routine      Calling model routine (string)                      !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     foundit      The value of the result is TRUE/FALSE if the        !
!                    execution flag is in error.                       !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      integer, intent(in) :: flag, noerr, line
 
      character (len=*), intent(in) :: routine
!
!  Local variable declarations.
!
      logical :: foundit
!
!-----------------------------------------------------------------------
!  Scan array for requested string.
!-----------------------------------------------------------------------
!
      foundit=.false.
      IF (flag.ne.noerr) THEN
        foundit=.true.
        IF (yaml_master) THEN
          WRITE (yaml_stdout,10) flag, line, trim(routine)
  10      FORMAT (' Found Error: ', i2.2, t20, 'Line: ', i0,            &
     &            t35, 'Source: ', a)
        END IF
        FLUSH (yaml_stdout)
      END IF
 
      RETURN
      END FUNCTION yaml_error
!
      FUNCTION yaml_get_i_struc (self, keystring, V) RESULT (status)
!
!***********************************************************************
!                                                                      !
!  It loads a vector set of integers in YAML block-list structure,     !
!  V(1:Nitems)%vector(1:Nvalues).  If the dummy argument V structure   !
!  is allocated, it deallocates/allocates the required Nitems and      !
!  Nvalues dimensions.                                                 !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     self       YAML tree dictionary object (CLASS yaml_tree)         !
!     keystring  YAML tree aggregated keys (string)                    !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     V          Vector of integers in block list (TYPE yaml_Ivec)     !
!     status     Error code (integer)                                  !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      class(yaml_tree), intent(in) :: self
      character (len=*), intent(in) :: keystring
      TYPE (yaml_ivec), allocatable, intent(out) :: v(:)
!
!  Local variable declarations.
!
      TYPE (yaml_extract), allocatable :: s(:)
!
      integer :: lenstr, nitems, nvalues, i, n
      integer :: status
!
      character (len=Lmax) :: msg
 
      character (len=*), parameter :: myfile =                          &
     &   __FILE__//", yaml_Get_i_struc"
!
!-----------------------------------------------------------------------
!  Extract requested key-string values.
!-----------------------------------------------------------------------
!
      status=noerr
!
      IF (yaml_error(self%extract(keystring, s),                        &
     &               noerr, __line__, myfile)) RETURN
!
!  Allocate output structure.
!
      nitems=SIZE(s, dim=1)
      IF (ALLOCATED(v)) DEALLOCATE (v)
      ALLOCATE ( v(nitems) )
!
!  Convert string vector values to integers.
!
      DO n=1,nitems
        IF (s(n)%has_vector) THEN
          nvalues=SIZE(s(n)%vector)
          ALLOCATE ( v(n)%vector(nvalues) )
          DO i=1,nvalues
            READ (s(n)%vector(i)%value, * ,iostat=status, iomsg=msg)    &
     &           v(n)%vector(i)
            IF (yaml_error(status, noerr, __line__, myfile)) THEN
              yaml_errflag=5
              IF (yaml_master) WRITE (yaml_stdout,10) trim(keystring),  &
     &                                            s(n)%vector(i)%value, &
     &                                                trim(msg)
              RETURN
            END IF
          END DO
        END IF
      END DO
!
!  Deallocate local extraction structure.
!
      IF (ALLOCATED(s)) DEALLOCATE (s)
!
  10  FORMAT (/,' YAML_GET_I_STRUC - Error while converting string to', &
     &        ' integer, key: ',a,', value = ',a,/,20x,'ErrMsg: ',a)
!
      RETURN
      END FUNCTION yaml_get_i_struc
!
      FUNCTION yaml_get_l_struc (self, keystring, V) RESULT (status)
!
!***********************************************************************
!                                                                      !
!  It loads a vector set of logicals in YAML block-list structure,     !
!  V(1:Nitems)%vector(1:Nvalues).  If the dummy argument V structure   !
!  is allocated, it deallocates/allocates the required Nitems and      !
!  Nvalues dimensions.                                                 !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     self       YAML tree dictionary object (CLASS yaml_tree)         !
!     keystring  YAML tree aggregated keys (string)                    !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     V          Vector of logicals in block list (TYPE yaml_Lvec)     !
!     status     Error code (integer)                                  !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      class(yaml_tree), intent(in) :: self
      character (len=*), intent(in) :: keystring
      TYPE (yaml_lvec), allocatable, intent(out) :: v(:)
!
!  Local variable declarations.
!
      TYPE (yaml_extract), allocatable :: s(:)
!
      integer :: nitems, nvalues, n, i
      integer :: status
!
      character (len=*), parameter :: myfile =                          &
     &   __FILE__//", yaml_Get_l_struc"
!
!-----------------------------------------------------------------------
!  Extract requested key-string values.
!-----------------------------------------------------------------------
!
      status=noerr
!
      IF (yaml_error(self%extract(keystring, s),                        &
     &               noerr, __line__, myfile)) RETURN
!
!  Allocate output structure.
!
      nitems=SIZE(s, dim=1)
      IF (ALLOCATED(v)) DEALLOCATE (v)
      ALLOCATE ( v(nitems) )
!
!  Convert string vector values to logicals.
!
      DO n=1,nitems
        IF (s(n)%has_vector) THEN
          nvalues=SIZE(s(n)%vector)
          ALLOCATE ( v(n)%vector(nvalues) )
          DO i=1,nvalues
            IF (yaml_uppercase(s(n)%vector(i)%value(1:1)).eq.'T') THEN
              v(n)%vector(i)=.true.
            ELSE
              v(n)%vector(i)=.false.
            END IF
          END DO
        END IF
      END DO
!
!  Deallocate local extraction structure.
!
      IF (ALLOCATED(s)) DEALLOCATE (s)
!
      RETURN
      END FUNCTION yaml_get_l_struc
!
      FUNCTION yaml_get_r_struc (self, keystring, V) RESULT (status)
!
!***********************************************************************
!                                                                      !
!  It loads a vector set of real values in YAML block-list structure,  !
!  V(1:Nitems)%vector(1:Nvalues).  If the dummy argument V structure   !
!  is allocated, it deallocates/allocates the required Nitems and      !
!  Nvalues dimensions.                                                 !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     self       YAML tree dictionary object (CLASS yaml_tree)         !
!     keystring  YAML tree aggregated keys (string)                    !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     V          Vector of reals in block list (TYPE yaml_Rvec)        !
!     status     Error code (integer)                                  !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      class(yaml_tree), intent(in) :: self
      character (len=*), intent(in) :: keystring
      TYPE (yaml_rvec), allocatable, intent(out) :: v(:)
!
!  Local variable declarations.
!
      TYPE (yaml_extract), allocatable :: s(:)
!
      integer :: nitems, nvalues, i, n
      integer :: status
!
      character (len=Lmax) :: msg
 
      character (len=*), parameter :: myfile =                          &
     &   __FILE__//", yaml_Get_r_struc"
!
!-----------------------------------------------------------------------
!  Extract requested key-string values.
!-----------------------------------------------------------------------
!
      status=noerr
!
      IF (yaml_error(self%extract(keystring, s),                        &
     &               noerr, __line__, myfile)) RETURN
!
!  Allocate output structure.
!
      nitems=SIZE(s, dim=1)
      IF (ALLOCATED(v)) DEALLOCATE (v)
      ALLOCATE ( v(nitems) )
!
!  Convert string vector values to floating-point.
!
      DO n=1,nitems
        IF (s(n)%has_vector) THEN
          nvalues=SIZE(s(n)%vector)
          ALLOCATE ( v(n)%vector(nvalues) )
          DO i=1,nvalues
            READ (s(n)%vector(i)%value, * ,iostat=status, iomsg=msg)    &
     &           v(n)%vector(i)
            IF (yaml_error(status, noerr, __line__, myfile)) THEN
              yaml_errflag=5
              IF (yaml_master) WRITE (yaml_stdout,10) trim(keystring),  &
     &                                            s(n)%vector(i)%value, &
     &                                                trim(msg)
              RETURN
            END IF
          END DO
        ELSE
          READ (s(n)%value, * ,iostat=status, iomsg=msg)                &
     &         v(n)%vector(i)
          IF (yaml_error(status, noerr, __line__, myfile)) THEN
            yaml_errflag=5
            IF (yaml_master) WRITE (yaml_stdout,10) trim(keystring),    &
     &                                              s(n)%value,         &
     &                                              trim(msg)
            RETURN
          END IF
        END IF
      END DO
!
!  Deallocate local extraction structure.
!
      IF (ALLOCATED(s)) DEALLOCATE (s)
!
  10  FORMAT (/,' YAML_GET_R_STRUC - Error while converting string to', &
     &        ' real, key: ',a,', value = ',a,/,20x,'ErrMsg: ',a)
!
      RETURN
      END FUNCTION yaml_get_r_struc
!
      FUNCTION yaml_get_s_struc (self, keystring, V) RESULT (status)
!
!***********************************************************************
!                                                                      !
!  It loads a vector set of strings in YAML block-list structure,      !
!  V(1:Nitems)%vector(1:Nvalues)%value.  If the dummy argument V       !
!  structure is allocated, it deallocates/allocates the required       !
!  Nitems and Nvalues dimensions.                                      !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     self       YAML tree dictionary object (CLASS yaml_tree)         !
!     keystring  YAML tree aggregated keys (string)                    !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     V          Vector of strings in block list (TYPE yaml_Svec)      !
!     status     Error code (integer)                                  !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      class(yaml_tree), intent(in) :: self
      character (len=*), intent(in) :: keystring
      TYPE (yaml_svec), allocatable, intent(out) :: v(:)
!
!  Local variable declarations.
!
      TYPE (yaml_extract), allocatable :: s(:)
!
      integer :: nitems, nvalues, n, i
      integer :: status
!
      character (len=*), parameter :: myfile =                          &
     &   __FILE__//", yaml_Get_s_struc"
!
!-----------------------------------------------------------------------
!  Extract requested key-string values.
!-----------------------------------------------------------------------
!
      status=noerr
!
      IF (yaml_error(self%extract(keystring, s),                        &
     &               noerr, __line__, myfile)) RETURN
!
!  Allocate output structure.
!
      nitems=SIZE(s, dim=1)
      IF (ALLOCATED(v)) DEALLOCATE (v)
      ALLOCATE ( v(nitems) )
!
!  Load string vector values to output structure.
!
      DO n=1,nitems
        IF (s(n)%has_vector) THEN
          nvalues=SIZE(s(n)%vector)
          ALLOCATE ( v(n)%vector(nvalues) )
          DO i=1,nvalues
            v(n)%vector(i)%value=s(n)%vector(i)%value
          END DO
        ELSE
          v(n)%value=s(n)%value
        END IF
      END DO
!
!  Deallocate local extraction structure.
!
      IF (ALLOCATED(s)) DEALLOCATE (s)
!
      RETURN
      END FUNCTION yaml_get_s_struc
!
      FUNCTION yaml_get_ivar_0d (self, keystring, value) RESULT (status)
!
!***********************************************************************
!                                                                      !
!  It gets scalar integer data from YAML dictionary object.            !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     self       YAML tree dictionary object (CLASS yaml_tree)         !
!     keystring  YAML tree aggregated keys (string)                    !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     value      YAML value (integer; scalar)                          !
!     status     Error code (integer)                                  !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      class(yaml_tree), intent(in) :: self
      character (len=*), intent(in) :: keystring
      integer, intent(out) :: value
!
!  Local variable declarations.
!
      TYPE (yaml_extract), allocatable :: s(:)
!
      integer :: nvalues, status
!
      character (len=Lmax) :: msg
 
      character (len=*), parameter :: myfile =                          &
     &   __FILE__//", yaml_Get_ivar_0d"
!
!-----------------------------------------------------------------------
!  Extract requested key-string value.
!-----------------------------------------------------------------------
!
      status=noerr
!
      IF (yaml_error(self%extract(keystring, s),                        &
     &               noerr, __line__, myfile)) RETURN
!
!  Make sure that extracted value is a scalar.
!
      nvalues=SIZE(s)
!
      IF (nvalues.gt.1) THEN
        status=7
        yaml_errflag=status
        IF (yaml_error(status, noerr, __line__, myfile)) THEN
          IF (yaml_master) WRITE (yaml_stdout,10) keystring, nvalues,   &
     &                                            self%filename
          RETURN
        END IF
!
!  Convert string value to integer.
!
      ELSE
        READ (s(1)%value, *, iostat=status, iomsg=msg) value
        IF (yaml_error(status, noerr, __line__, myfile)) THEN
          yaml_errflag=5
          IF (yaml_master) WRITE (yaml_stdout,20) trim(keystring),      &
     &                                            s(1)%value, trim(msg)
          RETURN
        END IF
      END IF
!
!  Deallocate.
!
      IF (ALLOCATED(s)) DEALLOCATE (s)
!
  10  FORMAT (/,' YAML_GET_IVAR_0D - Extracted value is not a scalar,', &
     &        ' key-string: ',a,/,20x,'Nvalues = ',i0,/,20x,'File: ',a)
  20  FORMAT (/,' YAML_GET_IVAR_0D - Error while converting string to', &
     &        ' integer, key: ',a,', value = ',a,/,20x,'ErrMsg: ',a)
!
      RETURN
      END FUNCTION yaml_get_ivar_0d
!
      FUNCTION yaml_get_ivar_1d (self, keystring, value) RESULT (status)
!
!***********************************************************************
!                                                                      !
!  It gets 1D integer data from YAML dictionary object.                !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     self       YAML tree dictionary object (CLASS yaml_tree)         !
!     keystring  YAML tree aggregated keys (string)                    !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     value      YAML value (integer; 1D-array)                        !
!     status     Error code (integer)                                  !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      class(yaml_tree), intent(in) :: self
      character (len=*), intent(in) :: keystring
      integer, intent(out) :: value(:)
!
!  Local variable declarations.
!
      TYPE (yaml_extract), allocatable :: s(:)
!
      integer :: nvalues, i, status
!
      character (len=Lmax) :: msg
 
      character (len=*), parameter :: myfile =                          &
     &   __FILE__//", yaml_Get_ivar_1d"
!
!-----------------------------------------------------------------------
!  Extract requested key-string values.
!-----------------------------------------------------------------------
!
      status=noerr
!
      IF (yaml_error(self%extract(keystring, s),                        &
     &               noerr, __line__, myfile)) RETURN
!
!  Make sure that extracted value is a scalar.
!
      nvalues=SIZE(s, dim=1)
!
      IF (SIZE(value, dim=1).lt.nvalues) THEN
        status=7
        yaml_errflag=status
        IF (yaml_error(status, noerr, __line__, myfile)) THEN
          IF (yaml_master) WRITE (yaml_stdout,10) keystring, nvalues,   &
     &                                            SIZE(value, dim=1),   &
     &                                            self%filename
          RETURN
        END IF
      END IF
!
!  Convert string values to integers.
!
      DO i=1,nvalues
        READ (s(i)%value, *, iostat=status, iomsg=msg) value(i)
        IF (yaml_error(status, noerr, __line__, myfile)) THEN
          yaml_errflag=5
          IF (yaml_master) WRITE (yaml_stdout,20) trim(keystring),      &
     &                                            s(i)%value, trim(msg)
          RETURN
        END IF
      END DO
!
!  Deallocate.
!
      IF (ALLOCATED(s)) DEALLOCATE (s)
!
  10  FORMAT (/,' YAML_GET_IVAR_1D - Inconsistent number of values,',   &
     &        ' key-string: ',a,/,20x,'YAML size = ',i0,                &
     &        ', Variable size = ',i0,/,20x,'File: ',a)
  20  FORMAT (/,' YAML_GET_IVAR_1D - Error while converting string to', &
     &        ' integer, key: ',a,', value = ',a,/,20x,'ErrMsg: ',a)
!
      RETURN
      END FUNCTION yaml_get_ivar_1d
!
      FUNCTION yaml_get_lvar_0d (self, keystring, value) RESULT (status)
!
!***********************************************************************
!                                                                      !
!  It gets scalar logical data from YAML disctionary object.           !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     self       YAML tree dictionary object (CLASS yaml_tree)         !
!     keystring  YAML tree aggregated keys (string)                    !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     value      YAML value (logical; scalar)                          !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      class(yaml_tree), intent(in) :: self
      character (len=*), intent(in) :: keystring
      logical, intent(out) :: value
!
!  Local variable declarations.
!
      TYPE (yaml_extract), allocatable :: s(:)
!
      integer :: nvalues, status
!
      character (len=*), parameter :: myfile =                          &
     &   __FILE__//", yaml_Get_lvar_0d"
!
!-----------------------------------------------------------------------
!  Extract requested key-string value.
!-----------------------------------------------------------------------
!
      status=noerr
!
      IF (yaml_error(self%extract(keystring, s),                        &
     &               noerr, __line__, myfile)) RETURN
!
!  Make sure that extracted value is a scalar.
!
      nvalues=SIZE(s)
!
      IF (nvalues.gt.1) THEN
        status=7
        yaml_errflag=status
        IF (yaml_error(status, noerr, __line__, myfile)) THEN
          IF (yaml_master) WRITE (yaml_stdout,10) keystring, nvalues,   &
     &                                            self%filename
          RETURN
        END IF
!
!  Convert string value to logical.
!
      ELSE
        IF (yaml_uppercase(s(1)%value(1:1)).eq.'T') THEN
          value=.true.
        ELSE
          value=.false.
        END IF
      END IF
!
!  Deallocate.
!
      IF (ALLOCATED(s)) DEALLOCATE (s)
!
  10  FORMAT (/,' YAML_GET_LVAR_0D - Extracted value is not a scalar,', &
     &        ' key-string: ',a,/,20x,'Nvalues = ',i0,/,20x,'File: ',a)
!
      RETURN
      END FUNCTION yaml_get_lvar_0d
!
      FUNCTION yaml_get_lvar_1d (self, keystring, value) RESULT (status)
!
!***********************************************************************
!                                                                      !
!  It gets 1D logical data from YAML dictionary object.                !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     self       YAML tree dictionary object (CLASS yaml_tree)         !
!     keystring  YAML tree aggregated keys (string)                    !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     value      YAML value (logical; 1D-array)                        !
!     status     Error code (integer)                                  !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      class(yaml_tree), intent(in) :: self
      character (len=*), intent(in) :: keystring
      logical, intent(out) :: value(:)
!
!  Local variable declarations.
!
      TYPE (yaml_extract), allocatable :: s(:)
!
      integer :: nvalues, i, status
!
      character (len=*), parameter :: myfile =                          &
     &   __FILE__//", yaml_Get_lvar_1d"
!
!-----------------------------------------------------------------------
!  Extract requested key-string values.
!-----------------------------------------------------------------------
!
      status=noerr
!
      IF (yaml_error(self%extract(keystring, s),                        &
     &               noerr, __line__, myfile)) RETURN
!
!  Make sure that extracted value is a scalar.
!
      nvalues=SIZE(s, dim=1)
!
      IF (SIZE(value, dim=1).lt.nvalues) THEN
        yaml_errflag=7
        status=yaml_errflag
        IF (yaml_error(yaml_errflag, noerr, __line__, myfile)) THEN
          IF (yaml_master) WRITE (yaml_stdout,10) keystring, nvalues,   &
     &                                            SIZE(value, dim=1),   &
     &                                            self%filename
          RETURN
        END IF
      END IF
!
!  Convert string values to logicals.
!
      DO i=1,nvalues
        IF (yaml_uppercase(s(i)%value(1:1)).eq.'T') THEN
          value(i)=.true.
        ELSE
          value(i)=.false.
        END IF
      END DO
!
!  Deallocate.
!
      IF (ALLOCATED(s)) DEALLOCATE (s)
!
  10  FORMAT (/,' YAML_GET_LVAR_1D - Inconsistent number of values,',   &
     &        ' key-string: ',a,/,20x,'YAML size = ',i0,                &
     &        ', Variable size = ',i0,/,20x,'File: ',a)
!
      RETURN
      END FUNCTION yaml_get_lvar_1d
!
      FUNCTION yaml_get_rvar_0d (self, keystring, value) RESULT (status)
!
!***********************************************************************
!                                                                      !
!  It gets scalar floating-point data from YAML dictionary object.     !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     self       YAML tree dictionary object (CLASS yaml_tree)         !
!     keystring  YAML tree aggregated keys (string)                    !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     value      YAML value (real; scalar)                             !
!     status     Error code (integer)                                  !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      class(yaml_tree), intent(in) :: self
      character (len=*), intent(in) :: keystring
      real (kind_real), intent(out) :: value
!
!  Local variable declarations.
!
      TYPE (yaml_extract), allocatable :: s(:)
!
      integer :: nvalues, ie, status
!
      character (len=Lmax) :: msg
 
      character (len=*), parameter :: myfile =                          &
     &   __FILE__//", yaml_Get_rvar_0d"
!
!-----------------------------------------------------------------------
!  Extract requested key-string value.
!-----------------------------------------------------------------------
!
      status=noerr
!
      IF (yaml_error(self%extract(keystring, s),                        &
     &               noerr, __line__, myfile)) RETURN
!
!  Make sure that extracted value is a scalar.
!
      nvalues=SIZE(s)
!
      IF (nvalues.gt.1) THEN
        yaml_errflag=7
        status=yaml_errflag
        IF (yaml_error(yaml_errflag, noerr, __line__, myfile)) THEN
          IF (yaml_master) WRITE (yaml_stdout,10) keystring, nvalues,   &
     &                                            self%filename
          RETURN
        END IF
!
!  Convert string value to real.
!
      ELSE
        s(1)%value=adjustl(s(1)%value)
        ie=len_trim(s(1)%value)
        READ (s(1)%value(1:ie), *, iostat=status, iomsg=msg) value
        IF (yaml_error(status, noerr, __line__, myfile)) THEN
          yaml_errflag=5
          IF (yaml_master) WRITE (yaml_stdout,20) trim(keystring),      &
     &                                            s(1)%value, trim(msg)
          RETURN
        END IF
      END IF
!
!  Deallocate.
!
      IF (ALLOCATED(s)) DEALLOCATE (s)
!
  10  FORMAT (/,' YAML_GET_RVAR_0D - Extracted value is not a scalar,', &
     &        ' key-string: ',a,/,20x,'Nvalues = ',i0,/,20x,'File: ',a)
  20  FORMAT (/,' YAML_GET_RVAR_0D - Error while converting string to', &
     &        ' integer, key: ',a,', value = ',a,/,20x,'ErrMsg: ',a)
!
      RETURN
      END FUNCTION yaml_get_rvar_0d
!
      FUNCTION yaml_get_rvar_1d (self, keystring, value) RESULT (status)
!
!***********************************************************************
!                                                                      !
!  It gets 1D floating-point data from YAML dictionary object.         !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     self       YAML tree dictionary object (CLASS yaml_tree)         !
!     keystring  YAML tree aggregated keys (string)                    !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     value      YAML value (real; 1D-array)                           !
!     status     Error code (integer)                                  !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      class(yaml_tree), intent(in) :: self
      character (len=*), intent(in) :: keystring
      real (kind_real), intent(out) :: value(:)
!
!  Local variable declarations.
!
      TYPE (yaml_extract), allocatable :: s(:)
!
      integer :: nvalues, i, ie, status
!
      character (len=Lmax) :: msg
 
      character (len=*), parameter :: myfile =                          &
     &   __FILE__//", yaml_Get_rvar_1d"
!
!-----------------------------------------------------------------------
!  Extract requested key-string values.
!-----------------------------------------------------------------------
!
      status=noerr
!
      IF (yaml_error(self%extract(keystring, s),                        &
     &               noerr, __line__, myfile)) RETURN
!
!  Make sure that extracted value is a scalar.
!
      nvalues=SIZE(s, dim=1)
!
      IF (SIZE(value, dim=1).lt.nvalues) THEN
        yaml_errflag=7
        status=yaml_errflag
        IF (yaml_error(yaml_errflag, noerr, __line__, myfile)) THEN
          IF (yaml_master) WRITE (yaml_stdout,10) keystring, nvalues,   &
     &                                            SIZE(value, dim=1),   &
     &                                            self%filename
          RETURN
        END IF
      END IF
!
!  Convert string values to reals.
!
      DO i=1,nvalues
        s(i)%value=adjustl(s(i)%value)
        ie=len_trim(s(i)%value)
        READ (s(i)%value(1:ie), *, iostat=status, iomsg=msg) value(i)
        IF (yaml_error(status, noerr, __line__, myfile)) THEN
          yaml_errflag=5
          IF (yaml_master) WRITE (yaml_stdout,20) trim(keystring),      &
     &                                            s(i)%value, trim(msg)
          RETURN
        END IF
      END DO
!
!  Deallocate.
!
      IF (ALLOCATED(s)) DEALLOCATE (s)
!
  10  FORMAT (/,' YAML_GET_RVAR_1D - Inconsistent number of values,',   &
     &        ' key-string: ',a,/,20x,'YAML size = ',i0,                &
     &        ', Variable size = ',i0,/,20x,'File: ',a)
  20  FORMAT (/,' YAML_GET_RVAR_1D - Error while converting string to', &
     &        ' real, key: ',a,', value = ',a,/,20x,'ErrMsg: ',a)
!
      RETURN
      END FUNCTION yaml_get_rvar_1d
!
      FUNCTION yaml_get_svar_0d (self, keystring, value) RESULT (status)
!
!***********************************************************************
!                                                                      !
!  It gets scalar string data from YAML dictionary object.             !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     self       YAML tree dictionary object (CLASS yaml_tree)         !
!     keystring  YAML tree aggregated keys (string)                    !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     value      YAML value (string; scalar)                           !
!     status     Error code (integer)                                  !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      class(yaml_tree), intent(in ) :: self
      character (len=*), intent(in ) :: keystring
      character (len=*), intent(out) :: value
!
!  Local variable declarations.
!
      TYPE (yaml_extract), allocatable :: s(:)
!
      integer :: nvalues, status
!
      character (len=*), parameter :: myfile =                          &
     &   __FILE__//", yaml_Get_lvar_0d"
!
!-----------------------------------------------------------------------
!  Extract requested key-string value.
!-----------------------------------------------------------------------
!
      status=noerr
!
      IF (yaml_error(self%extract(keystring, s),                        &
     &               noerr, __line__, myfile)) RETURN
!
!  Make sure that extracted value is a scalar.
!
      nvalues=SIZE(s)
!
      IF (nvalues.gt.1) THEN
        yaml_errflag=7
        status=yaml_errflag
        IF (yaml_error(yaml_errflag, noerr, __line__, myfile)) THEN
          IF (yaml_master) WRITE (yaml_stdout,10) keystring, nvalues,   &
     &                                            self%filename
          RETURN
        END IF
!
!  Load string value.
!
      ELSE
        value=s(1)%value
      END IF
!
!  Deallocate.
!
      IF (ALLOCATED(s)) DEALLOCATE (s)
!
  10  FORMAT (/,' YAML_GET_SVAR_0D - Extracted value is not a scalar,', &
     &        ' key-string: ',a,/,20x,'Nvalues = ',i0,/,20x,'File: ',a)
!
      RETURN
      END FUNCTION yaml_get_svar_0d
!
      FUNCTION yaml_get_svar_1d (self, keystring, value) RESULT (status)
!
!***********************************************************************
!                                                                      !
!  It gets 1D string data from YAML dictionary object.                 !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     self       YAML tree dictionary object (CLASS yaml_tree)         !
!     keystring  YAML tree aggregated keys (string)                    !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     value      YAML value (string; 1D-array)                         !
!     status     Error code (integer)                                  !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      class(yaml_tree), intent(in ) :: self
      character (len=*), intent(in ) :: keystring
      character (len=*), intent(out) :: value(:)
!
!  Local variable declarations.
!
      TYPE (yaml_extract), allocatable :: s(:)
!
      integer :: nvalues, i, status
!
      character (len=*), parameter :: myfile =                          &
     &   __FILE__//", yaml_Get_lvar_1d"
!
!-----------------------------------------------------------------------
!  Extract requested key-string values.
!-----------------------------------------------------------------------
!
      status=noerr
!
      IF (yaml_error(self%extract(keystring, s),                        &
     &               noerr, __line__, myfile)) RETURN
!
!  Make sure that extracted value is a scalar.
!
      nvalues=SIZE(s, dim=1)
!
      IF (SIZE(value, dim=1).lt.nvalues) THEN
        yaml_errflag=7
        status=yaml_errflag
        IF (yaml_error(yaml_errflag, noerr, __line__, myfile)) THEN
          IF (yaml_master) WRITE (yaml_stdout,10) keystring, nvalues,   &
     &                                            SIZE(value, dim=1),   &
     &                                            self%filename
          RETURN
        END IF
      END IF
!
!  Load string values.
!
      DO i=1,nvalues
        value(i)=s(i)%value
      END DO
!
!  Deallocate.
!
      IF (ALLOCATED(s)) DEALLOCATE (s)
!
  10  FORMAT (/,' YAML_GET_SVAR_1D - Inconsistent number of values,',   &
     &        ' key-string: ',a,/,20x,'YAML size = ',i0,                &
     &        ', Variable size = ',i0,/,20x,'File: ',a)
!
      RETURN
      END FUNCTION yaml_get_svar_1d
!
      FUNCTION yaml_lowercase (Sinp) RESULT (Sout)
!
!=======================================================================
!                                                                      !
!  It converts all string elements to lowercase.                       !
!                                                                      !
!  Reference:                                                          !
!                                                                      !
!     Cooper Redwine, 1995: "Upgrading to Fortran 90", Springer-       !
!       Verlag, New York, pp 416.                                      !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      character(len=*), intent(in) :: sinp
!
!  Local variable definitions.
!
      integer :: lstr, i, j
 
      character (len=LEN(Sinp)) :: sout
 
      character (len=26), parameter :: l = 'abcdefghijklmnopqrstuvwxyz'
      character (len=26), parameter :: u = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
!
!-----------------------------------------------------------------------
!  Convert input string to lowercase.
!-----------------------------------------------------------------------
!
      lstr=len(sinp)
      sout=sinp
      DO i=1,lstr
        j=index(u, sout(i:i))
        IF (j.ne.0) THEN
          sout(i:i)=l(j:j)
        END IF
      END DO
!
      RETURN
      END FUNCTION yaml_lowercase
!
      FUNCTION yaml_uppercase (Sinp) RESULT (Sout)
!
!=======================================================================
!                                                                      !
!  It converts all string elements to uppercase.                       !
!                                                                      !
!  Reference:                                                          !
!                                                                      !
!     Cooper Redwine, 1995: "Upgrading to Fortran 90", Springer-       !
!       Verlag, New York, pp 416.                                      !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      character (len=*), intent(in) :: sinp
!
!  Local variable definitions.
!
      integer :: lstr, i, j
!
      character (len=LEN(Sinp)) :: sout
!
      character (len=26), parameter :: l = 'abcdefghijklmnopqrstuvwxyz'
      character (len=26), parameter :: u = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
!
!-----------------------------------------------------------------------
!  Convert input string to uppercase.
!-----------------------------------------------------------------------
!
      lstr=len(sinp)
      sout=sinp
      DO i=1,lstr
        j=index(l, sout(i:i))
        IF (j.ne.0) THEN
          sout(i:i)=u(j:j)
        END IF
      END DO
!
      RETURN
      END FUNCTION yaml_uppercase
!
      SUBROUTINE yaml_valuetype (value, Lswitch)
!
!***********************************************************************
!                                                                      !
!  It determines the YAML value type as logical, integer, real, or     !
!  string.                                                             !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     self       YAML pair value (string)                              !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     Lswitch    YAML key/value switches (logical, vector)             !
!                                                                      !
!                  Lswitch(1) = T/F, value has an alias '*' token      !
!                  Lswitch(2) = T/F, value has an anchor '&' token     !
!                  Lswitch(3) = T/F, key/value starts a block '-'      !
!                  Lswitch(4) = T/F, value has sequence '[...]' tokens !
!                  Lswitch(5) = T/F, logical value(s)                  !
!                  Lswitch(6) = T/F, integer value(s)                  !
!                  Lswitch(7) = T/F, floating-point value(s)           !
!                  Lswitch(8) = T/F, string value(s)                   !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      logical, intent(inout) :: lswitch(:)
!
      character (len=*), intent(inout)  :: value
!
!  Local variable declarations.
!
      integer :: lstr, schar
      integer :: colon, dot, exponent, letter, numeric, precision
      integer :: i, multiple
!
!-----------------------------------------------------------------------
!  Set keyword value type.
!-----------------------------------------------------------------------
!
!  Initialize.
!
      colon=0
      dot=0
      exponent=0
      letter=0
      multiple=0
      numeric=0
      precision=0
!
!  Check input value string.
!
      lstr=len_trim(value)
      IF (lstr.gt.0) THEN
        DO i=1,lstr
          schar=ichar(value(i:i))
!
!  Check for numbers, plus, and minus signs. For example, value=-1.0E+37
!  is a floating-point numerical value.
!
          IF (((48.le.schar).and.(schar.le.57)).or.                     &
     &        (schar.eq.43).or.(schar.eq.45)) numeric=numeric+1
!
!  Check for dot/period, CHAR(46). If period is not found in a numerical
!  expression, identify value as an integer.
!
          IF (schar.eq.46) dot=dot+1
!
!  Check for precision character: D=ICHAR(68) and d=ICHAR(100). For
!  example, value=0.0d0 and others in the future.
!
          IF ((schar.eq.69).or.(schar.eq.101)) precision=precision+1
!
!  Check for exponent character: E=CHAR(69) and e=CHAR(101).
!
          IF ((schar.eq.69).or.(schar.eq.101)) exponent=exponent+1
!
!  Check for multiple values separate by comma, CHAR(44), in a sequence
!  of values: [val1, val2, ..., valN].
!
          IF (lswitch(4)) multiple=multiple+1
!
!  Check for colon, CHAR(58). We can have value=2020-01-01T00:00:00Z,
!  which has numbers, hyphen, and letters. It is the colon that makes
!  it a string variable (https://www.myroms.org).
!
          IF (schar.eq.58) colon=colon+1
!
!  English uppercase and lowercase alphabet.
!
          IF (((65.le.schar).and.(schar.le.90)).or.                     &
     &        (schar.eq.97).or.(schar.eq.122)) letter=letter+1
        END DO
!
!  Set integer or floating-point type.
!
        IF ((numeric.gt.0).and.(colon.eq.0)) THEN
          IF ((dot.gt.0).or.(exponent.gt.0).or.(precision.gt.0)) THEN
            lswitch(7)=.true.              ! floating-point
          ELSE
            lswitch(6)=.true.              ! integer
          END IF
        ELSE
          IF ((value.eq.'true').or.(value.eq.'false').or.               &
     &        (value.eq.'TRUE').or.(value.eq.'FALSE')) THEN
            lswitch(5)=.true.              ! logical
          ELSE IF (letter.gt.0) THEN
            lswitch(8)=.true.              ! string
          END IF
        END IF
      END IF
!
      RETURN
      END SUBROUTINE yaml_valuetype
!
! <><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
!
      SUBROUTINE process_yaml (yaml_file)
!
! Imported variable declarations.
!
      character (len=*), intent(in) :: yaml_file
!
! Local variable declarations.
!
      character (len=*), parameter :: myfile =                          &
     &  __FILE__//', process_yaml'
 
      TYPE (yaml_tree)    :: yml                ! YAML tree structure
 
      TYPE (couplingfield), allocatable :: e(:), i(:), s(:)
!
!  Create YAML object and report its content.
!
      IF (yaml_error(yaml_initialize(yml, trim(yaml_file), lreport),    &
     &               noerror, __line__, myfile)) THEN
        WRITE (6,10) trim(yaml_file)
 10     FORMAT (/,' PROCESS_YAML - Unable to create YAML object for:',  &
     &          /,13x,'FileName = ',a)
        RETURN
      END IF
!
!  If CMEPS file, extract export and import states metadata.
!
      IF (yml%has('export').and.yml%has('import')) THEN
        CALL cmeps_metadata (yml, trim(yaml_file), 'export',  e)
        CALL cmeps_metadata (yml, trim(yaml_file), 'import',  i)
        CALL yml%destroy ()
!
!  If ROMS coupling file, extract export nas import state metadata.
!
      ELSE IF (.not.yml%has('svn_repository').and.                      &
     &              yml%has('metadata')) THEN
        CALL coupling_metadata (yml, trim(yaml_file), s)
!
!  IF ROMS 'varingo.yaml', extract input and output variables metadata.
!
      ELSE IF (yml%has('svn_repository').and.                           &
     &         yml%has('metadata')) THEN
        CALL io_metadata (yml, trim(yaml_file))
      END IF
!
      RETURN
!
      END SUBROUTINE process_yaml
!
      SUBROUTINE cmeps_metadata (self, filename, key, S)
!
!=======================================================================
!                                                                      !
!  It process either import or export fields which are stored as block !
!  lists (leading key/value is hyphenated) in the YAML file. The YAML  !
!  file is used to configure ROMS ESMF/NUOPC 'cap' module to be run by !
!  the Community Mediator for Earth Prediction Systems (CMEPS).        !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     self      YAML tree dictionary (TYPE yaml_tree)                  !
!                                                                      !
!     filename  ROMS YAML configuration filename for CMEPS (string)    !
!                                                                      !
!     key       Leading blocking key to process (string), for example: !
!                 'export', 'import', or 'bulk_flux import'            !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     S         Import or Export coupling fields (TYPE CouplingField)  !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      TYPE (yaml_tree),  intent(inout) :: self
      character (len=*), intent(in   ) :: filename
      character (len=*), intent(in   ) :: key
      TYPE (couplingfield), allocatable, intent(out) :: s(:)
!
!  Local variable declarations.
!
      integer :: i, lenstr
!
      character (len=*), parameter :: myfile =                          &
     &  __FILE__//", cmeps_metadata"
!
!-----------------------------------------------------------------------
!  Process coupling import or export metadata for CMEPS.
!-----------------------------------------------------------------------
!
!  If applicable, create YAML tree dictionary.
!
      IF (.not.ASSOCIATED(self%list)) THEN
        IF (yaml_error(yaml_initialize(self, trim(filename),            &
     &                                 .false.),                        &
     &                 noerror, __line__, myfile)) THEN
          IF (yaml_master) WRITE (stdout,10) trim(filename)
          RETURN
        END IF
      END IF
!
!  Extract requested blocking list.
!
      IF (yaml_error(yaml_get(self, trim(key)//'.standard_name',        &
     &                        ystring1),                                &
     &                 noerror, __line__, myfile)) RETURN
      nentries=SIZE(ystring1)
!
      IF (yaml_error(yaml_get(self, trim(key)//'.long_name',            &
     &                        ystring2),                                &
     &               noerror, __line__, myfile)) RETURN
!
      IF (yaml_error(yaml_get(self, trim(key)//'.short_name',           &
     &                        ystring3),                                &
     &                 noerror, __line__, myfile)) RETURN
!
      IF (yaml_error(yaml_get(self, trim(key)//'.data_variables',       &
     &                        ystring4),                                &
     &               noerror, __line__, myfile)) RETURN
!
      IF (yaml_error(yaml_get(self, trim(key)//'.source_units',         &
     &                        ystring5),                                &
     &               noerror, __line__, myfile)) RETURN
!
      IF (yaml_error(yaml_get(self, trim(key)//'.destination_units',    &
     &                        ystring6),                                &
     &               noerror, __line__, myfile)) RETURN
!
      IF (yaml_error(yaml_get(self, trim(key)//'.source_grid',          &
     &                        ystring7),                                &
     &               noerror, __line__, myfile)) RETURN
!
      IF (yaml_error(yaml_get(self, trim(key)//'.destination_grid',     &
     &                        ystring8),                                &
     &               noerror, __line__, myfile)) RETURN
!
      IF (yaml_error(yaml_get(self, trim(key)//'.connected_to',         &
     &                        ystring9),                                &
     &               noerror, __line__, myfile)) RETURN
!
      IF (yaml_error(yaml_get(self, trim(key)//'.map_type',             &
     &                        ystring10),                               &
     &               noerror, __line__, myfile)) RETURN
!
      IF (yaml_error(yaml_get(self, trim(key)//'.map_norm',             &
     &                        ystring11),                               &
     &               noerror, __line__, myfile)) RETURN
!
      IF (.not.allocated(yreal1)) THEN
        allocate ( yreal1(nentries) )
      END IF
      IF (yaml_error(yaml_get(self, trim(key)//'.add_offset',           &
     &                        yreal1),                                  &
     &               noerror, __line__, myfile)) RETURN
!
      IF (.not.allocated(yreal2)) THEN
        allocate ( yreal2(nentries) )
      END IF
      IF (yaml_error(yaml_get(self, trim(key)//'.scale',                &
     &                        yreal2),                                  &
     &               noerror, __line__, myfile)) RETURN
      IF (.not.allocated(yreal1)) THEN
        allocate ( yreal1(nentries) )
      END IF
!
      IF (.not.allocated(ylogical1)) THEN
        allocate ( ylogical1(nentries) )
      END IF
      IF (yaml_error(yaml_get(self, trim(key)//'.debug_write',          &
     &                        ylogical1),                               &
     &               noerror, __line__, myfile)) RETURN
!
!  Load metadata into output structure.
!
      IF (.not.allocated(s)) allocate ( s(nentries) )
!
      DO i=1,nentries
        s(i)%debug_write = ylogical1(i)
        s(i)%add_offset  = yreal1(i)
        s(i)%scale       = yreal2(i)
!
        IF (yaml_error(yaml_assignstring(s(i)%standard_name,            &
     &                                   ystring1(i)%value, lenstr),    &
     &                 noerror, __line__, myfile)) RETURN
!
        IF (yaml_error(yaml_assignstring(s(i)%long_name,                &
     &                                   ystring2(i)%value, lenstr),    &
     &                 noerror, __line__, myfile)) RETURN
!
        IF (yaml_error(yaml_assignstring(s(i)%short_name,               &
     &                                   ystring3(i)%value, lenstr),    &
     &                 noerror, __line__, myfile)) RETURN
!
        IF (yaml_error(yaml_assignstring(s(i)%data_netcdf_vname,        &
     &                                   ystring4(i)%vector(1)%value,   &
     &                                   lenstr),                       &
     &                 noerror, __line__, myfile)) RETURN
!
        IF (yaml_error(yaml_assignstring(s(i)%data_netcdf_tname,        &
     &                                   ystring4(i)%vector(2)%value,   &
     &                                   lenstr),                       &
     &                 noerror, __line__, myfile)) RETURN
!
        IF (yaml_error(yaml_assignstring(s(i)%source_units,             &
     &                                   ystring5(i)%value, lenstr),    &
     &                 noerror, __line__, myfile)) RETURN
!
        IF (yaml_error(yaml_assignstring(s(i)%destination_units,        &
     &                                   ystring6(i)%value, lenstr),    &
     &                 noerror, __line__, myfile)) RETURN
!
        IF (yaml_error(yaml_assignstring(s(i)%source_grid,              &
     &                                   ystring7(i)%value, lenstr),    &
     &                 noerror, __line__, myfile)) RETURN
!
        IF (yaml_error(yaml_assignstring(s(i)%destination_grid,         &
     &                                   ystring8(i)%value, lenstr),    &
     &                 noerror, __line__, myfile)) RETURN
!
        IF (yaml_error(yaml_assignstring(s(i)%connected_to,             &
     &                                   ystring9(i)%value, lenstr),    &
     &                 noerror, __line__, myfile)) RETURN
        IF (yaml_lowercase(s(i)%connected_to).eq.'false') THEN
          s(i)%connected=.false.
        ELSE
          s(i)%connected=.true.
        END IF
!
        IF (yaml_error(yaml_assignstring(s(i)%map_type,                 &
     &                                   ystring10(i)%value, lenstr),   &
     &                 noerror, __line__, myfile)) RETURN
!
        IF (yaml_error(yaml_assignstring(s(i)%map_norm,                 &
     &                                   ystring11(i)%value, lenstr),   &
     &                 noerror, __line__, myfile)) RETURN
      END DO
!
!  Deallocate generic structures.
!
      IF (allocated(ystring1 ))  deallocate (ystring1 )
      IF (allocated(ystring2 ))  deallocate (ystring2 )
      IF (allocated(ystring3 ))  deallocate (ystring3 )
      IF (allocated(ystring4 ))  deallocate (ystring4 )
      IF (allocated(ystring5 ))  deallocate (ystring5 )
      IF (allocated(ystring6 ))  deallocate (ystring6 )
      IF (allocated(ystring7 ))  deallocate (ystring7 )
      IF (allocated(ystring8 ))  deallocate (ystring8 )
      IF (allocated(ystring9 ))  deallocate (ystring9 )
      IF (allocated(ystring10))  deallocate (ystring10)
      IF (allocated(ystring11))  deallocate (ystring11)
      IF (allocated(ylogical1))  deallocate (ylogical1)
      IF (allocated(yreal1))     deallocate (yreal1)
      IF (allocated(yreal2))     deallocate (yreal2)
!
!  Report.
!
      IF (yaml_master.and.ldebugmetadata) THEN
        WRITE (stdout,'(/,3a,/,3a)')                                    &
     &        "Coupling Metadata Dictionary, key: '", trim(key), "',",  &
     &        repeat('=',28), '  File: ', trim(filename)
        DO i=1,SIZE(s)
          WRITE (stdout,'(/,a,a)')      '  - standard_name:        ',   &
     &                                  trim(s(i)%standard_name)
          WRITE (stdout,'(a,a)')        '    long_name:            ',   &
     &                                  trim(s(i)%long_name)
          WRITE (stdout,'(a,a)')        '    short_name:           ',   &
     &                                  trim(s(i)%short_name)
          WRITE (stdout,'(a,a)')        '    data_netcdf_variable: ',   &
     &                                  trim(s(i)%data_netcdf_vname)
          WRITE (stdout,'(a,a)')        '    data_netcdf_time:     ',   &
     &                                  trim(s(i)%data_netcdf_tname)
          WRITE (stdout,'(a,a)')        '    source_units:         ',   &
     &                                  trim(s(i)%source_units)
          WRITE (stdout,'(a,a)')        '    destination_units:    ',   &
     &                                  trim(s(i)%destination_units)
          WRITE (stdout,'(a,a)')        '    source_grid:          ',   &
     &                                  trim(s(i)%source_grid)
          WRITE (stdout,'(a,a)')        '    destination_grid:     ',   &
     &                                  trim(s(i)%destination_grid)
          WRITE (stdout,'(a,1p,e15.8)') '    add_offset:           ',   &
     &                                  s(i)%add_offset
          WRITE (stdout,'(a,1p,e15.8)') '    scale:                ',   &
     &                                  s(i)%scale
          WRITE (stdout,'(a,l1)')       '    debug_write:          ',   &
     &                                  s(i)%debug_write
          WRITE (stdout,'(a,l1)')       '    connected:            ',   &
     &                                  s(i)%connected
          WRITE (stdout,'(a,a)')        '    connected_to:         ',   &
     &                                  trim(s(i)%connected_to)
          WRITE (stdout,'(a,a)')        '    map_type:             ',   &
     &                                  trim(s(i)%map_type)
          WRITE (stdout,'(a,a)')        '    map_norm:             ',   &
     &                                  trim(s(i)%map_norm)
        END DO
        FLUSH (stdout)
      END IF
!
  10  FORMAT (/,' CMEPS_METADATA - Unable to create YAML object for',    &
     &        ' ROMS/CMEPS configuration metadata file: ',/,21x,a,/,     &
     &        21x,'Default file is located in source directory.')
!
      RETURN
      END SUBROUTINE cmeps_metadata
!
      SUBROUTINE coupling_metadata (YML, filename, S)
!
!=======================================================================
!                                                                      !
!  It processes import and export field dictionary for ROMS coupling   !
!  system with the ESMF/NUOPC library. If processes field metadata     !
!  entry-by-entry from 'coupling_*.yaml'.                              !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     YML       YAML tree dictionary (TYPE yaml_tree)                  !
!                                                                      !
!     filename  Coupling metadata filename (string)                    !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     S         Import/Export coupling fields (TYPE CouplingField)     !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      character (len=*), intent(in) :: filename
!
      TYPE (yaml_tree),  intent(inout) :: yml
      TYPE (couplingfield), allocatable, intent(out) :: s(:)
!
!  Local variable declarations.
!
      integer :: i
!
      character (len=*), parameter :: myfile =                          &
     &  __FILE__//", coupling_metadata"
!
!-----------------------------------------------------------------------
!  Process coupling import/export metadata.
!-----------------------------------------------------------------------
!
!  Create YAML dictionary.
!
      ientry=0
!
!  Extract key/value pair (blocking list).
!
      IF (yaml_error(yaml_get(yml, 'metadata.standard_name',            &
     &                        ystring1),                                &
     &               noerror, __line__, myfile)) RETURN
      nentries=SIZE(ystring1)
!
      IF (yaml_error(yaml_get(yml, 'metadata.long_name',                &
     &                        ystring2),                                &
     &               noerror, __line__, myfile)) RETURN
!
      IF (yaml_error(yaml_get(yml, 'metadata.short_name',               &
     &                        ystring3),                                &
     &               noerror, __line__, myfile)) RETURN
!
      IF (yaml_error(yaml_get(yml, 'metadata.data_variables',           &
     &                        ystring4),                                &
     &               noerror, __line__, myfile)) RETURN
!
      IF (yaml_error(yaml_get(yml, 'metadata.source_units',             &
     &                        ystring5),                                &
     &               noerror, __line__, myfile)) RETURN
!
      IF (yaml_error(yaml_get(yml, 'metadata.destination_units',        &
     &                        ystring6),                                &
     &               noerror, __line__, myfile)) RETURN
!
      IF (yaml_error(yaml_get(yml, 'metadata.source_grid',              &
     &                        ystring7),                                &
     &               noerror, __line__, myfile)) RETURN
!
      IF (yaml_error(yaml_get(yml, 'metadata.destination_grid',         &
     &                        ystring8),                                &
     &               noerror, __line__, myfile)) RETURN
!
      IF (yaml_error(yaml_get(yml, 'metadata.connected_to',             &
     &                        ystring9),                                &
     &               noerror, __line__, myfile)) RETURN
!
      IF (yaml_error(yaml_get(yml, 'metadata.regrid_method',            &
     &                        ystring10),                               &
     &               noerror, __line__, myfile)) RETURN
!
      IF (yaml_error(yaml_get(yml, 'metadata.extrapolate_method',       &
     &                        ystring11),                               &
     &               noerror, __line__, myfile)) RETURN
!
      IF (allocated(yreal1)) deallocate (yreal1)
      allocate ( yreal1(nentries) )
      IF (yaml_error(yaml_get(yml, 'metadata.add_offset',               &
     &                        yreal1),                                  &
     &               noerror, __line__, myfile)) RETURN
!
      IF (allocated(yreal2)) deallocate (yreal2)
      allocate ( yreal2(nentries) )
      IF (yaml_error(yaml_get(yml, 'metadata.scale',                    &
     &                        yreal2),                                  &
     &               noerror, __line__, myfile)) RETURN
!
      IF (allocated(ylogical1)) deallocate (ylogical1)
      allocate ( ylogical1(nentries) )
      IF (yaml_error(yaml_get(yml, 'metadata.debug_write',              &
     &                        ylogical1),                               &
     &               noerror, __line__, myfile)) RETURN
!
!-----------------------------------------------------------------------
!  Load metadata information from YAML structures.
!-----------------------------------------------------------------------
!
      IF (.not.allocated(s)) allocate ( s(nentries) )
!
      DO i=1,nentries
        s(i)%debug_write = ylogical1(i)
        s(i)%add_offset  = yreal1(i)
        s(i)%scale       = yreal2(i)
!
        IF (yaml_error(yaml_assignstring(s(i)%standard_name,            &
     &                                   ystring1(i)%value, lenstr),    &
     &                 noerror, __line__, myfile)) RETURN
!
        IF (yaml_error(yaml_assignstring(s(i)%long_name,                &
     &                                   ystring2(i)%value, lenstr),    &
     &                 noerror, __line__, myfile)) RETURN
!
        IF (yaml_error(yaml_assignstring(s(i)%short_name,               &
     &                                   ystring3(i)%value, lenstr),    &
     &                 noerror, __line__, myfile)) RETURN
!
        IF (yaml_error(yaml_assignstring(s(i)%data_netcdf_vname,        &
     &                                   ystring4(i)%vector(1)%value,   &
     &                                   lenstr),                       &
     &                 noerror, __line__, myfile)) RETURN
!
        IF (yaml_error(yaml_assignstring(s(i)%data_netcdf_tname,        &
     &                                   ystring4(i)%vector(2)%value,   &
     &                                   lenstr),
     &                 noerror, __line__, myfile)) RETURN
!
        IF (yaml_error(yaml_assignstring(s(i)%source_units,             &
     &                                   ystring5(i)%value, lenstr),    &
     &                 noerror, __line__, myfile)) RETURN
!
        IF (yaml_error(yaml_assignstring(s(i)%destination_units,        &
     &                                   ystring6(i)%value, lenstr),    &
     &                 noerror, __line__, myfile)) RETURN
!
        IF (yaml_error(yaml_assignstring(s(i)%source_grid,              &
     &                                   ystring7(i)%value, lenstr),    &
     &                 noerror, __line__, myfile)) RETURN
!
        IF (yaml_error(yaml_assignstring(s(i)%destination_grid,         &
     &                                   ystring8(i)%value, lenstr),    &
     &                 noerror, __line__, myfile)) RETURN
!
        IF (yaml_error(yaml_assignstring(s(i)%connected_to,             &
     &                                   ystring9(i)%value, lenstr),    &
     &                 noerror, __line__, myfile)) RETURN
        IF (yaml_lowercase(s(i)%connected_to).eq.'false') THEN
          s(i)%connected=.false.
        ELSE
          s(i)%connected=.true.
        END IF
!
        IF (yaml_error(yaml_assignstring(s(i)%regrid_method,            &
     &                                   ystring10(i)%value, lenstr),   &
     &                 noerror, __line__, myfile)) RETURN
!
        IF (yaml_error(yaml_assignstring(s(i)%extrapolate_method,       &
     &                                   ystring11(i)%value, lenstr),   &
     &                 noerror, __line__, myfile)) RETURN
      END DO
!
!  Deallocate generic structures.
!
      CALL yml%destroy ()
      IF (allocated(ystring1 ))  deallocate (ystring1 )
      IF (allocated(ystring2 ))  deallocate (ystring2 )
      IF (allocated(ystring3 ))  deallocate (ystring3 )
      IF (allocated(ystring4 ))  deallocate (ystring4 )
      IF (allocated(ystring5 ))  deallocate (ystring5 )
      IF (allocated(ystring6 ))  deallocate (ystring6 )
      IF (allocated(ystring7 ))  deallocate (ystring7 )
      IF (allocated(ystring8 ))  deallocate (ystring8 )
      IF (allocated(ystring9 ))  deallocate (ystring9 )
      IF (allocated(ystring10))  deallocate (ystring10)
      IF (allocated(ystring11))  deallocate (ystring11)
      IF (allocated(ylogical1))  deallocate (ylogical1)
      IF (allocated(yreal1))     deallocate (yreal1)
      IF (allocated(yreal2))     deallocate (yreal2)
!
!  Report.
!
      IF (yaml_master.and.ldebugmetadata) THEN
        WRITE (stdout,'(/,2a,/,a)')                                     &
     &        'Coupling Metadata Dictionary, File: ',                   &
     &        trim(filename), repeat('=',28)
        DO i=1,SIZE(s)
          WRITE (stdout,'(/,a,a)')      '  - standard_name:        ',   &
     &                                  trim(s(i)%standard_name)
          WRITE (stdout,'(a,a)')        '    long_name:            ',   &
     &                                  trim(s(i)%long_name)
          WRITE (stdout,'(a,a)')        '    short_name:           ',   &
     &                                  trim(s(i)%short_name)
          WRITE (stdout,'(a,a)')        '    data_netcdf_variable: ',   &
     &                                  trim(s(i)%data_netcdf_vname)
          WRITE (stdout,'(a,a)')        '    data_netcdf_time:     ',   &
     &                                  trim(s(i)%data_netcdf_tname)
          WRITE (stdout,'(a,a)')        '    source_units:         ',   &
     &                                  trim(s(i)%source_units)
          WRITE (stdout,'(a,a)')        '    destination_units:    ',   &
     &                                  trim(s(i)%destination_units)
          WRITE (stdout,'(a,a)')        '    source_grid:          ',   &
     &                                  trim(s(i)%source_grid)
          WRITE (stdout,'(a,a)')        '    destination_grid:     ',   &
     &                                  trim(s(i)%destination_grid)
          WRITE (stdout,'(a,1p,e15.8)') '    add_offset:           ',   &
     &                                  s(i)%add_offset
          WRITE (stdout,'(a,1p,e15.8)') '    scale:                ',   &
     &                                  s(i)%scale
          WRITE (stdout,'(a,l1)')       '    debug_write:          ',   &
     &                                  s(i)%debug_write
          WRITE (stdout,'(a,l1)')       '    connected:            ',   &
     &                                  s(i)%connected
          WRITE (stdout,'(a,a)')        '    connected_to:         ',   &
     &                                  trim(s(i)%connected_to)
          WRITE (stdout,'(a,a)')        '    regrid_method:        ',   &
     &                                  trim(s(i)%regrid_method)
          WRITE (stdout,'(a,a)')        '    extrapolate_method:   ',   &
     &                                  trim(s(i)%extrapolate_method)
        END DO
        FLUSH (stdout)
      END IF
!
      RETURN
!
  10  FORMAT (/,' COUPLING_METADATA - Unable to create YAML object',    &
     &        ' for ROMS I/O metadata file: ',/,21x,a,/,                &
     &        21x,'Default file is located in source directory.')
!
      END SUBROUTINE coupling_metadata
!
      SUBROUTINE io_metadata (YML, filename)
!
!=======================================================================
!                                                                      !
!  It processes ROMS input/output fields metadata entry-by-entry from  !
!  YAML tree dictionary.                                               !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     YML       YAML tree dictionary (TYPE yaml_tree)                  !
!                                                                      !
!     filename  ROMS I/O metadata filename (string)                    !
!                                                                      !
!  It reports internal variables metadata:                             !
!                                                                      !
!     Vinfo      I/O Variable information (string array)               !
!                  Vinfo(1):  Field variable short-name                !
!                  Vinfo(2):  Long-name attribute                      !
!                  Vinfo(3):  Units attribute                          !
!                  Vinfo(4):  Field attribute                          !
!                  Vinfo(5):  Associated time variable name            !
!                  Vinfo(6):  Standard-name attribute                  !
!                  Vinfo(7):  Staggered C-grid variable type:          !
!                               'nulvar' => non-grided variable        !
!                               'p2dvar' => 2D PHI-variable            !
!                               'r2dvar' => 2D RHO-variable            !
!                               'u2dvar' => 2D U-variable              !
!                               'v2dvar' => 2D V-variable              !
!                               'p3dvar' => 3D PSI-variable            !
!                               'r3dvar' => 3D RHO-variable            !
!                               'u3dvar' => 3D U-variable              !
!                               'v3dvar' => 3D V-variable              !
!                               'w3dvar' => 3D W-variable              !
!                               'b3dvar' => 3D BED-sediment            !
!                               'l3dvar' => 3D spectral light variable !
!                               'l4dvar' => 4D spectral light variable !
!                  Vinfo(8):  Index code for information arrays        !
!                                                                      !
!     scale      Scale to convert input data to model units (real)     !
!                                                                      !
!     offeset    Value to add to input data (real)                     !
!                                                                      !
!     Ldone      True if end-of-file or dictionary found               !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      character (len=*), intent(in) :: filename
!
      TYPE (yaml_tree),  intent(inout) :: YML
!
!  Local variable declarations.
!
      integer :: i, j, n
!
      real (dp) :: offset, scale
!
      character (len=160) :: Vinfo(8)
 
      character (len=*), parameter :: MyFile =                          &
     &  __FILE__//", io_metadata"
!
!-----------------------------------------------------------------------
!  On first pass, initialize metadata processing.
!-----------------------------------------------------------------------
!
!  Extract values from YML tree.
!
      IF (yaml_error(yaml_get(yml, 'metadata.variable',                 &
     &                        ystring1),                                &
     &               noerror, __line__, myfile)) RETURN
      nentries=SIZE(ystring1, dim=1)
!
      IF (yaml_error(yaml_get(yml, 'metadata.long_name',                &
     &                        ystring2),                                &
     &               noerror, __line__, myfile)) RETURN
!
      IF (yaml_error(yaml_get(yml, 'metadata.units',                    &
     &                        ystring3),                                &
     &               noerror, __line__, myfile)) RETURN
!
      IF (yaml_error(yaml_get(yml, 'metadata.field',                    &
     &                        ystring4),                                &
     &               noerror, __line__, myfile)) RETURN
!
      IF (yaml_error(yaml_get(yml, 'metadata.time',                     &
     &                        ystring5),                                &
     &               noerror, __line__, myfile)) RETURN
!
      IF (yaml_error(yaml_get(yml, 'metadata.standard_name',            &
     &                        ystring6),                                &
     &               noerror, __line__, myfile)) RETURN
!
      IF (yaml_error(yaml_get(yml, 'metadata.type',                     &
     &                        ystring7),                                &
     &               noerror, __line__, myfile)) RETURN
!
      IF (yaml_error(yaml_get(yml, 'metadata.index_code',               &
     &                        ystring8),                                &
     &               noerror, __line__, myfile)) RETURN
!
      IF (allocated(yreal1)) deallocate (yreal1)
      allocate ( yreal1(nentries) )
      IF (yaml_error(yaml_get(yml, 'metadata.add_offset',               &
     &                        yreal1),                                  &
     &               noerror, __line__, myfile)) RETURN
!
      IF (allocated(yreal2)) deallocate (yreal2)
      allocate ( yreal2(nentries) )
      IF (yaml_error(yaml_get(yml, 'metadata.scale',                    &
     &                        yreal2),                                  &
     &               noerror, __line__, myfile)) RETURN
!
!-----------------------------------------------------------------------
!  Process metadata entries.
!-----------------------------------------------------------------------
!
!  Extract metadata information from YAML structures.
!
      IF (yaml_master.and.ldebugmetadata) THEN
        WRITE (stdout,'(/,2a,/,a)')                                     &
     &        'ROMS I/O Metadata Dictionary, File: ',                   &
     &        trim(filename), repeat('=',28)
!
        DO n=1,nentries
          DO j=1,SIZE(vinfo)
            DO i=1,len(vinfo(1))
              vinfo(j)(i:i)=char(32)
            END DO
          END DO
!
          vinfo(1)=ystring1(n)%value         ! 'variable'      key
          vinfo(2)=ystring2(n)%value         ! 'long_name'     key
          vinfo(3)=ystring3(n)%value         ! 'units'         key
          vinfo(4)=ystring4(n)%value         ! 'field'         key
          vinfo(5)=ystring5(n)%value         ! 'time'          key
          vinfo(6)=ystring6(n)%value         ! 'standard_name' key
          vinfo(7)=ystring7(n)%value         ! 'type'          key
          vinfo(8)=ystring8(n)%value         ! 'index_code'    key
          offset  =yreal1(n)                 ! 'add_offset'    key
          scale   =yreal2(n)                 ! 'scale'         key
!
          WRITE (stdout,'(/,a,a)')      '  - variable:       ',         &
     &                                  trim(vinfo(1))
          WRITE (stdout,'(a,a)')        '    standard_name:  ',         &
     &                                  trim(vinfo(6))
          WRITE (stdout,'(a,a)')        '    long_name:      ',         &
     &                                  trim(vinfo(2))
          WRITE (stdout,'(a,a)')        '    units:          ',         &
     &                                  trim(vinfo(3))
          WRITE (stdout,'(a,a)')        '    field:          ',         &
     &                                  trim(vinfo(4))
          WRITE (stdout,'(a,a)')        '    time:           ',         &
     &                                  trim(vinfo(5))
          WRITE (stdout,'(a,a)')        '    index_code:     ',         &
     &                                  trim(vinfo(8))
          WRITE (stdout,'(a,a)')        '    type:           ',         &
     &                                  trim(vinfo(7))
          WRITE (stdout,'(a,1p,e15.8)') '    add_offset:     ',         &
     &                                  offset
          WRITE (stdout,'(a,1p,e15.8)') '    scale:          ',         &
     &                                  scale
        END DO
        FLUSH (stdout)
      END IF
!
!  Destroy and deallocate.
!
      CALL yml%destroy ()
      IF (allocated(ystring1))  deallocate (ystring1)
      IF (allocated(ystring2))  deallocate (ystring2)
      IF (allocated(ystring3))  deallocate (ystring3)
      IF (allocated(ystring4))  deallocate (ystring4)
      IF (allocated(ystring5))  deallocate (ystring5)
      IF (allocated(ystring6))  deallocate (ystring6)
      IF (allocated(ystring7))  deallocate (ystring7)
      IF (allocated(ystring8))  deallocate (ystring8)
      IF (allocated(yreal1))    deallocate (yreal1)
      IF (allocated(yreal2))    deallocate (yreal2)
!
      RETURN
      END SUBROUTINE io_metadata
!
!-----------------------------------------------------------------------
      END MODULE yaml_parser
!-----------------------------------------------------------------------
!
      PROGRAM yaml_parser_test
!
!=======================================================================
!                                                                      !
! This program can be used to test the YAML parser available in ROMS.  !
!                                                                      !
!=======================================================================
!
      USE yaml_parser, ONLY : process_yaml
!
! Local variable definitions.
!
      character (len=120) :: yaml_file          ! YAML filename
 
      character (len=*), parameter :: myfile =                          &
     &  __FILE__//', read_yaml'
!
! Get YAML file name.
!
      DO WHILE (.true.)
        WRITE (6,10)
 10     FORMAT (/,' Enter YAML filename: ',$)
        READ(5,'(a)',err=20) yaml_file
!
! Create and process YAML object.
!
        CALL process_yaml (trim(yaml_file))
      END DO
 
 20   stop
 
      END PROGRAM yaml_parser_test