! This file is AUTOGENERATED!!!!
! Do not edit this file; edit m_wxml_overloads.m4 and regenerate.
!
!
module m_wxml_overloads

#ifndef DUMMYLIB
  use fox_m_fsys_format, only: str
#endif
  use fox_m_fsys_realtypes, only: sp, dp
  use m_wxml_core, only: xmlf_t
  use m_wxml_core, only: xml_AddCharacters
  use m_wxml_core, only: xml_AddAttribute
  use m_wxml_core, only: xml_AddPseudoAttribute

  implicit none
  private

  interface xml_AddCharacters
    module procedure CharactersScalarCmplxDp
    module procedure CharactersScalarCmplxSp
    module procedure CharactersScalarRealDp
    module procedure CharactersScalarRealSp
    module procedure CharactersScalarInt
    module procedure CharactersScalarLg
    
    module procedure CharactersArrayCmplxDp
    module procedure CharactersArrayCmplxSp
    module procedure CharactersArrayRealDp
    module procedure CharactersArrayRealSp
    module procedure CharactersArrayInt
    module procedure CharactersArrayLg
    module procedure CharactersArrayCh
    module procedure CharactersMatrixCmplxDp
    module procedure CharactersMatrixCmplxSp
    module procedure CharactersMatrixRealDp
    module procedure CharactersMatrixRealSp
    module procedure CharactersMatrixInt
    module procedure CharactersMatrixLg
    module procedure CharactersMatrixCh
 end interface

  interface xml_AddAttribute
    module procedure AttributeScalarCmplxDp
    module procedure AttributeScalarCmplxSp
    module procedure AttributeScalarRealDp
    module procedure AttributeScalarRealSp
    module procedure AttributeScalarInt
    module procedure AttributeScalarLg
    
    module procedure AttributeArrayCmplxDp
    module procedure AttributeArrayCmplxSp
    module procedure AttributeArrayRealDp
    module procedure AttributeArrayRealSp
    module procedure AttributeArrayInt
    module procedure AttributeArrayLg
    module procedure AttributeArrayCh
    module procedure AttributeMatrixCmplxDp
    module procedure AttributeMatrixCmplxSp
    module procedure AttributeMatrixRealDp
    module procedure AttributeMatrixRealSp
    module procedure AttributeMatrixInt
    module procedure AttributeMatrixLg
    module procedure AttributeMatrixCh
 end interface

  interface xml_AddPseudoAttribute
    module procedure PseudoAttributeScalarCmplxDp
    module procedure PseudoAttributeScalarCmplxSp
    module procedure PseudoAttributeScalarRealDp
    module procedure PseudoAttributeScalarRealSp
    module procedure PseudoAttributeScalarInt
    module procedure PseudoAttributeScalarLg
    
    module procedure PseudoAttributeArrayCmplxDp
    module procedure PseudoAttributeArrayCmplxSp
    module procedure PseudoAttributeArrayRealDp
    module procedure PseudoAttributeArrayRealSp
    module procedure PseudoAttributeArrayInt
    module procedure PseudoAttributeArrayLg
    module procedure PseudoAttributeArrayCh
    module procedure PseudoAttributeMatrixCmplxDp
    module procedure PseudoAttributeMatrixCmplxSp
    module procedure PseudoAttributeMatrixRealDp
    module procedure PseudoAttributeMatrixRealSp
    module procedure PseudoAttributeMatrixInt
    module procedure PseudoAttributeMatrixLg
    module procedure PseudoAttributeMatrixCh
 end interface

  public :: xml_AddCharacters
  public :: xml_AddAttribute
  public :: xml_AddPseudoAttribute

contains

  subroutine CharactersScalarCmplxDp &
    (xf, chars, fmt)

    type(xmlf_t), intent(inout) :: xf
    complex(dp), intent(in)   :: chars
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddCharacters(xf=xf, chars=str(chars, fmt))
    else
      call xml_AddCharacters(xf=xf, chars=str(chars))
    endif
#endif
  end subroutine CharactersScalarCmplxDp


  subroutine CharactersScalarCmplxSp &
    (xf, chars, fmt)

    type(xmlf_t), intent(inout) :: xf
    complex(sp), intent(in)   :: chars
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddCharacters(xf=xf, chars=str(chars, fmt))
    else
      call xml_AddCharacters(xf=xf, chars=str(chars))
    endif
