yaml_parser.F

Go to the documentation of this file.

      MODULE yaml_parser_mod
!
!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.      !
!                                                                      !
!=======================================================================
!
!  ROMS kernel association.
!
      USE mod_kinds,    ONLY : kind_real    => dp     ! double-precision
      USE mod_parallel, ONLY : yaml_master  => master ! master PET
      USE mod_scalars,  ONLY : yaml_errflag => exit_flag  ! error flag
      USE mod_iounits,  ONLY : yaml_stdout  => stdout ! standard ouput
!
      implicit none
!
!-----------------------------------------------------------------------
!  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
!
      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=yaml_countkeys(vstring, char(44))
!
            IF (.not.ALLOCATED(s)) THEN
              ALLOCATE ( s(npairs) )                   ! main structure
            END IF
            IF (i.eq.1) THEN
              s(1:npairs)%has_vector=.true.
            END IF
            ALLOCATE ( s(i)%vector(nvalues) )          ! sub-structure
!
            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
            IF (i.eq.1) THEN
              s(1:npairs)%has_vector=.false.
            END IF
!
            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=yaml_countkeys(vstring, char(44))
!
            IF (.not.ALLOCATED(s)) THEN
              ALLOCATE ( s(nvalues) )
            END IF
            IF (i.eq.1) THEN
              s(1:nvalues)%has_vector=.false.
            END IF
!
            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
!
            IF (.not.ALLOCATED(s)) THEN
              allocate ( s(1) )
            END IF
            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 compiliers 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
 
!-----------------------------------------------------------------------
 
      END MODULE yaml_parser_mod