#endif
  end subroutine CharactersScalarCmplxSp


  subroutine CharactersScalarRealDp &
    (xf, chars, fmt)

    type(xmlf_t), intent(inout) :: xf
    real(dp), intent(in)   :: chars
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddCharacters(xf=xf, chars=str(chars, fmt))
    else
      call xml_AddCharacters(xf=xf, chars=str(chars))
    endif
#endif
  end subroutine CharactersScalarRealDp


  subroutine CharactersScalarRealSp &
    (xf, chars, fmt)

    type(xmlf_t), intent(inout) :: xf
    real(sp), intent(in)   :: chars
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddCharacters(xf=xf, chars=str(chars, fmt))
    else
      call xml_AddCharacters(xf=xf, chars=str(chars))
    endif
#endif
  end subroutine CharactersScalarRealSp


  subroutine CharactersScalarInt &
    (xf, chars)

    type(xmlf_t), intent(inout) :: xf
    integer, intent(in)   :: chars

#ifndef DUMMYLIB
    call xml_AddCharacters(xf=xf, chars=str(chars))
#endif
  end subroutine CharactersScalarInt


  subroutine CharactersScalarLg &
    (xf, chars)

    type(xmlf_t), intent(inout) :: xf
    logical, intent(in)   :: chars

#ifndef DUMMYLIB
    call xml_AddCharacters(xf=xf, chars=str(chars))
#endif
  end subroutine CharactersScalarLg




  subroutine CharactersArrayCmplxDp &
    (xf, chars, fmt)

    type(xmlf_t), intent(inout) :: xf
    complex(dp), intent(in) , dimension(:)  :: chars
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddCharacters(xf=xf, chars=str(chars, fmt), ws_significant=.false.)
    else
      call xml_AddCharacters(xf=xf, chars=str(chars), ws_significant=.false.)
    endif
#endif
  end subroutine CharactersArrayCmplxDp


  subroutine CharactersArrayCmplxSp &
    (xf, chars, fmt)

    type(xmlf_t), intent(inout) :: xf
    complex(sp), intent(in) , dimension(:)  :: chars
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddCharacters(xf=xf, chars=str(chars, fmt), ws_significant=.false.)
    else
      call xml_AddCharacters(xf=xf, chars=str(chars), ws_significant=.false.)
    endif
#endif
  end subroutine CharactersArrayCmplxSp


  subroutine CharactersArrayRealDp &
    (xf, chars, fmt)

    type(xmlf_t), intent(inout) :: xf
    real(dp), intent(in) , dimension(:)  :: chars
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddCharacters(xf=xf, chars=str(chars, fmt), ws_significant=.false.)
    else
      call xml_AddCharacters(xf=xf, chars=str(chars), ws_significant=.false.)
    endif
#endif
  end subroutine CharactersArrayRealDp


  subroutine CharactersArrayRealSp &
    (xf, chars, fmt)

    type(xmlf_t), intent(inout) :: xf
    real(sp), intent(in) , dimension(:)  :: chars
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddCharacters(xf=xf, chars=str(chars, fmt), ws_significant=.false.)
    else
      call xml_AddCharacters(xf=xf, chars=str(chars), ws_significant=.false.)
    endif
#endif
  end subroutine CharactersArrayRealSp


  subroutine CharactersArrayInt &
    (xf, chars)

    type(xmlf_t), intent(inout) :: xf
    integer, intent(in) , dimension(:)  :: chars

#ifndef DUMMYLIB
    call xml_AddCharacters(xf=xf, chars=str(chars), ws_significant=.false.)
#endif
  end subroutine CharactersArrayInt


  subroutine CharactersArrayLg &
    (xf, chars)

    type(xmlf_t), intent(inout) :: xf
    logical, intent(in) , dimension(:)  :: chars

#ifndef DUMMYLIB
    call xml_AddCharacters(xf=xf, chars=str(chars), ws_significant=.false.)
#endif
  end subroutine CharactersArrayLg


  subroutine CharactersArrayCh &
    (xf, chars, delimiter)

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) , dimension(:)  :: chars
    character(len=1), intent(in), optional :: delimiter

#ifndef DUMMYLIB
    call xml_AddCharacters(xf=xf, chars=str(chars, delimiter), ws_significant=.false.)
#endif
  end subroutine CharactersArrayCh


  subroutine CharactersMatrixCmplxDp &
    (xf, chars, fmt)

    type(xmlf_t), intent(inout) :: xf
    complex(dp), intent(in) , dimension(:,:)  :: chars
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddCharacters(xf=xf, chars=str(chars, fmt), ws_significant=.false.)
    else
      call xml_AddCharacters(xf=xf, chars=str(chars), ws_significant=.false.)
    endif
#endif
  end subroutine CharactersMatrixCmplxDp


  subroutine CharactersMatrixCmplxSp &
    (xf, chars, fmt)

    type(xmlf_t), intent(inout) :: xf
    complex(sp), intent(in) , dimension(:,:)  :: chars
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddCharacters(xf=xf, chars=str(chars, fmt), ws_significant=.false.)
    else
      call xml_AddCharacters(xf=xf, chars=str(chars), ws_significant=.false.)
    endif
#endif
  end subroutine CharactersMatrixCmplxSp


  subroutine CharactersMatrixRealDp &
    (xf, chars, fmt)

    type(xmlf_t), intent(inout) :: xf
    real(dp), intent(in) , dimension(:,:)  :: chars
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddCharacters(xf=xf, chars=str(chars, fmt), ws_significant=.false.)
    else
      call xml_AddCharacters(xf=xf, chars=str(chars), ws_significant=.false.)
    endif
#endif
  end subroutine CharactersMatrixRealDp


  subroutine CharactersMatrixRealSp &
    (xf, chars, fmt)

    type(xmlf_t), intent(inout) :: xf
    real(sp), intent(in) , dimension(:,:)  :: chars
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddCharacters(xf=xf, chars=str(chars, fmt), ws_significant=.false.)
    else
      call xml_AddCharacters(xf=xf, chars=str(chars), ws_significant=.false.)
    endif
#endif
  end subroutine CharactersMatrixRealSp


  subroutine CharactersMatrixInt &
    (xf, chars)

    type(xmlf_t), intent(inout) :: xf
    integer, intent(in) , dimension(:,:)  :: chars

#ifndef DUMMYLIB
    call xml_AddCharacters(xf=xf, chars=str(chars), ws_significant=.false.)
#endif
  end subroutine CharactersMatrixInt


  subroutine CharactersMatrixLg &
    (xf, chars)

    type(xmlf_t), intent(inout) :: xf
    logical, intent(in) , dimension(:,:)  :: chars

#ifndef DUMMYLIB
    call xml_AddCharacters(xf=xf, chars=str(chars), ws_significant=.false.)
#endif
  end subroutine CharactersMatrixLg


  subroutine CharactersMatrixCh &
    (xf, chars, delimiter)

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) , dimension(:,:)  :: chars
    character(len=1), intent(in), optional :: delimiter

#ifndef DUMMYLIB
    call xml_AddCharacters(xf=xf, chars=str(chars, delimiter), ws_significant=.false.)
#endif
  end subroutine CharactersMatrixCh



  subroutine AttributeScalarCmplxDp &
    (xf, name, value, fmt) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    complex(dp), intent(in)   :: value
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddAttribute(xf=xf, name=name, value=str(value, fmt))
    else
      call xml_AddAttribute(xf=xf, name=name, value=str(value))
    endif
#endif
  end subroutine AttributeScalarCmplxDp

  subroutine AttributeScalarCmplxSp &
    (xf, name, value, fmt) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    complex(sp), intent(in)   :: value
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddAttribute(xf=xf, name=name, value=str(value, fmt))
    else
      call xml_AddAttribute(xf=xf, name=name, value=str(value))
    endif
#endif
  end subroutine AttributeScalarCmplxSp

  subroutine AttributeScalarRealDp &
    (xf, name, value, fmt) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    real(dp), intent(in)   :: value
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddAttribute(xf=xf, name=name, value=str(value, fmt))
    else
      call xml_AddAttribute(xf=xf, name=name, value=str(value))
    endif
#endif
  end subroutine AttributeScalarRealDp

  subroutine AttributeScalarRealSp &
    (xf, name, value, fmt) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    real(sp), intent(in)   :: value
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddAttribute(xf=xf, name=name, value=str(value, fmt))
    else
      call xml_AddAttribute(xf=xf, name=name, value=str(value))
    endif
#endif
  end subroutine AttributeScalarRealSp

  subroutine AttributeScalarInt &
    (xf, name, value) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    integer, intent(in)   :: value

#ifndef DUMMYLIB
    call xml_AddAttribute(xf=xf, name=name, value=str(value))
#endif
  end subroutine AttributeScalarInt

  subroutine AttributeScalarLg &
    (xf, name, value) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    logical, intent(in)   :: value

#ifndef DUMMYLIB
    call xml_AddAttribute(xf=xf, name=name, value=str(value))
#endif
  end subroutine AttributeScalarLg


  subroutine AttributeArrayCmplxDp &
    (xf, name, value, fmt) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    complex(dp), intent(in) , dimension(:)  :: value
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddAttribute(xf=xf, name=name, value=str(value, fmt), ws_significant=.false.)
    else
      call xml_AddAttribute(xf=xf, name=name, value=str(value), ws_significant=.false.)
    endif
#endif
  end subroutine AttributeArrayCmplxDp

  subroutine AttributeArrayCmplxSp &
    (xf, name, value, fmt) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    complex(sp), intent(in) , dimension(:)  :: value
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddAttribute(xf=xf, name=name, value=str(value, fmt), ws_significant=.false.)
    else
      call xml_AddAttribute(xf=xf, name=name, value=str(value), ws_significant=.false.)
    endif
#endif
  end subroutine AttributeArrayCmplxSp

  subroutine AttributeArrayRealDp &
    (xf, name, value, fmt) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    real(dp), intent(in) , dimension(:)  :: value
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddAttribute(xf=xf, name=name, value=str(value, fmt), ws_significant=.false.)
    else
      call xml_AddAttribute(xf=xf, name=name, value=str(value), ws_significant=.false.)
    endif
#endif
  end subroutine AttributeArrayRealDp

  subroutine AttributeArrayRealSp &
    (xf, name, value, fmt) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    real(sp), intent(in) , dimension(:)  :: value
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddAttribute(xf=xf, name=name, value=str(value, fmt), ws_significant=.false.)
    else
      call xml_AddAttribute(xf=xf, name=name, value=str(value), ws_significant=.false.)
    endif
#endif
  end subroutine AttributeArrayRealSp

  subroutine AttributeArrayInt &
    (xf, name, value) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    integer, intent(in) , dimension(:)  :: value

#ifndef DUMMYLIB
    call xml_AddAttribute(xf=xf, name=name, value=str(value), ws_significant=.false.)
#endif
  end subroutine AttributeArrayInt

  subroutine AttributeArrayLg &
    (xf, name, value) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    logical, intent(in) , dimension(:)  :: value

#ifndef DUMMYLIB
    call xml_AddAttribute(xf=xf, name=name, value=str(value), ws_significant=.false.)
#endif
  end subroutine AttributeArrayLg

  subroutine AttributeArrayCh &
    (xf, name, value, delimiter) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    character(len=*), intent(in) , dimension(:)  :: value
    character(len=1), intent(in), optional :: delimiter

#ifndef DUMMYLIB
    call xml_AddAttribute(xf=xf, name=name, value=str(value, delimiter), ws_significant=.false.)
#endif
  end subroutine AttributeArrayCh

  subroutine AttributeMatrixCmplxDp &
    (xf, name, value, fmt) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    complex(dp), intent(in) , dimension(:,:)  :: value
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddAttribute(xf=xf, name=name, value=str(value, fmt), ws_significant=.false.)
    else
      call xml_AddAttribute(xf=xf, name=name, value=str(value), ws_significant=.false.)
    endif
#endif
  end subroutine AttributeMatrixCmplxDp

  subroutine AttributeMatrixCmplxSp &
    (xf, name, value, fmt) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    complex(sp), intent(in) , dimension(:,:)  :: value
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddAttribute(xf=xf, name=name, value=str(value, fmt), ws_significant=.false.)
    else
      call xml_AddAttribute(xf=xf, name=name, value=str(value), ws_significant=.false.)
    endif
#endif
  end subroutine AttributeMatrixCmplxSp

  subroutine AttributeMatrixRealDp &
    (xf, name, value, fmt) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    real(dp), intent(in) , dimension(:,:)  :: value
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddAttribute(xf=xf, name=name, value=str(value, fmt), ws_significant=.false.)
    else
      call xml_AddAttribute(xf=xf, name=name, value=str(value), ws_significant=.false.)
    endif
#endif
  end subroutine AttributeMatrixRealDp

  subroutine AttributeMatrixRealSp &
    (xf, name, value, fmt) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    real(sp), intent(in) , dimension(:,:)  :: value
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddAttribute(xf=xf, name=name, value=str(value, fmt), ws_significant=.false.)
    else
      call xml_AddAttribute(xf=xf, name=name, value=str(value), ws_significant=.false.)
    endif
#endif
  end subroutine AttributeMatrixRealSp

  subroutine AttributeMatrixInt &
    (xf, name, value) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    integer, intent(in) , dimension(:,:)  :: value

#ifndef DUMMYLIB
    call xml_AddAttribute(xf=xf, name=name, value=str(value), ws_significant=.false.)
#endif
  end subroutine AttributeMatrixInt

  subroutine AttributeMatrixLg &
    (xf, name, value) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    logical, intent(in) , dimension(:,:)  :: value

#ifndef DUMMYLIB
    call xml_AddAttribute(xf=xf, name=name, value=str(value), ws_significant=.false.)
#endif
  end subroutine AttributeMatrixLg

  subroutine AttributeMatrixCh &
    (xf, name, value, delimiter) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    character(len=*), intent(in) , dimension(:,:)  :: value
    character(len=1), intent(in), optional :: delimiter

#ifndef DUMMYLIB
    call xml_AddAttribute(xf=xf, name=name, value=str(value, delimiter), ws_significant=.false.)
#endif
  end subroutine AttributeMatrixCh


  subroutine PseudoAttributeScalarCmplxDp &
    (xf, name, value, fmt) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    complex(dp), intent(in)   :: value
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value, fmt))
    else
      call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value))
    endif
#endif
  end subroutine PseudoAttributeScalarCmplxDp

  subroutine PseudoAttributeScalarCmplxSp &
    (xf, name, value, fmt) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    complex(sp), intent(in)   :: value
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value, fmt))
    else
      call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value))
    endif
#endif
  end subroutine PseudoAttributeScalarCmplxSp

  subroutine PseudoAttributeScalarRealDp &
    (xf, name, value, fmt) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    real(dp), intent(in)   :: value
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value, fmt))
    else
      call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value))
    endif
#endif
  end subroutine PseudoAttributeScalarRealDp

  subroutine PseudoAttributeScalarRealSp &
    (xf, name, value, fmt) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    real(sp), intent(in)   :: value
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value, fmt))
    else
      call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value))
    endif
#endif
  end subroutine PseudoAttributeScalarRealSp

  subroutine PseudoAttributeScalarInt &
    (xf, name, value) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    integer, intent(in)   :: value

#ifndef DUMMYLIB
    call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value))
#endif
  end subroutine PseudoAttributeScalarInt

  subroutine PseudoAttributeScalarLg &
    (xf, name, value) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    logical, intent(in)   :: value

#ifndef DUMMYLIB
    call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value))
#endif
  end subroutine PseudoAttributeScalarLg


  subroutine PseudoAttributeArrayCmplxDp &
    (xf, name, value, fmt) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    complex(dp), intent(in) , dimension(:)  :: value
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value, fmt), ws_significant=.false.)
    else
      call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value), ws_significant=.false.)
    endif
#endif
  end subroutine PseudoAttributeArrayCmplxDp

  subroutine PseudoAttributeArrayCmplxSp &
    (xf, name, value, fmt) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    complex(sp), intent(in) , dimension(:)  :: value
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value, fmt), ws_significant=.false.)
    else
      call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value), ws_significant=.false.)
    endif
#endif
  end subroutine PseudoAttributeArrayCmplxSp

  subroutine PseudoAttributeArrayRealDp &
    (xf, name, value, fmt) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    real(dp), intent(in) , dimension(:)  :: value
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value, fmt), ws_significant=.false.)
    else
      call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value), ws_significant=.false.)
    endif
#endif
  end subroutine PseudoAttributeArrayRealDp

  subroutine PseudoAttributeArrayRealSp &
    (xf, name, value, fmt) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    real(sp), intent(in) , dimension(:)  :: value
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value, fmt), ws_significant=.false.)
    else
      call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value), ws_significant=.false.)
    endif
#endif
  end subroutine PseudoAttributeArrayRealSp

  subroutine PseudoAttributeArrayInt &
    (xf, name, value) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    integer, intent(in) , dimension(:)  :: value

#ifndef DUMMYLIB
    call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value), ws_significant=.false.)
#endif
  end subroutine PseudoAttributeArrayInt

  subroutine PseudoAttributeArrayLg &
    (xf, name, value) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    logical, intent(in) , dimension(:)  :: value

#ifndef DUMMYLIB
    call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value), ws_significant=.false.)
#endif
  end subroutine PseudoAttributeArrayLg

  subroutine PseudoAttributeArrayCh &
    (xf, name, value, delimiter) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    character(len=*), intent(in) , dimension(:)  :: value
    character(len=1), intent(in), optional :: delimiter

#ifndef DUMMYLIB
    call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value, delimiter), ws_significant=.false.)
#endif
  end subroutine PseudoAttributeArrayCh

  subroutine PseudoAttributeMatrixCmplxDp &
    (xf, name, value, fmt) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    complex(dp), intent(in) , dimension(:,:)  :: value
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value, fmt), ws_significant=.false.)
    else
      call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value), ws_significant=.false.)
    endif
#endif
  end subroutine PseudoAttributeMatrixCmplxDp

  subroutine PseudoAttributeMatrixCmplxSp &
    (xf, name, value, fmt) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    complex(sp), intent(in) , dimension(:,:)  :: value
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value, fmt), ws_significant=.false.)
    else
      call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value), ws_significant=.false.)
    endif
#endif
  end subroutine PseudoAttributeMatrixCmplxSp

  subroutine PseudoAttributeMatrixRealDp &
    (xf, name, value, fmt) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    real(dp), intent(in) , dimension(:,:)  :: value
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value, fmt), ws_significant=.false.)
    else
      call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value), ws_significant=.false.)
    endif
#endif
  end subroutine PseudoAttributeMatrixRealDp

  subroutine PseudoAttributeMatrixRealSp &
    (xf, name, value, fmt) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    real(sp), intent(in) , dimension(:,:)  :: value
    character(len=*), intent(in), optional :: fmt

#ifndef DUMMYLIB
    if (present(fmt)) then
      call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value, fmt), ws_significant=.false.)
    else
      call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value), ws_significant=.false.)
    endif
#endif
  end subroutine PseudoAttributeMatrixRealSp

  subroutine PseudoAttributeMatrixInt &
    (xf, name, value) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    integer, intent(in) , dimension(:,:)  :: value

#ifndef DUMMYLIB
    call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value), ws_significant=.false.)
#endif
  end subroutine PseudoAttributeMatrixInt

  subroutine PseudoAttributeMatrixLg &
    (xf, name, value) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    logical, intent(in) , dimension(:,:)  :: value

#ifndef DUMMYLIB
    call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value), ws_significant=.false.)
#endif
  end subroutine PseudoAttributeMatrixLg

  subroutine PseudoAttributeMatrixCh &
    (xf, name, value, delimiter) 

    type(xmlf_t), intent(inout) :: xf
    character(len=*), intent(in) :: name
    character(len=*), intent(in) , dimension(:,:)  :: value
    character(len=1), intent(in), optional :: delimiter

#ifndef DUMMYLIB
    call xml_AddPseudoAttribute(xf=xf, name=name, value=str(value, delimiter), ws_significant=.false.)
#endif
  end subroutine PseudoAttributeMatrixCh


end module m_wxml_overloads
