text:
! wrapfstrings.f
! This file is generated by Shroud nowrite-version. Do not edit.
! Copyright (c) 2017-2021, Lawrence Livermore National Security, LLC and
! other Shroud Project Developers.
! See the top-level COPYRIGHT file for details.
!
! SPDX-License-Identifier: (BSD-3-Clause)
!
#include "shroud/features.h"
!>
!! \file wrapfstrings.f
!! \brief Shroud generated wrapper for strings library
!<
! splicer begin file_top
! splicer end file_top
module strings_mod
    ! splicer begin module_use
    ! splicer end module_use
    implicit none

    ! splicer begin module_top
    ! splicer end module_top

    ! ----------------------------------------
    ! Function:  void passChar
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  char status +value
    ! Attrs:     +intent(in)
    ! Exact:     c_in_char_scalar
    interface
        subroutine pass_char(status) &
                bind(C, name="STR_pass_char")
            use iso_c_binding, only : C_CHAR
            implicit none
            character(kind=C_CHAR), value, intent(IN) :: status
        end subroutine pass_char
    end interface

    ! ----------------------------------------
    ! Function:  void passCharForce
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  char status +value
    ! Attrs:     +intent(in)
    ! Exact:     c_in_char_scalar
    interface
        subroutine c_pass_char_force(status) &
                bind(C, name="STR_pass_char_force")
            use iso_c_binding, only : C_CHAR
            implicit none
            character(kind=C_CHAR), value, intent(IN) :: status
        end subroutine c_pass_char_force
    end interface

    ! ----------------------------------------
    ! Function:  char returnChar
    ! Attrs:     +intent(function)
    ! Exact:     c_function_char_scalar
    interface
        subroutine c_return_char(SHT_rv) &
                bind(C, name="STR_return_char")
            use iso_c_binding, only : C_CHAR
            implicit none
            character(kind=C_CHAR), intent(OUT) :: SHT_rv
        end subroutine c_return_char
    end interface

    ! ----------------------------------------
    ! Function:  void passCharPtr
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  char * dest +charlen(40)+intent(out)
    ! Attrs:     +intent(out)
    ! Requested: c_out_char_*
    ! Match:     c_default
    ! ----------------------------------------
    ! Argument:  const char * src
    ! Attrs:     +intent(in)
    ! Requested: c_in_char_*
    ! Match:     c_default
    ! start c_pass_char_ptr
    interface
        subroutine c_pass_char_ptr(dest, src) &
                bind(C, name="STR_pass_char_ptr")
            use iso_c_binding, only : C_CHAR
            implicit none
            character(kind=C_CHAR), intent(OUT) :: dest(*)
            character(kind=C_CHAR), intent(IN) :: src(*)
        end subroutine c_pass_char_ptr
    end interface
    ! end c_pass_char_ptr

    ! ----------------------------------------
    ! Function:  void passCharPtr
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  char * dest +charlen(40)+intent(out)
    ! Attrs:     +api(cfi)+intent(out)
    ! Exact:     c_out_char_*_cfi
    ! ----------------------------------------
    ! Argument:  const char * src
    ! Attrs:     +api(cfi)+intent(in)
    ! Exact:     c_in_char_*_cfi
    ! start pass_char_ptr
    interface
        subroutine pass_char_ptr(dest, src) &
                bind(C, name="STR_pass_char_ptr_CFI")
            implicit none
            character(len=*), intent(OUT) :: dest
            character(len=*), intent(IN) :: src
        end subroutine pass_char_ptr
    end interface
    ! end pass_char_ptr

    ! ----------------------------------------
    ! Function:  void passCharPtrInOut
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  char * s +intent(inout)
    ! Attrs:     +intent(inout)
    ! Requested: c_inout_char_*
    ! Match:     c_default
    interface
        subroutine c_pass_char_ptr_in_out(s) &
                bind(C, name="STR_pass_char_ptr_in_out")
            use iso_c_binding, only : C_CHAR
            implicit none
            character(kind=C_CHAR), intent(INOUT) :: s(*)
        end subroutine c_pass_char_ptr_in_out
    end interface

    ! ----------------------------------------
    ! Function:  void passCharPtrInOut
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  char * s +intent(inout)
    ! Attrs:     +api(cfi)+intent(inout)
    ! Exact:     c_inout_char_*_cfi
    interface
        subroutine pass_char_ptr_in_out(s) &
                bind(C, name="STR_pass_char_ptr_in_out_CFI")
            implicit none
            character(len=*), intent(INOUT) :: s
        end subroutine pass_char_ptr_in_out
    end interface

    ! ----------------------------------------
    ! Function:  const char * getCharPtr1
    ! Attrs:     +deref(allocatable)+intent(function)
    ! Requested: c_function_char_*_allocatable
    ! Match:     c_function_char_*
    ! start c_get_char_ptr1
    interface
        function c_get_char_ptr1() &
                result(SHT_rv) &
                bind(C, name="STR_get_char_ptr1")
            use iso_c_binding, only : C_PTR
            implicit none
            type(C_PTR) SHT_rv
        end function c_get_char_ptr1
    end interface
    ! end c_get_char_ptr1

    ! ----------------------------------------
    ! Function:  const char * getCharPtr1
    ! Attrs:     +api(cfi)+deref(allocatable)+intent(function)
    ! Exact:     c_function_char_*_cfi_allocatable
    ! start c_get_char_ptr1_cfi
    interface
        subroutine c_get_char_ptr1_cfi(SHT_rv) &
                bind(C, name="STR_get_char_ptr1_CFI")
            implicit none
            character(len=:), intent(OUT), allocatable :: SHT_rv
        end subroutine c_get_char_ptr1_cfi
    end interface
    ! end c_get_char_ptr1_cfi

    ! ----------------------------------------
    ! Function:  const char * getCharPtr2 +len(30)
    ! Attrs:     +deref(copy)+intent(function)
    ! Requested: c_function_char_*_copy
    ! Match:     c_function_char_*
    ! start c_get_char_ptr2
    interface
        function c_get_char_ptr2() &
                result(SHT_rv) &
                bind(C, name="STR_get_char_ptr2")
            use iso_c_binding, only : C_PTR
            implicit none
            type(C_PTR) SHT_rv
        end function c_get_char_ptr2
    end interface
    ! end c_get_char_ptr2

    ! ----------------------------------------
    ! Function:  const char * getCharPtr2 +len(30)
    ! Attrs:     +api(cfi)+deref(copy)+intent(function)
    ! Requested: c_function_char_*_cfi_copy
    ! Match:     c_function_char_*_cfi
    ! start c_get_char_ptr2_cfi
    interface
        subroutine c_get_char_ptr2_cfi(SHT_rv) &
                bind(C, name="STR_get_char_ptr2_CFI")
            implicit none
            character(len=*), intent(OUT) :: SHT_rv
        end subroutine c_get_char_ptr2_cfi
    end interface
    ! end c_get_char_ptr2_cfi

    ! ----------------------------------------
    ! Function:  const char * getCharPtr3
    ! Attrs:     +intent(function)
    ! Exact:     c_function_char_*
    ! start c_get_char_ptr3
    interface
        function c_get_char_ptr3() &
                result(SHT_rv) &
                bind(C, name="STR_get_char_ptr3")
            use iso_c_binding, only : C_PTR
            implicit none
            type(C_PTR) SHT_rv
        end function c_get_char_ptr3
    end interface
    ! end c_get_char_ptr3

    ! ----------------------------------------
    ! Function:  void getCharPtr3
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  char * output
    ! Attrs:     +api(cfi)+deref(result)+intent(out)+is_result
    ! Requested: c_function_char_*_cfi_result
    ! Match:     c_function_char_*_cfi
    ! start c_get_char_ptr3_cfi
    interface
        subroutine c_get_char_ptr3_cfi(output) &
                bind(C, name="STR_get_char_ptr3_CFI")
            implicit none
            character(len=*), intent(OUT) :: output
        end subroutine c_get_char_ptr3_cfi
    end interface
    ! end c_get_char_ptr3_cfi

    ! ----------------------------------------
    ! Function:  const char * getCharPtr4 +deref(raw)
    ! Attrs:     +deref(raw)+intent(function)
    ! Requested: c_function_char_*_raw
    ! Match:     c_function_char_*
    interface
        function get_char_ptr4() &
                result(SHT_rv) &
                bind(C, name="STR_get_char_ptr4")
            use iso_c_binding, only : C_PTR
            implicit none
            type(C_PTR) SHT_rv
        end function get_char_ptr4
    end interface

#ifdef HAVE_CHARACTER_POINTER_FUNCTION
    ! ----------------------------------------
    ! Function:  const char * getCharPtr5 +deref(pointer)
    ! Attrs:     +deref(pointer)+intent(function)
    ! Requested: c_function_char_*_pointer
    ! Match:     c_function_char_*
    interface
        function c_get_char_ptr5() &
                result(SHT_rv) &
                bind(C, name="STR_get_char_ptr5")
            use iso_c_binding, only : C_PTR
            implicit none
            type(C_PTR) SHT_rv
        end function c_get_char_ptr5
    end interface
#endif

#ifdef HAVE_CHARACTER_POINTER_FUNCTION
    ! ----------------------------------------
    ! Function:  const char * getCharPtr5 +deref(pointer)
    ! Attrs:     +api(cfi)+deref(pointer)+intent(function)
    ! Exact:     c_function_char_*_cfi_pointer
    interface
        subroutine c_get_char_ptr5_cfi(SHT_rv) &
                bind(C, name="STR_get_char_ptr5_CFI")
            implicit none
            character(len=:), intent(OUT), pointer :: SHT_rv
        end subroutine c_get_char_ptr5_cfi
    end interface
#endif

    ! ----------------------------------------
    ! Function:  const string getConstStringResult
    ! Attrs:     +api(cfi)+deref(allocatable)+intent(function)
    ! Exact:     c_function_string_scalar_cfi_allocatable
    interface
        subroutine c_get_const_string_result_cfi(SHT_rv) &
                bind(C, name="STR_get_const_string_result_CFI")
            implicit none
            character(len=:), intent(OUT), allocatable :: SHT_rv
        end subroutine c_get_const_string_result_cfi
    end interface

    ! ----------------------------------------
    ! Function:  const string getConstStringLen +len(30)
    ! Attrs:     +api(cfi)+deref(copy)+intent(function)
    ! Requested: c_function_string_scalar_cfi_copy
    ! Match:     c_function_string_scalar_cfi
    interface
        subroutine c_get_const_string_len_cfi(SHT_rv) &
                bind(C, name="STR_get_const_string_len_CFI")
            implicit none
            character(len=*), intent(OUT) :: SHT_rv
        end subroutine c_get_const_string_len_cfi
    end interface

    ! ----------------------------------------
    ! Function:  void getConstStringAsArg
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  string * output
    ! Attrs:     +api(cfi)+deref(result)+intent(out)+is_result
    ! Requested: c_function_string_*_cfi_result
    ! Match:     c_function_string_*_cfi
    interface
        subroutine c_get_const_string_as_arg_cfi(output) &
                bind(C, name="STR_get_const_string_as_arg_CFI")
            implicit none
            character(len=*), intent(OUT) :: output
        end subroutine c_get_const_string_as_arg_cfi
    end interface

    ! ----------------------------------------
    ! Function:  const std::string getConstStringAlloc
    ! Attrs:     +api(cfi)+deref(allocatable)+intent(function)
    ! Exact:     c_function_string_scalar_cfi_allocatable
    interface
        subroutine c_get_const_string_alloc_cfi(SHT_rv) &
                bind(C, name="STR_get_const_string_alloc_CFI")
            implicit none
            character(len=:), intent(OUT), allocatable :: SHT_rv
        end subroutine c_get_const_string_alloc_cfi
    end interface

    ! ----------------------------------------
    ! Function:  const string & getConstStringRefPure
    ! Attrs:     +deref(allocatable)+intent(function)
    ! Requested: c_function_string_&_allocatable
    ! Match:     c_function_string_&
    ! start c_get_const_string_ref_pure
    interface
        function c_get_const_string_ref_pure() &
                result(SHT_rv) &
                bind(C, name="STR_get_const_string_ref_pure")
            use iso_c_binding, only : C_PTR
            implicit none
            type(C_PTR) SHT_rv
        end function c_get_const_string_ref_pure
    end interface
    ! end c_get_const_string_ref_pure

    ! ----------------------------------------
    ! Function:  const string & getConstStringRefPure
    ! Attrs:     +api(cfi)+deref(allocatable)+intent(function)
    ! Exact:     c_function_string_&_cfi_allocatable
    ! start c_get_const_string_ref_pure_cfi
    interface
        subroutine c_get_const_string_ref_pure_cfi(SHT_rv) &
                bind(C, name="STR_get_const_string_ref_pure_CFI")
            implicit none
            character(len=:), intent(OUT), allocatable :: SHT_rv
        end subroutine c_get_const_string_ref_pure_cfi
    end interface
    ! end c_get_const_string_ref_pure_cfi

    ! ----------------------------------------
    ! Function:  const string & getConstStringRefLen +len(30)
    ! Attrs:     +deref(copy)+intent(function)
    ! Requested: c_function_string_&_copy
    ! Match:     c_function_string_&
    interface
        function c_get_const_string_ref_len() &
                result(SHT_rv) &
                bind(C, name="STR_get_const_string_ref_len")
            use iso_c_binding, only : C_PTR
            implicit none
            type(C_PTR) SHT_rv
        end function c_get_const_string_ref_len
    end interface

    ! ----------------------------------------
    ! Function:  const string & getConstStringRefLen +len(30)
    ! Attrs:     +api(cfi)+deref(copy)+intent(function)
    ! Requested: c_function_string_&_cfi_copy
    ! Match:     c_function_string_&_cfi
    interface
        subroutine c_get_const_string_ref_len_cfi(SHT_rv) &
                bind(C, name="STR_get_const_string_ref_len_CFI")
            implicit none
            character(len=*), intent(OUT) :: SHT_rv
        end subroutine c_get_const_string_ref_len_cfi
    end interface

    ! ----------------------------------------
    ! Function:  const string & getConstStringRefAsArg
    ! Attrs:     +intent(function)
    ! Exact:     c_function_string_&
    interface
        function c_get_const_string_ref_as_arg() &
                result(SHT_rv) &
                bind(C, name="STR_get_const_string_ref_as_arg")
            use iso_c_binding, only : C_PTR
            implicit none
            type(C_PTR) SHT_rv
        end function c_get_const_string_ref_as_arg
    end interface

    ! ----------------------------------------
    ! Function:  void getConstStringRefAsArg
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  string & output
    ! Attrs:     +api(cfi)+deref(result)+intent(out)+is_result
    ! Requested: c_function_string_&_cfi_result
    ! Match:     c_function_string_&_cfi
    interface
        subroutine c_get_const_string_ref_as_arg_cfi(output) &
                bind(C, name="STR_get_const_string_ref_as_arg_CFI")
            implicit none
            character(len=*), intent(OUT) :: output
        end subroutine c_get_const_string_ref_as_arg_cfi
    end interface

    ! ----------------------------------------
    ! Function:  const string & getConstStringRefLenEmpty +len(30)
    ! Attrs:     +deref(copy)+intent(function)
    ! Requested: c_function_string_&_copy
    ! Match:     c_function_string_&
    interface
        function c_get_const_string_ref_len_empty() &
                result(SHT_rv) &
                bind(C, name="STR_get_const_string_ref_len_empty")
            use iso_c_binding, only : C_PTR
            implicit none
            type(C_PTR) SHT_rv
        end function c_get_const_string_ref_len_empty
    end interface

    ! ----------------------------------------
    ! Function:  const string & getConstStringRefLenEmpty +len(30)
    ! Attrs:     +api(cfi)+deref(copy)+intent(function)
    ! Requested: c_function_string_&_cfi_copy
    ! Match:     c_function_string_&_cfi
    interface
        subroutine c_get_const_string_ref_len_empty_cfi(SHT_rv) &
                bind(C, name="STR_get_const_string_ref_len_empty_CFI")
            implicit none
            character(len=*), intent(OUT) :: SHT_rv
        end subroutine c_get_const_string_ref_len_empty_cfi
    end interface

    ! ----------------------------------------
    ! Function:  const std::string & getConstStringRefAlloc
    ! Attrs:     +deref(allocatable)+intent(function)
    ! Requested: c_function_string_&_allocatable
    ! Match:     c_function_string_&
    interface
        function c_get_const_string_ref_alloc() &
                result(SHT_rv) &
                bind(C, name="STR_get_const_string_ref_alloc")
            use iso_c_binding, only : C_PTR
            implicit none
            type(C_PTR) SHT_rv
        end function c_get_const_string_ref_alloc
    end interface

    ! ----------------------------------------
    ! Function:  const std::string & getConstStringRefAlloc
    ! Attrs:     +api(cfi)+deref(allocatable)+intent(function)
    ! Exact:     c_function_string_&_cfi_allocatable
    interface
        subroutine c_get_const_string_ref_alloc_cfi(SHT_rv) &
                bind(C, name="STR_get_const_string_ref_alloc_CFI")
            implicit none
            character(len=:), intent(OUT), allocatable :: SHT_rv
        end subroutine c_get_const_string_ref_alloc_cfi
    end interface

    ! ----------------------------------------
    ! Function:  const string * getConstStringPtrLen +len(30)
    ! Attrs:     +deref(copy)+intent(function)
    ! Requested: c_function_string_*_copy
    ! Match:     c_function_string_*
    interface
        function c_get_const_string_ptr_len() &
                result(SHT_rv) &
                bind(C, name="STR_get_const_string_ptr_len")
            use iso_c_binding, only : C_PTR
            implicit none
            type(C_PTR) SHT_rv
        end function c_get_const_string_ptr_len
    end interface

    ! ----------------------------------------
    ! Function:  const string * getConstStringPtrLen +len(30)
    ! Attrs:     +api(cfi)+deref(copy)+intent(function)
    ! Requested: c_function_string_*_cfi_copy
    ! Match:     c_function_string_*_cfi
    interface
        subroutine c_get_const_string_ptr_len_cfi(SHT_rv) &
                bind(C, name="STR_get_const_string_ptr_len_CFI")
            implicit none
            character(len=*), intent(OUT) :: SHT_rv
        end subroutine c_get_const_string_ptr_len_cfi
    end interface

    ! ----------------------------------------
    ! Function:  const std::string * getConstStringPtrAlloc +owner(library)
    ! Attrs:     +deref(allocatable)+intent(function)
    ! Requested: c_function_string_*_allocatable
    ! Match:     c_function_string_*
    interface
        function c_get_const_string_ptr_alloc() &
                result(SHT_rv) &
                bind(C, name="STR_get_const_string_ptr_alloc")
            use iso_c_binding, only : C_PTR
            implicit none
            type(C_PTR) SHT_rv
        end function c_get_const_string_ptr_alloc
    end interface

    ! ----------------------------------------
    ! Function:  const std::string * getConstStringPtrAlloc +owner(library)
    ! Attrs:     +api(cfi)+deref(allocatable)+intent(function)
    ! Exact:     c_function_string_*_cfi_allocatable
    interface
        subroutine c_get_const_string_ptr_alloc_cfi(SHT_rv) &
                bind(C, name="STR_get_const_string_ptr_alloc_CFI")
            implicit none
            character(len=:), intent(OUT), allocatable :: SHT_rv
        end subroutine c_get_const_string_ptr_alloc_cfi
    end interface

    ! ----------------------------------------
    ! Function:  const std::string * getConstStringPtrOwnsAlloc +owner(caller)
    ! Attrs:     +deref(allocatable)+intent(function)
    ! Requested: c_function_string_*_allocatable
    ! Match:     c_function_string_*
    interface
        function c_get_const_string_ptr_owns_alloc() &
                result(SHT_rv) &
                bind(C, name="STR_get_const_string_ptr_owns_alloc")
            use iso_c_binding, only : C_PTR
            implicit none
            type(C_PTR) SHT_rv
        end function c_get_const_string_ptr_owns_alloc
    end interface

    ! ----------------------------------------
    ! Function:  const std::string * getConstStringPtrOwnsAlloc +owner(caller)
    ! Attrs:     +api(cfi)+deref(allocatable)+intent(function)
    ! Exact:     c_function_string_*_cfi_allocatable
    interface
        subroutine c_get_const_string_ptr_owns_alloc_cfi(SHT_rv) &
                bind(C, name="STR_get_const_string_ptr_owns_alloc_CFI")
            implicit none
            character(len=:), intent(OUT), allocatable :: SHT_rv
        end subroutine c_get_const_string_ptr_owns_alloc_cfi
    end interface

    ! ----------------------------------------
    ! Function:  const std::string * getConstStringPtrOwnsAllocPattern +free_pattern(C_string_free)+owner(caller)
    ! Attrs:     +deref(allocatable)+intent(function)
    ! Requested: c_function_string_*_allocatable
    ! Match:     c_function_string_*
    interface
        function c_get_const_string_ptr_owns_alloc_pattern() &
                result(SHT_rv) &
                bind(C, name="STR_get_const_string_ptr_owns_alloc_pattern")
            use iso_c_binding, only : C_PTR
            implicit none
            type(C_PTR) SHT_rv
        end function c_get_const_string_ptr_owns_alloc_pattern
    end interface

    ! ----------------------------------------
    ! Function:  const std::string * getConstStringPtrOwnsAllocPattern +free_pattern(C_string_free)+owner(caller)
    ! Attrs:     +api(cfi)+deref(allocatable)+intent(function)
    ! Exact:     c_function_string_*_cfi_allocatable
    interface
        subroutine c_get_const_string_ptr_owns_alloc_pattern_cfi(SHT_rv) &
                bind(C, name="STR_get_const_string_ptr_owns_alloc_pattern_CFI")
            implicit none
            character(len=:), intent(OUT), allocatable :: SHT_rv
        end subroutine c_get_const_string_ptr_owns_alloc_pattern_cfi
    end interface

#ifdef HAVE_CHARACTER_POINTER_FUNCTION
    ! ----------------------------------------
    ! Function:  const std::string * getConstStringPtrPointer +deref(pointer)+owner(library)
    ! Attrs:     +deref(pointer)+intent(function)
    ! Requested: c_function_string_*_pointer
    ! Match:     c_function_string_*
    interface
        function c_get_const_string_ptr_pointer() &
                result(SHT_rv) &
                bind(C, name="STR_get_const_string_ptr_pointer")
            use iso_c_binding, only : C_PTR
            implicit none
            type(C_PTR) SHT_rv
        end function c_get_const_string_ptr_pointer
    end interface
#endif

#ifdef HAVE_CHARACTER_POINTER_FUNCTION
    ! ----------------------------------------
    ! Function:  const std::string * getConstStringPtrPointer +deref(pointer)+owner(library)
    ! Attrs:     +api(cfi)+deref(pointer)+intent(function)
    ! Exact:     c_function_string_*_cfi_pointer
    interface
        subroutine c_get_const_string_ptr_pointer_cfi(SHT_rv) &
                bind(C, name="STR_get_const_string_ptr_pointer_CFI")
            implicit none
            character(len=:), intent(OUT), pointer :: SHT_rv
        end subroutine c_get_const_string_ptr_pointer_cfi
    end interface
#endif

    ! ----------------------------------------
    ! Function:  void acceptStringConstReference
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  const std::string & arg1
    ! Attrs:     +intent(in)
    ! Exact:     c_in_string_&
    interface
        subroutine c_accept_string_const_reference(arg1) &
                bind(C, name="STR_accept_string_const_reference")
            use iso_c_binding, only : C_CHAR
            implicit none
            character(kind=C_CHAR), intent(IN) :: arg1(*)
        end subroutine c_accept_string_const_reference
    end interface

    ! ----------------------------------------
    ! Function:  void acceptStringConstReference
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  const std::string & arg1
    ! Attrs:     +api(cfi)+intent(in)
    ! Exact:     c_in_string_&_cfi
    interface
        subroutine accept_string_const_reference(arg1) &
                bind(C, name="STR_accept_string_const_reference_CFI")
            implicit none
            character(len=*), intent(IN) :: arg1
        end subroutine accept_string_const_reference
    end interface

    ! ----------------------------------------
    ! Function:  void acceptStringReferenceOut
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  std::string & arg1 +intent(out)
    ! Attrs:     +intent(out)
    ! Exact:     c_out_string_&
    interface
        subroutine c_accept_string_reference_out(arg1) &
                bind(C, name="STR_accept_string_reference_out")
            use iso_c_binding, only : C_CHAR
            implicit none
            character(kind=C_CHAR), intent(OUT) :: arg1(*)
        end subroutine c_accept_string_reference_out
    end interface

    ! ----------------------------------------
    ! Function:  void acceptStringReferenceOut
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  std::string & arg1 +intent(out)
    ! Attrs:     +api(cfi)+intent(out)
    ! Exact:     c_out_string_&_cfi
    interface
        subroutine accept_string_reference_out(arg1) &
                bind(C, name="STR_accept_string_reference_out_CFI")
            implicit none
            character(len=*), intent(OUT) :: arg1
        end subroutine accept_string_reference_out
    end interface

    ! ----------------------------------------
    ! Function:  void acceptStringReference
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  std::string & arg1
    ! Attrs:     +intent(inout)
    ! Exact:     c_inout_string_&
    ! start c_accept_string_reference
    interface
        subroutine c_accept_string_reference(arg1) &
                bind(C, name="STR_accept_string_reference")
            use iso_c_binding, only : C_CHAR
            implicit none
            character(kind=C_CHAR), intent(INOUT) :: arg1(*)
        end subroutine c_accept_string_reference
    end interface
    ! end c_accept_string_reference

    ! ----------------------------------------
    ! Function:  void acceptStringReference
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  std::string & arg1
    ! Attrs:     +api(cfi)+intent(inout)
    ! Exact:     c_inout_string_&_cfi
    ! start accept_string_reference
    interface
        subroutine accept_string_reference(arg1) &
                bind(C, name="STR_accept_string_reference_CFI")
            implicit none
            character(len=*), intent(INOUT) :: arg1
        end subroutine accept_string_reference
    end interface
    ! end accept_string_reference

    ! ----------------------------------------
    ! Function:  void acceptStringPointerConst
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  const std::string * arg1
    ! Attrs:     +intent(in)
    ! Exact:     c_in_string_*
    interface
        subroutine c_accept_string_pointer_const(arg1) &
                bind(C, name="STR_accept_string_pointer_const")
            use iso_c_binding, only : C_CHAR
            implicit none
            character(kind=C_CHAR), intent(IN) :: arg1(*)
        end subroutine c_accept_string_pointer_const
    end interface

    ! ----------------------------------------
    ! Function:  void acceptStringPointerConst
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  const std::string * arg1
    ! Attrs:     +api(cfi)+intent(in)
    ! Exact:     c_in_string_*_cfi
    interface
        subroutine accept_string_pointer_const(arg1) &
                bind(C, name="STR_accept_string_pointer_const_CFI")
            implicit none
            character(len=*), intent(IN) :: arg1
        end subroutine accept_string_pointer_const
    end interface

    ! ----------------------------------------
    ! Function:  void acceptStringPointer
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  std::string * arg1
    ! Attrs:     +intent(inout)
    ! Exact:     c_inout_string_*
    interface
        subroutine c_accept_string_pointer(arg1) &
                bind(C, name="STR_accept_string_pointer")
            use iso_c_binding, only : C_CHAR
            implicit none
            character(kind=C_CHAR), intent(INOUT) :: arg1(*)
        end subroutine c_accept_string_pointer
    end interface

    ! ----------------------------------------
    ! Function:  void acceptStringPointer
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  std::string * arg1
    ! Attrs:     +api(cfi)+intent(inout)
    ! Exact:     c_inout_string_*_cfi
    interface
        subroutine accept_string_pointer(arg1) &
                bind(C, name="STR_accept_string_pointer_CFI")
            implicit none
            character(len=*), intent(INOUT) :: arg1
        end subroutine accept_string_pointer
    end interface

    ! ----------------------------------------
    ! Function:  void fetchStringPointer
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  std::string * arg1 +intent(out)
    ! Attrs:     +intent(out)
    ! Exact:     c_out_string_*
    interface
        subroutine c_fetch_string_pointer(arg1) &
                bind(C, name="STR_fetch_string_pointer")
            use iso_c_binding, only : C_CHAR
            implicit none
            character(kind=C_CHAR), intent(OUT) :: arg1(*)
        end subroutine c_fetch_string_pointer
    end interface

    ! ----------------------------------------
    ! Function:  void fetchStringPointer
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  std::string * arg1 +intent(out)
    ! Attrs:     +api(cfi)+intent(out)
    ! Exact:     c_out_string_*_cfi
    interface
        subroutine fetch_string_pointer(arg1) &
                bind(C, name="STR_fetch_string_pointer_CFI")
            implicit none
            character(len=*), intent(OUT) :: arg1
        end subroutine fetch_string_pointer
    end interface

    ! ----------------------------------------
    ! Function:  void acceptStringPointerLen
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  std::string * arg1
    ! Attrs:     +intent(inout)
    ! Exact:     c_inout_string_*
    ! ----------------------------------------
    ! Argument:  int * nlen +intent(out)
    ! Attrs:     +intent(out)
    ! Requested: c_out_native_*
    ! Match:     c_default
    interface
        subroutine c_accept_string_pointer_len(arg1, nlen) &
                bind(C, name="STR_accept_string_pointer_len")
            use iso_c_binding, only : C_CHAR, C_INT
            implicit none
            character(kind=C_CHAR), intent(INOUT) :: arg1(*)
            integer(C_INT), intent(OUT) :: nlen
        end subroutine c_accept_string_pointer_len
    end interface

    ! ----------------------------------------
    ! Function:  void acceptStringPointerLen
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  std::string * arg1
    ! Attrs:     +api(cfi)+intent(inout)
    ! Exact:     c_inout_string_*_cfi
    ! ----------------------------------------
    ! Argument:  int * nlen +intent(out)
    ! Attrs:     +intent(out)
    ! Requested: c_out_native_*
    ! Match:     c_default
    interface
        subroutine accept_string_pointer_len(arg1, nlen) &
                bind(C, name="STR_accept_string_pointer_len_CFI")
            use iso_c_binding, only : C_INT
            implicit none
            character(len=*), intent(INOUT) :: arg1
            integer(C_INT), intent(OUT) :: nlen
        end subroutine accept_string_pointer_len
    end interface

    ! ----------------------------------------
    ! Function:  void fetchStringPointerLen
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  std::string * arg1 +intent(out)
    ! Attrs:     +intent(out)
    ! Exact:     c_out_string_*
    ! ----------------------------------------
    ! Argument:  int * nlen +intent(out)
    ! Attrs:     +intent(out)
    ! Requested: c_out_native_*
    ! Match:     c_default
    interface
        subroutine c_fetch_string_pointer_len(arg1, nlen) &
                bind(C, name="STR_fetch_string_pointer_len")
            use iso_c_binding, only : C_CHAR, C_INT
            implicit none
            character(kind=C_CHAR), intent(OUT) :: arg1(*)
            integer(C_INT), intent(OUT) :: nlen
        end subroutine c_fetch_string_pointer_len
    end interface

    ! ----------------------------------------
    ! Function:  void fetchStringPointerLen
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  std::string * arg1 +intent(out)
    ! Attrs:     +api(cfi)+intent(out)
    ! Exact:     c_out_string_*_cfi
    ! ----------------------------------------
    ! Argument:  int * nlen +intent(out)
    ! Attrs:     +intent(out)
    ! Requested: c_out_native_*
    ! Match:     c_default
    interface
        subroutine fetch_string_pointer_len(arg1, nlen) &
                bind(C, name="STR_fetch_string_pointer_len_CFI")
            use iso_c_binding, only : C_INT
            implicit none
            character(len=*), intent(OUT) :: arg1
            integer(C_INT), intent(OUT) :: nlen
        end subroutine fetch_string_pointer_len
    end interface

    ! ----------------------------------------
    ! Function:  int acceptStringInstance
    ! Attrs:     +intent(function)
    ! Requested: c_function_native_scalar
    ! Match:     c_function
    ! ----------------------------------------
    ! Argument:  std::string arg1 +value
    ! Attrs:     +intent(in)
    ! Exact:     c_in_string_scalar
    interface
        function c_accept_string_instance(arg1) &
                result(SHT_rv) &
                bind(C, name="STR_accept_string_instance")
            use iso_c_binding, only : C_CHAR, C_INT
            implicit none
            character(kind=C_CHAR), intent(IN) :: arg1(*)
            integer(C_INT) :: SHT_rv
        end function c_accept_string_instance
    end interface

    ! ----------------------------------------
    ! Function:  int acceptStringInstance
    ! Attrs:     +intent(function)
    ! Requested: c_function_native_scalar
    ! Match:     c_function
    ! ----------------------------------------
    ! Argument:  std::string arg1 +value
    ! Attrs:     +api(cfi)+intent(in)
    ! Exact:     c_in_string_scalar_cfi
    interface
        function accept_string_instance(arg1) &
                result(SHT_rv) &
                bind(C, name="STR_accept_string_instance_CFI")
            use iso_c_binding, only : C_INT
            implicit none
            character(len=*), intent(IN) :: arg1
            integer(C_INT) :: SHT_rv
        end function accept_string_instance
    end interface

    ! ----------------------------------------
    ! Function:  void explicit1
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  char * name +intent(in)+len_trim(AAlen)
    ! Attrs:     +intent(in)
    ! Requested: c_in_char_*
    ! Match:     c_default
    interface
        subroutine c_explicit1(name) &
                bind(C, name="STR_explicit1")
            use iso_c_binding, only : C_CHAR
            implicit none
            character(kind=C_CHAR), intent(IN) :: name(*)
        end subroutine c_explicit1
    end interface

    ! ----------------------------------------
    ! Function:  void explicit1
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  char * name +intent(in)+len_trim(AAlen)
    ! Attrs:     +api(cfi)+intent(in)
    ! Exact:     c_in_char_*_cfi
    interface
        subroutine explicit1(name) &
                bind(C, name="STR_explicit1_CFI")
            implicit none
            character(len=*), intent(IN) :: name
        end subroutine explicit1
    end interface

    ! ----------------------------------------
    ! Function:  void explicit2
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  char * name +intent(out)+len(AAtrim)
    ! Attrs:     +intent(out)
    ! Requested: c_out_char_*
    ! Match:     c_default
    interface
        subroutine c_explicit2(name) &
                bind(C, name="STR_explicit2")
            use iso_c_binding, only : C_CHAR
            implicit none
            character(kind=C_CHAR), intent(OUT) :: name(*)
        end subroutine c_explicit2
    end interface

    ! ----------------------------------------
    ! Function:  void explicit2
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  char * name +intent(out)+len(AAtrim)
    ! Attrs:     +api(cfi)+intent(out)
    ! Exact:     c_out_char_*_cfi
    interface
        subroutine explicit2(name) &
                bind(C, name="STR_explicit2_CFI")
            implicit none
            character(len=*), intent(OUT) :: name
        end subroutine explicit2
    end interface

    ! ----------------------------------------
    ! Function:  void CpassChar
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  char status +value
    ! Attrs:     +intent(in)
    ! Exact:     c_in_char_scalar
    interface
        subroutine cpass_char(status) &
                bind(C, name="CpassChar")
            use iso_c_binding, only : C_CHAR
            implicit none
            character(kind=C_CHAR), value, intent(IN) :: status
        end subroutine cpass_char
    end interface

    ! ----------------------------------------
    ! Function:  char CreturnChar
    ! Attrs:     +intent(function)
    ! Exact:     c_function_char_scalar
    interface
        subroutine c_creturn_char(SHT_rv) &
                bind(C, name="STR_creturn_char")
            use iso_c_binding, only : C_CHAR
            implicit none
            character(kind=C_CHAR), intent(OUT) :: SHT_rv
        end subroutine c_creturn_char
    end interface

    ! ----------------------------------------
    ! Function:  void CpassCharPtr
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  char * dest +intent(out)
    ! Attrs:     +intent(out)
    ! Requested: c_out_char_*
    ! Match:     c_default
    ! ----------------------------------------
    ! Argument:  const char * src +blanknull
    ! Attrs:     +intent(in)
    ! Requested: c_in_char_*
    ! Match:     c_default
    interface
        subroutine c_cpass_char_ptr(dest, src) &
                bind(C, name="CpassCharPtr")
            use iso_c_binding, only : C_CHAR
            implicit none
            character(kind=C_CHAR), intent(OUT) :: dest(*)
            character(kind=C_CHAR), intent(IN) :: src(*)
        end subroutine c_cpass_char_ptr
    end interface

    ! ----------------------------------------
    ! Function:  void CpassCharPtr
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  char * dest +intent(out)
    ! Attrs:     +api(cfi)+intent(out)
    ! Exact:     c_out_char_*_cfi
    ! ----------------------------------------
    ! Argument:  const char * src +blanknull
    ! Attrs:     +api(cfi)+intent(in)
    ! Exact:     c_in_char_*_cfi
    interface
        subroutine cpass_char_ptr(dest, src) &
                bind(C, name="STR_cpass_char_ptr_CFI")
            implicit none
            character(len=*), intent(OUT) :: dest
            character(len=*), intent(IN) :: src
        end subroutine cpass_char_ptr
    end interface

    ! ----------------------------------------
    ! Function:  void CpassCharPtrBlank
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  char * dest +intent(out)
    ! Attrs:     +intent(out)
    ! Requested: c_out_char_*
    ! Match:     c_default
    ! ----------------------------------------
    ! Argument:  const char * src
    ! Attrs:     +intent(in)
    ! Requested: c_in_char_*
    ! Match:     c_default
    interface
        subroutine c_cpass_char_ptr_blank(dest, src) &
                bind(C, name="STR_cpass_char_ptr_blank")
            use iso_c_binding, only : C_CHAR
            implicit none
            character(kind=C_CHAR), intent(OUT) :: dest(*)
            character(kind=C_CHAR), intent(IN) :: src(*)
        end subroutine c_cpass_char_ptr_blank
    end interface

    ! ----------------------------------------
    ! Function:  void CpassCharPtrBlank
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  char * dest +intent(out)
    ! Attrs:     +api(cfi)+intent(out)
    ! Exact:     c_out_char_*_cfi
    ! ----------------------------------------
    ! Argument:  const char * src
    ! Attrs:     +api(cfi)+intent(in)
    ! Exact:     c_in_char_*_cfi
    interface
        subroutine cpass_char_ptr_blank(dest, src) &
                bind(C, name="STR_cpass_char_ptr_blank_CFI")
            implicit none
            character(len=*), intent(OUT) :: dest
            character(len=*), intent(IN) :: src
        end subroutine cpass_char_ptr_blank
    end interface

    ! ----------------------------------------
    ! Function:  void PostDeclare
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  int * count +intent(in)+rank(1)
    ! Attrs:     +intent(in)
    ! Requested: c_in_native_*
    ! Match:     c_default
    ! ----------------------------------------
    ! Argument:  std::string & name
    ! Attrs:     +intent(inout)
    ! Exact:     c_inout_string_&
    interface
        subroutine c_post_declare(count, name) &
                bind(C, name="STR_post_declare")
            use iso_c_binding, only : C_CHAR, C_INT
            implicit none
            integer(C_INT), intent(IN) :: count(*)
            character(kind=C_CHAR), intent(INOUT) :: name(*)
        end subroutine c_post_declare
    end interface

    ! ----------------------------------------
    ! Function:  void PostDeclare
    ! Attrs:     +intent(subroutine)
    ! Requested: c_subroutine_void_scalar
    ! Match:     c_subroutine
    ! ----------------------------------------
    ! Argument:  int * count +intent(in)+rank(1)
    ! Attrs:     +api(cfi)+intent(in)
    ! Exact:     c_in_native_*_cfi
    ! ----------------------------------------
    ! Argument:  std::string & name
    ! Attrs:     +api(cfi)+intent(inout)
    ! Exact:     c_inout_string_&_cfi
    interface
        subroutine post_declare(count, name) &
                bind(C, name="STR_post_declare_CFI")
            use iso_c_binding, only : C_INT
            implicit none
            integer(C_INT), intent(IN) :: count(:)
            character(len=*), intent(INOUT) :: name
        end subroutine post_declare
    end interface

    ! ----------------------------------------
    ! Function:  int CpassCharPtrNotrim
    ! Attrs:     +intent(function)
    ! Requested: c_function_native_scalar
    ! Match:     c_function
    ! ----------------------------------------
    ! Argument:  const char * src
    ! Attrs:     +intent(in)
    ! Requested: c_in_char_*
    ! Match:     c_default
    interface
        function c_cpass_char_ptr_notrim(src) &
                result(SHT_rv) &
                bind(C, name="STR_cpass_char_ptr_notrim")
            use iso_c_binding, only : C_CHAR, C_INT
            implicit none
            character(kind=C_CHAR), intent(IN) :: src(*)
            integer(C_INT) :: SHT_rv
        end function c_cpass_char_ptr_notrim
    end interface

    ! ----------------------------------------
    ! Function:  int CpassCharPtrNotrim
    ! Attrs:     +intent(function)
    ! Requested: c_function_native_scalar
    ! Match:     c_function
    ! ----------------------------------------
    ! Argument:  const char * src
    ! Attrs:     +api(cfi)+intent(in)
    ! Exact:     c_in_char_*_cfi
    interface
        function cpass_char_ptr_notrim(src) &
                result(SHT_rv) &
                bind(C, name="STR_cpass_char_ptr_notrim_CFI")
            use iso_c_binding, only : C_INT
            implicit none
            character(len=*), intent(IN) :: src
            integer(C_INT) :: SHT_rv
        end function cpass_char_ptr_notrim
    end interface

    ! ----------------------------------------
    ! Function:  int CpassCharPtrCAPI
    ! Attrs:     +intent(function)
    ! Requested: c_function_native_scalar
    ! Match:     c_function
    ! ----------------------------------------
    ! Argument:  void * addr +value
    ! Attrs:     +intent(in)
    ! Requested: c_in_void_*
    ! Match:     c_default
    ! ----------------------------------------
    ! Argument:  const char * src +api(capi)
    ! Attrs:     +api(capi)+intent(in)
    ! Requested: c_in_char_*_capi
    ! Match:     c_default
    interface
        function cpass_char_ptr_capi(addr, src) &
                result(SHT_rv) &
                bind(C, name="STR_cpass_char_ptr_capi")
            use iso_c_binding, only : C_CHAR, C_INT, C_PTR
            implicit none
            type(C_PTR), value, intent(IN) :: addr
            character(kind=C_CHAR), intent(IN) :: src(*)
            integer(C_INT) :: SHT_rv
        end function cpass_char_ptr_capi
    end interface

    ! ----------------------------------------
    ! Function:  int CpassCharPtrCAPI2
    ! Attrs:     +intent(function)
    ! Requested: c_function_native_scalar
    ! Match:     c_function
    ! ----------------------------------------
    ! Argument:  const char * in
    ! Attrs:     +intent(in)
    ! Requested: c_in_char_*
    ! Match:     c_default
    ! ----------------------------------------
    ! Argument:  const char * src +api(capi)
    ! Attrs:     +api(capi)+intent(in)
    ! Requested: c_in_char_*_capi
    ! Match:     c_default
    interface
        function c_cpass_char_ptr_capi2(in, src) &
                result(SHT_rv) &
                bind(C, name="STR_cpass_char_ptr_capi2")
            use iso_c_binding, only : C_CHAR, C_INT
            implicit none
            character(kind=C_CHAR), intent(IN) :: in(*)
            character(kind=C_CHAR), intent(IN) :: src(*)
            integer(C_INT) :: SHT_rv
        end function c_cpass_char_ptr_capi2
    end interface

    ! ----------------------------------------
    ! Function:  int CpassCharPtrCAPI2
    ! Attrs:     +intent(function)
    ! Requested: c_function_native_scalar
    ! Match:     c_function
    ! ----------------------------------------
    ! Argument:  const char * in
    ! Attrs:     +api(cfi)+intent(in)
    ! Exact:     c_in_char_*_cfi
    ! ----------------------------------------
    ! Argument:  const char * src +api(capi)
    ! Attrs:     +api(capi)+intent(in)
    ! Requested: c_in_char_*_capi
    ! Match:     c_default
    interface
        function cpass_char_ptr_capi2(in, src) &
                result(SHT_rv) &
                bind(C, name="STR_cpass_char_ptr_capi2_CFI")
            use iso_c_binding, only : C_CHAR, C_INT
            implicit none
            character(len=*), intent(IN) :: in
            character(kind=C_CHAR), intent(IN) :: src(*)
            integer(C_INT) :: SHT_rv
        end function cpass_char_ptr_capi2
    end interface

    interface
        ! splicer begin additional_interfaces
        ! splicer end additional_interfaces
    end interface

contains

    ! ----------------------------------------
    ! Function:  void passCharForce
    ! Attrs:     +intent(subroutine)
    ! Exact:     f_subroutine
    ! Attrs:     +intent(subroutine)
    ! Exact:     c_subroutine
    ! ----------------------------------------
    ! Argument:  char status +value
    ! Attrs:     +intent(in)
    ! Exact:     f_in_char_scalar
    ! Attrs:     +intent(in)
    ! Exact:     c_in_char_scalar
    !>
    !! By default no Fortran wrapper is created.
    !! Force one so it can be tested.
    !<
    subroutine pass_char_force(status)
        character, value, intent(IN) :: status
        ! splicer begin function.pass_char_force
        call c_pass_char_force(status)
        ! splicer end function.pass_char_force
    end subroutine pass_char_force

    ! ----------------------------------------
    ! Function:  char returnChar
    ! Attrs:     +intent(function)
    ! Exact:     f_function_char_scalar
    ! Attrs:     +intent(function)
    ! Exact:     c_function_char_scalar
    !>
    !! \brief return a char argument (non-pointer)
    !!
    !<
    function return_char() &
            result(SHT_rv)
        character :: SHT_rv
        ! splicer begin function.return_char
        call c_return_char(SHT_rv)
        ! splicer end function.return_char
    end function return_char

    ! Generated by arg_to_cfi
    ! ----------------------------------------
    ! Function:  const char * getCharPtr1
    ! Attrs:     +deref(allocatable)+intent(function)
    ! Exact:     f_function_char_*_cfi_allocatable
    ! Attrs:     +api(cfi)+deref(allocatable)+intent(function)
    ! Exact:     c_function_char_*_cfi_allocatable
    !>
    !! \brief return a 'const char *' as character(*)
    !!
    !<
    ! start get_char_ptr1
    function get_char_ptr1() &
            result(SHT_rv)
        character(len=:), allocatable :: SHT_rv
        ! splicer begin function.get_char_ptr1
        call c_get_char_ptr1_cfi(SHT_rv)
        ! splicer end function.get_char_ptr1
    end function get_char_ptr1
    ! end get_char_ptr1

    ! Generated by arg_to_cfi
    ! ----------------------------------------
    ! Function:  const char * getCharPtr2 +len(30)
    ! Attrs:     +deref(copy)+intent(function)
    ! Requested: f_function_char_*_cfi_copy
    ! Match:     f_function_char_*_cfi
    ! Attrs:     +api(cfi)+deref(copy)+intent(function)
    ! Requested: c_function_char_*_cfi_copy
    ! Match:     c_function_char_*_cfi
    !>
    !! \brief return 'const char *' with fixed size (len=30)
    !!
    !<
    ! start get_char_ptr2
    function get_char_ptr2() &
            result(SHT_rv)
        character(len=30) :: SHT_rv
        ! splicer begin function.get_char_ptr2
        call c_get_char_ptr2_cfi(SHT_rv)
        ! splicer end function.get_char_ptr2
    end function get_char_ptr2
    ! end get_char_ptr2

    ! Generated by arg_to_cfi - arg_to_cfi
    ! ----------------------------------------
    ! Function:  void getCharPtr3
    ! Attrs:     +intent(subroutine)
    ! Exact:     f_subroutine
    ! Attrs:     +intent(subroutine)
    ! Exact:     c_subroutine
    ! ----------------------------------------
    ! Argument:  char * output
    ! Attrs:     +api(cfi)+deref(result)+intent(out)+is_result
    ! Requested: f_function_char_*_cfi_result
    ! Match:     f_function_char_*_cfi
    ! Attrs:     +api(cfi)+deref(result)+intent(out)+is_result
    ! Requested: c_function_char_*_cfi_result
    ! Match:     c_function_char_*_cfi
    !>
    !! \brief return a 'const char *' as argument
    !!
    !<
    ! start get_char_ptr3
    subroutine get_char_ptr3(output)
        character(len=*), intent(OUT) :: output
        ! splicer begin function.get_char_ptr3
        call c_get_char_ptr3_cfi(output)
        ! splicer end function.get_char_ptr3
    end subroutine get_char_ptr3
    ! end get_char_ptr3

#ifdef HAVE_CHARACTER_POINTER_FUNCTION
    ! Generated by arg_to_cfi
    ! ----------------------------------------
    ! Function:  const char * getCharPtr5 +deref(pointer)
    ! Attrs:     +deref(pointer)+intent(function)
    ! Exact:     f_function_char_*_cfi_pointer
    ! Attrs:     +api(cfi)+deref(pointer)+intent(function)
    ! Exact:     c_function_char_*_cfi_pointer
    !>
    !! \brief return a 'const char *' as character(:) pointer
    !!
    !<
    function get_char_ptr5() &
            result(SHT_rv)
        character(len=:), pointer :: SHT_rv
        ! splicer begin function.get_char_ptr5
        call c_get_char_ptr5_cfi(SHT_rv)
        ! splicer end function.get_char_ptr5
    end function get_char_ptr5
#endif

    ! Generated by arg_to_cfi
    ! ----------------------------------------
    ! Function:  const string getConstStringResult
    ! Attrs:     +deref(allocatable)+intent(function)
    ! Exact:     f_function_string_scalar_cfi_allocatable
    ! Attrs:     +api(cfi)+deref(allocatable)+intent(function)
    ! Exact:     c_function_string_scalar_cfi_allocatable
    !>
    !! \brief return an ALLOCATABLE CHARACTER from std::string
    !!
    !<
    function get_const_string_result() &
            result(SHT_rv)
        character(len=:), allocatable :: SHT_rv
        ! splicer begin function.get_const_string_result
        call c_get_const_string_result_cfi(SHT_rv)
        ! splicer end function.get_const_string_result
    end function get_const_string_result

    ! Generated by arg_to_cfi
    ! ----------------------------------------
    ! Function:  const string getConstStringLen +len(30)
    ! Attrs:     +deref(copy)+intent(function)
    ! Requested: f_function_string_scalar_cfi_copy
    ! Match:     f_function_string_scalar_cfi
    ! Attrs:     +api(cfi)+deref(copy)+intent(function)
    ! Requested: c_function_string_scalar_cfi_copy
    ! Match:     c_function_string_scalar_cfi
    !>
    !! \brief return a 'const string' as argument
    !!
    !<
    function get_const_string_len() &
            result(SHT_rv)
        character(len=30) :: SHT_rv
        ! splicer begin function.get_const_string_len
        call c_get_const_string_len_cfi(SHT_rv)
        ! splicer end function.get_const_string_len
    end function get_const_string_len

    ! Generated by arg_to_cfi - arg_to_cfi
    ! ----------------------------------------
    ! Function:  void getConstStringAsArg
    ! Attrs:     +intent(subroutine)
    ! Exact:     f_subroutine
    ! Attrs:     +intent(subroutine)
    ! Exact:     c_subroutine
    ! ----------------------------------------
    ! Argument:  string * output
    ! Attrs:     +api(cfi)+deref(result)+intent(out)+is_result
    ! Requested: f_function_string_*_cfi_result
    ! Match:     f_function_string_*_cfi
    ! Attrs:     +api(cfi)+deref(result)+intent(out)+is_result
    ! Requested: c_function_string_*_cfi_result
    ! Match:     c_function_string_*_cfi
    !>
    !! \brief return a 'const string' as argument
    !!
    !<
    subroutine get_const_string_as_arg(output)
        character(len=*), intent(OUT) :: output
        ! splicer begin function.get_const_string_as_arg
        call c_get_const_string_as_arg_cfi(output)
        ! splicer end function.get_const_string_as_arg
    end subroutine get_const_string_as_arg

    ! Generated by arg_to_cfi
    ! ----------------------------------------
    ! Function:  const std::string getConstStringAlloc
    ! Attrs:     +deref(allocatable)+intent(function)
    ! Exact:     f_function_string_scalar_cfi_allocatable
    ! Attrs:     +api(cfi)+deref(allocatable)+intent(function)
    ! Exact:     c_function_string_scalar_cfi_allocatable
    function get_const_string_alloc() &
            result(SHT_rv)
        character(len=:), allocatable :: SHT_rv
        ! splicer begin function.get_const_string_alloc
        call c_get_const_string_alloc_cfi(SHT_rv)
        ! splicer end function.get_const_string_alloc
    end function get_const_string_alloc

    ! Generated by arg_to_cfi
    ! ----------------------------------------
    ! Function:  const string & getConstStringRefPure
    ! Attrs:     +deref(allocatable)+intent(function)
    ! Exact:     f_function_string_&_cfi_allocatable
    ! Attrs:     +api(cfi)+deref(allocatable)+intent(function)
    ! Exact:     c_function_string_&_cfi_allocatable
    !>
    !! \brief return a 'const string&' as ALLOCATABLE character
    !!
    !<
    ! start get_const_string_ref_pure
    function get_const_string_ref_pure() &
            result(SHT_rv)
        character(len=:), allocatable :: SHT_rv
        ! splicer begin function.get_const_string_ref_pure
        call c_get_const_string_ref_pure_cfi(SHT_rv)
        ! splicer end function.get_const_string_ref_pure
    end function get_const_string_ref_pure
    ! end get_const_string_ref_pure

    ! Generated by arg_to_cfi
    ! ----------------------------------------
    ! Function:  const string & getConstStringRefLen +len(30)
    ! Attrs:     +deref(copy)+intent(function)
    ! Requested: f_function_string_&_cfi_copy
    ! Match:     f_function_string_&_cfi
    ! Attrs:     +api(cfi)+deref(copy)+intent(function)
    ! Requested: c_function_string_&_cfi_copy
    ! Match:     c_function_string_&_cfi
    !>
    !! \brief return 'const string&' with fixed size (len=30)
    !!
    !! Since +len(30) is provided, the result of the function
    !! will be copied directly into memory provided by Fortran.
    !! The function will not be ALLOCATABLE.
    !<
    function get_const_string_ref_len() &
            result(SHT_rv)
        character(len=30) :: SHT_rv
        ! splicer begin function.get_const_string_ref_len
        call c_get_const_string_ref_len_cfi(SHT_rv)
        ! splicer end function.get_const_string_ref_len
    end function get_const_string_ref_len

    ! Generated by arg_to_cfi - arg_to_cfi
    ! ----------------------------------------
    ! Function:  void getConstStringRefAsArg
    ! Attrs:     +intent(subroutine)
    ! Exact:     f_subroutine
    ! Attrs:     +intent(subroutine)
    ! Exact:     c_subroutine
    ! ----------------------------------------
    ! Argument:  string & output
    ! Attrs:     +api(cfi)+deref(result)+intent(out)+is_result
    ! Requested: f_function_string_&_cfi_result
    ! Match:     f_function_string_&_cfi
    ! Attrs:     +api(cfi)+deref(result)+intent(out)+is_result
    ! Requested: c_function_string_&_cfi_result
    ! Match:     c_function_string_&_cfi
    !>
    !! \brief return a 'const string&' as argument
    !!
    !! Pass an additional argument which will be used as the return value.
    !! The length of the output variable is declared by the caller.
    !<
    subroutine get_const_string_ref_as_arg(output)
        character(len=*), intent(OUT) :: output
        ! splicer begin function.get_const_string_ref_as_arg
        call c_get_const_string_ref_as_arg_cfi(output)
        ! splicer end function.get_const_string_ref_as_arg
    end subroutine get_const_string_ref_as_arg

    ! Generated by arg_to_cfi
    ! ----------------------------------------
    ! Function:  const string & getConstStringRefLenEmpty +len(30)
    ! Attrs:     +deref(copy)+intent(function)
    ! Requested: f_function_string_&_cfi_copy
    ! Match:     f_function_string_&_cfi
    ! Attrs:     +api(cfi)+deref(copy)+intent(function)
    ! Requested: c_function_string_&_cfi_copy
    ! Match:     c_function_string_&_cfi
    !>
    !! \brief Test returning empty string reference
    !!
    !<
    function get_const_string_ref_len_empty() &
            result(SHT_rv)
        character(len=30) :: SHT_rv
        ! splicer begin function.get_const_string_ref_len_empty
        call c_get_const_string_ref_len_empty_cfi(SHT_rv)
        ! splicer end function.get_const_string_ref_len_empty
    end function get_const_string_ref_len_empty

    ! Generated by arg_to_cfi
    ! ----------------------------------------
    ! Function:  const std::string & getConstStringRefAlloc
    ! Attrs:     +deref(allocatable)+intent(function)
    ! Exact:     f_function_string_&_cfi_allocatable
    ! Attrs:     +api(cfi)+deref(allocatable)+intent(function)
    ! Exact:     c_function_string_&_cfi_allocatable
    function get_const_string_ref_alloc() &
            result(SHT_rv)
        character(len=:), allocatable :: SHT_rv
        ! splicer begin function.get_const_string_ref_alloc
        call c_get_const_string_ref_alloc_cfi(SHT_rv)
        ! splicer end function.get_const_string_ref_alloc
    end function get_const_string_ref_alloc

    ! Generated by arg_to_cfi
    ! ----------------------------------------
    ! Function:  const string * getConstStringPtrLen +len(30)
    ! Attrs:     +deref(copy)+intent(function)
    ! Requested: f_function_string_*_cfi_copy
    ! Match:     f_function_string_*_cfi
    ! Attrs:     +api(cfi)+deref(copy)+intent(function)
    ! Requested: c_function_string_*_cfi_copy
    ! Match:     c_function_string_*_cfi
    !>
    !! \brief return a 'const string *' as character(30)
    !!
    !! It is the caller's responsibility to release the string
    !! created by the C++ library.
    !! This is accomplished with C_finalize_buf which is possible
    !! because +len(30) so the contents are copied before returning.
    !<
    function get_const_string_ptr_len() &
            result(SHT_rv)
        character(len=30) :: SHT_rv
        ! splicer begin function.get_const_string_ptr_len
        call c_get_const_string_ptr_len_cfi(SHT_rv)
        ! splicer end function.get_const_string_ptr_len
    end function get_const_string_ptr_len

    ! Generated by arg_to_cfi
    ! ----------------------------------------
    ! Function:  const std::string * getConstStringPtrAlloc +owner(library)
    ! Attrs:     +deref(allocatable)+intent(function)
    ! Requested: f_function_string_*_cfi_allocatable_library
    ! Match:     f_function_string_*_cfi_allocatable
    ! Attrs:     +api(cfi)+deref(allocatable)+intent(function)
    ! Exact:     c_function_string_*_cfi_allocatable
    function get_const_string_ptr_alloc() &
            result(SHT_rv)
        character(len=:), allocatable :: SHT_rv
        ! splicer begin function.get_const_string_ptr_alloc
        call c_get_const_string_ptr_alloc_cfi(SHT_rv)
        ! splicer end function.get_const_string_ptr_alloc
    end function get_const_string_ptr_alloc

    ! Generated by arg_to_cfi
    ! ----------------------------------------
    ! Function:  const std::string * getConstStringPtrOwnsAlloc +owner(caller)
    ! Attrs:     +deref(allocatable)+intent(function)
    ! Requested: f_function_string_*_cfi_allocatable_caller
    ! Match:     f_function_string_*_cfi_allocatable
    ! Attrs:     +api(cfi)+deref(allocatable)+intent(function)
    ! Exact:     c_function_string_*_cfi_allocatable
    !>
    !! It is the caller's responsibility to release the string
    !! created by the C++ library.
    !! This is accomplished +owner(caller) which sets idtor.
    !! The contents are copied by Fortran so they must outlast
    !! the return from the C wrapper.
    !<
    function get_const_string_ptr_owns_alloc() &
            result(SHT_rv)
        character(len=:), allocatable :: SHT_rv
        ! splicer begin function.get_const_string_ptr_owns_alloc
        call c_get_const_string_ptr_owns_alloc_cfi(SHT_rv)
        ! splicer end function.get_const_string_ptr_owns_alloc
    end function get_const_string_ptr_owns_alloc

    ! Generated by arg_to_cfi
    ! ----------------------------------------
    ! Function:  const std::string * getConstStringPtrOwnsAllocPattern +free_pattern(C_string_free)+owner(caller)
    ! Attrs:     +deref(allocatable)+intent(function)
    ! Requested: f_function_string_*_cfi_allocatable_caller
    ! Match:     f_function_string_*_cfi_allocatable
    ! Attrs:     +api(cfi)+deref(allocatable)+intent(function)
    ! Exact:     c_function_string_*_cfi_allocatable
    !>
    !! Similar to getConstStringPtrOwnsAlloc, but uses pattern to release memory.
    !<
    function get_const_string_ptr_owns_alloc_pattern() &
            result(SHT_rv)
        character(len=:), allocatable :: SHT_rv
        ! splicer begin function.get_const_string_ptr_owns_alloc_pattern
        call c_get_const_string_ptr_owns_alloc_pattern_cfi(SHT_rv)
        ! splicer end function.get_const_string_ptr_owns_alloc_pattern
    end function get_const_string_ptr_owns_alloc_pattern

#ifdef HAVE_CHARACTER_POINTER_FUNCTION
    ! Generated by arg_to_cfi
    ! ----------------------------------------
    ! Function:  const std::string * getConstStringPtrPointer +deref(pointer)+owner(library)
    ! Attrs:     +deref(pointer)+intent(function)
    ! Requested: f_function_string_*_cfi_pointer_library
    ! Match:     f_function_string_*_cfi_pointer
    ! Attrs:     +api(cfi)+deref(pointer)+intent(function)
    ! Exact:     c_function_string_*_cfi_pointer
    function get_const_string_ptr_pointer() &
            result(SHT_rv)
        character(len=:), pointer :: SHT_rv
        ! splicer begin function.get_const_string_ptr_pointer
        call c_get_const_string_ptr_pointer_cfi(SHT_rv)
        ! splicer end function.get_const_string_ptr_pointer
    end function get_const_string_ptr_pointer
#endif

    ! ----------------------------------------
    ! Function:  char CreturnChar
    ! Attrs:     +intent(function)
    ! Exact:     f_function_char_scalar
    ! Attrs:     +intent(function)
    ! Exact:     c_function_char_scalar
    !>
    !! \brief return a char argument (non-pointer), extern "C"
    !!
    !<
    function creturn_char() &
            result(SHT_rv)
        character :: SHT_rv
        ! splicer begin function.creturn_char
        call c_creturn_char(SHT_rv)
        ! splicer end function.creturn_char
    end function creturn_char

    ! splicer begin additional_functions
    ! splicer end additional_functions

end module strings_mod

max_stars_repo_name: ExternalRepositories/shroud

max_issues_repo_name: ExternalRepositories/shroud

max_forks_repo_name: ExternalRepositories/shroud


text:
      vlib work

     vlog ../rtl/spi_slave/spi_if.sv
     vlog ../rtl/spi_slave/spi_slave.sv
     vlog ../rtl/spi_slave/spi_slave_wb_master_top.sv

     vlog ../rtl/wishbone/wb_if.sv

      vlog ../rtl/top.sv +incdir+../simulation +incdir+../rtl/bus_matrix/ +incdir+../testbench

      vlog ../rtl/syscon/syscon.sv +define+SIM

      vlog ../behavioral/wb_uart/raminfr.v
      vlog ../behavioral/wb_uart/uart_debug_if.v
      vlog ../behavioral/wb_uart/uart_receiver.v
      vlog ../behavioral/wb_uart/uart_regs.v
      vlog ../behavioral/wb_uart/uart_rfifo.v
      vlog ../behavioral/wb_uart/uart_sync_flops.v
      vlog ../behavioral/wb_uart/uart_tfifo.v
      vlog ../behavioral/wb_uart/uart_top.v
      vlog ../behavioral/wb_uart/uart_transmitter.v
      vlog ../behavioral/wb_uart/uart_wb.v

      vlog ../behavioral/wb_spi/rtl/verilog/spi_clgen.v +incdir+../behavioral/wb_spi
      vlog ../behavioral/wb_spi/rtl/verilog/spi_shift.v +incdir+../behavioral/wb_spi
      vlog ../behavioral/wb_spi/rtl/verilog/spi_top.v +incdir+../behavioral/wb_spi

      vlog ../behavioral/wb_master/wb_mast_model.v
      vlog ../behavioral/wb_intercon/wb_arbiter.v  +incdir+../behavioral/
      vlog ../behavioral/wb_intercon/wb_data_resize.v
      vlog ../behavioral/wb_intercon/wb_mux.v  +incdir+../behavioral/

      vlog ../testbench/testbench.v +incdir+../simulation
      vlog ../testbench/test_tasks.v +incdir+../simulation
      vlog ../testbench/uart_tasks.v  +incdir+../simulation  +incdir+../testbench
      vlog ../testbench/spi_tasks.v  +incdir+../simulation  +incdir+../testbench  +define+MODELSIM

      vsim -voptargs=+acc work.testbench +define+RTL +define+SIM
#     do wave.do
      run -all

ext: f


text:
module funmod2

contains

subroutine matout(A,m,n)
integer :: i,m,n
double precision :: A(m,n)
do i = 1,m
   print "(10f16.8)", A(i,:); call flush(6)
end do
end subroutine matout

subroutine bytes_in_rec( bytes )
  implicit none
  integer     bytes

  character*8 string
  integer     i
  integer     ierr
  double precision d;
  real r;

  d = dble(1.0);
  r = 1.0;
  bytes = 0
  do i = 1,8
     !open(unit=15,file='/home/jason/tmpbytetst',access='direct',recl=i)
     open(unit=15,status='scratch',access='direct',recl=i)
     write(15,rec=1,iostat=ierr) r
     close(15, status='delete')
     !print *, 'i = ', i, ' real ierr = ', ierr
     if (ierr == 0) then
           bytes = i
           exit
     end if
     !open(unit=16,file='/home/jason/tmpbytetst2',access='direct',recl=i)
     !write(16,rec=1,iostat=ierr) d
     !close(16, status='delete')
     !print *, 'i = ', i, ' double ierr = ', ierr
  end do
  print *, 'bytes in real = ', bytes
  !open( 10, status = 'scratch', access = 'direct', recl = 1 )
  !write( 10,rec=1,iostat=ierr) d

  !do i = 1,8
  !   write( 10, rec = 1, iostat = ierr ) string(1:i)
  !   print *, 'i = ', i, ' ierr = ', ierr
  !   if ( ierr /= 0 ) exit
  !   bytes = i
  !end do
  !close( 10, status = 'delete' )

end subroutine bytes_in_rec

!--------------------------------------------------------------------------------------
! The following gamma/psi code was obtained from Alan Miller's Fortran Software website.

FUNCTION gamln (a) RESULT(fn_val)
!-----------------------------------------------------------------------
!            EVALUATION OF LN(GAMMA(A)) FOR POSITIVE A
!-----------------------------------------------------------------------
!     WRITTEN BY ALFRED H. MORRIS
!          NAVAL SURFACE WARFARE CENTER
!          DAHLGREN, VIRGINIA
!--------------------------
!     D = 0.5*(LN(2*PI) - 1)
!--------------------------
IMPLICIT NONE
double precision, INTENT(IN) :: a
double precision             :: fn_val

double precision :: c0 = .833333333333333D-01, c1 = -.277777777760991D-02,  &
             c2 = .793650666825390D-03, c3 = -.595202931351870D-03,  &
             c4 = .837308034031215D-03, c5 = -.165322962780713D-02,  &
             d = .418938533204673D0, t, w
INTEGER   :: i, n
!--------------------------
IF (a > 0.8D0) GO TO 10
fn_val = gamln1(a) - LOG(a)
RETURN
10 IF (a > 2.25D0) GO TO 20
t = (a - 0.5D0) - 0.5D0
fn_val = gamln1(t)
RETURN

20 IF (a >= 10.0D0) GO TO 30
n = a - 1.25D0
t = a
w = 1.0D0
DO i = 1, n
  t = t - 1.0D0
  w = t*w
END DO
fn_val = gamln1(t - 1.0D0) + LOG(w)
RETURN

30 t = (1.0D0/a)**2
w = (((((c5*t + c4)*t + c3)*t + c2)*t + c1)*t + c0)/a
fn_val = (d + w) + (a - 0.5D0)*(LOG(a) - 1.0D0)

RETURN
END FUNCTION gamln

FUNCTION gamln1 (a) RESULT(fn_val)
!-----------------------------------------------------------------------
!     EVALUATION OF LN(GAMMA(1 + A)) FOR -0.2 .LE. A .LE. 1.25
!-----------------------------------------------------------------------
IMPLICIT NONE
double precision, INTENT(IN) :: a
double precision             :: fn_val

double precision :: w, x, &
             p0 =  .577215664901533D+00, p1 =  .844203922187225D+00,  &
             p2 = -.168860593646662D+00, p3 = -.780427615533591D+00,  &
             p4 = -.402055799310489D+00, p5 = -.673562214325671D-01,  &
             p6 = -.271935708322958D-02,   &
             q1 =  .288743195473681D+01, q2 =  .312755088914843D+01,  &
             q3 =  .156875193295039D+01, q4 =  .361951990101499D+00,  &
             q5 =  .325038868253937D-01, q6 =  .667465618796164D-03,  &
             r0 = .422784335098467D+00,  r1 = .848044614534529D+00,  &
             r2 = .565221050691933D+00,  r3 = .156513060486551D+00,  &
             r4 = .170502484022650D-01,  r5 = .497958207639485D-03,  &
             s1 = .124313399877507D+01,  s2 = .548042109832463D+00,  &
             s3 = .101552187439830D+00,  s4 = .713309612391000D-02,  &
             s5 = .116165475989616D-03
!----------------------
IF (a >= 0.6D0) GO TO 10
w = ((((((p6*a + p5)*a + p4)*a + p3)*a + p2)*a + p1)*a + p0)/  &
    ((((((q6*a + q5)*a + q4)*a + q3)*a + q2)*a + q1)*a + 1.0D0)
fn_val = -a*w
RETURN

10 x = (a - 0.5D0) - 0.5D0
w = (((((r5*x + r4)*x + r3)*x + r2)*x + r1)*x + r0)/  &
    (((((s5*x + s4)*x + s3)*x + s2)*x + s1)*x + 1.0D0)
fn_val = x*w
RETURN
END FUNCTION gamln1

!-----------------------------------------------------------------------

FUNCTION psifun(xx) RESULT(fn_val)
!---------------------------------------------------------------------

!                 EVALUATION OF THE DIGAMMA FUNCTION

!                           -----------

!     PSIFUN(XX) IS ASSIGNED THE VALUE 0 WHEN THE DIGAMMA FUNCTION CANNOT
!     BE COMPUTED.

!     THE MAIN COMPUTATION INVOLVES EVALUATION OF RATIONAL CHEBYSHEV
!     APPROXIMATIONS PUBLISHED IN MATH. COMP. 27, 123-127(1973) BY
!     CODY, STRECOK AND THACHER.

!---------------------------------------------------------------------
!     PSIFUN WAS WRITTEN AT ARGONNE NATIONAL LABORATORY FOR THE FUNPACK
!     PACKAGE OF SPECIAL FUNCTION SUBROUTINES. PSIFUN WAS MODIFIED BY
!     A.H. MORRIS (NSWC).
!---------------------------------------------------------------------
IMPLICIT NONE
double precision, INTENT(IN) :: xx
double precision             :: fn_val

double precision :: dx0 = 1.461632144968362341262659542325721325D0
!---------------------------------------------------------------------

!     PIOV4 = PI/4
!     DX0 = ZERO OF PSIFUN TO EXTENDED PRECISION

!---------------------------------------------------------------------
double precision :: aug, den, piov4 = .785398163397448D0, sgn, upper,  &
             w, x, xmax1, xmx0, xsmall, z
INTEGER   :: i, m, n, nq
!---------------------------------------------------------------------

!     COEFFICIENTS FOR RATIONAL APPROXIMATION OF
!     PSIFUN(X) / (X - X0),  0.5 <= X <= 3.0

!---------------------------------------------------------------------
double precision :: p1(7) = (/ .895385022981970D-02, .477762828042627D+01,  &
                        .142441585084029D+03, .118645200713425D+04,  &
                        .363351846806499D+04, .413810161269013D+04,  &
                        .130560269827897D+04 /),   &
             q1(6) = (/ .448452573429826D+02, .520752771467162D+03,  &
                        .221000799247830D+04, .364127349079381D+04,  &
                        .190831076596300D+04, .691091682714533D-05 /)
!---------------------------------------------------------------------

!     COEFFICIENTS FOR RATIONAL APPROXIMATION OF
!     PSIFUN(X) - LN(X) + 1 / (2*X),  X > 3.0

!---------------------------------------------------------------------
double precision :: p2(4) = (/ -.212940445131011D+01, -.701677227766759D+01,  &
                        -.448616543918019D+01, -.648157123766197D+00 /), &
             q2(4) = (/  .322703493791143D+02,  .892920700481861D+02,  &
                         .546117738103215D+02,  .777788548522962D+01 /)
!---------------------------------------------------------------------

!     MACHINE DEPENDENT CONSTANTS ...

!        XMAX1  = THE SMALLEST POSITIVE FLOATING POINT CONSTANT
!                 WITH ENTIRELY INTEGER REPRESENTATION.  ALSO USED
!                 AS NEGATIVE OF LOWER BOUND ON ACCEPTABLE NEGATIVE
!                 ARGUMENTS AND AS THE POSITIVE ARGUMENT BEYOND WHICH
!                 PSIFUN MAY BE REPRESENTED AS ALOG(X).

!        XSMALL = ABSOLUTE ARGUMENT BELOW WHICH PI*COTAN(PI*X)
!                 MAY BE REPRESENTED BY 1/X.

!---------------------------------------------------------------------
xmax1 = ipmpar(3)
xmax1 = MIN(xmax1, 1.0D0/dpmpar(1))
xsmall = 1.d-9
!---------------------------------------------------------------------
x = xx
aug = 0.0D0
IF (x >= 0.5D0) GO TO 200
!---------------------------------------------------------------------
!     X .LT. 0.5,  USE REFLECTION FORMULA
!     PSIFUN(1-X) = PSI(X) + PI * COTAN(PI*X)
!---------------------------------------------------------------------
IF (ABS(x) > xsmall) GO TO 100
IF (x == 0.0D0) GO TO 400
!---------------------------------------------------------------------
!     0 .LT. ABS(X) .LE. XSMALL.  USE 1/X AS A SUBSTITUTE
!     FOR  PI*COTAN(PI*X)
!---------------------------------------------------------------------
aug = -1.0D0 / x
GO TO 150
!---------------------------------------------------------------------
!     REDUCTION OF ARGUMENT FOR COTAN
!---------------------------------------------------------------------
100 w = - x
sgn = piov4
IF (w > 0.0D0) GO TO 120
w = - w
sgn = -sgn
!---------------------------------------------------------------------
!     MAKE AN ERROR EXIT IF X .LE. -XMAX1
!---------------------------------------------------------------------
120 IF (w >= xmax1) GO TO 400
nq = INT(w)
w = w - nq
nq = INT(w*4.0D0)
w = 4.0D0 * (w - nq * .25D0)
!---------------------------------------------------------------------
!     W IS NOW RELATED TO THE FRACTIONAL PART OF  4.0 * X.
!     ADJUST ARGUMENT TO CORRESPOND TO VALUES IN FIRST
!     QUADRANT AND DETERMINE SIGN
!---------------------------------------------------------------------
n = nq / 2
IF ((n+n) /= nq) w = 1.0D0 - w
z = piov4 * w
m = n / 2
IF ((m+m) /= n) sgn = - sgn
!---------------------------------------------------------------------
!     DETERMINE FINAL VALUE FOR  -PI*COTAN(PI*X)
!---------------------------------------------------------------------
n = (nq + 1) / 2
m = n / 2
m = m + m
IF (m /= n) GO TO 140
!---------------------------------------------------------------------
!     CHECK FOR SINGULARITY
!---------------------------------------------------------------------
IF (z == 0.0D0) GO TO 400
!---------------------------------------------------------------------
!     USE COS/SIN AS A SUBSTITUTE FOR COTAN, AND
!     SIN/COS AS A SUBSTITUTE FOR TAN
!---------------------------------------------------------------------
aug = sgn * ((COS(z) / SIN(z)) * 4.0D0)
GO TO 150
140 aug = sgn * ((SIN(z) / COS(z)) * 4.0D0)
150 x = 1.0D0 - x
200 IF (x > 3.0D0) GO TO 300
!---------------------------------------------------------------------
!     0.5 .LE. X .LE. 3.0
!---------------------------------------------------------------------
den = x
upper = p1(1) * x

DO i = 1, 5
  den = (den + q1(i)) * x
  upper = (upper + p1(i+1)) * x
END DO

den = (upper + p1(7)) / (den + q1(6))
xmx0 = x - dx0
fn_val = den * xmx0 + aug
RETURN
!---------------------------------------------------------------------
!     IF X .GE. XMAX1, PSIFUN = LN(X)
!---------------------------------------------------------------------
300 IF (x >= xmax1) GO TO 350
!---------------------------------------------------------------------
!     3.0 .LT. X .LT. XMAX1
!---------------------------------------------------------------------
w = 1.0D0 / (x * x)
den = w
upper = p2(1) * w

DO i = 1, 3
  den = (den + q2(i)) * w
  upper = (upper + p2(i+1)) * w
END DO

aug = upper / (den + q2(4)) - 0.5D0 / x + aug
350 fn_val = aug + LOG(x)
RETURN
!---------------------------------------------------------------------
!     ERROR RETURN
!---------------------------------------------------------------------
400 fn_val = 0.0D0
RETURN
END FUNCTION psifun

FUNCTION ipmpar (i) RESULT(fn_val)
!-----------------------------------------------------------------------

!     IPMPAR PROVIDES THE INTEGER MACHINE CONSTANTS FOR THE COMPUTER
!     THAT IS USED. IT IS ASSUMED THAT THE ARGUMENT I IS AN INTEGER
!     HAVING ONE OF THE VALUES 1-10. IPMPAR(I) HAS THE VALUE ...

!  INTEGERS.

!     ASSUME INTEGERS ARE REPRESENTED IN THE N-DIGIT, BASE-A FORM

!               SIGN ( X(N-1)*A**(N-1) + ... + X(1)*A + X(0) )

!               WHERE 0 .LE. X(I) .LT. A FOR I=0,...,N-1.

!     IPMPAR(1) = A, THE BASE (radix).

!     IPMPAR(2) = N, THE NUMBER OF BASE-A DIGITS (digits).

!     IPMPAR(3) = A**N - 1, THE LARGEST MAGNITUDE (huge).

!  FLOATING-POINT NUMBERS.

!     IT IS ASSUMED THAT THE SINGLE AND DOUBLE PRECISION FLOATING
!     POINT ARITHMETICS HAVE THE SAME BASE, SAY B, AND THAT THE
!     NONZERO NUMBERS ARE REPRESENTED IN THE FORM

!               SIGN (B**E) * (X(1)/B + ... + X(M)/B**M)

!               WHERE X(I) = 0,1,...,B-1 FOR I=1,...,M,
!               X(1) .GE. 1, AND EMIN .LE. E .LE. EMAX.

!     IPMPAR(4) = B, THE BASE.

!  SINGLE-PRECISION

!     IPMPAR(5) = M, THE NUMBER OF BASE-B DIGITS.

!     IPMPAR(6) = EMIN, THE SMALLEST EXPONENT E.

!     IPMPAR(7) = EMAX, THE LARGEST EXPONENT E.

!  DOUBLE-PRECISION

!     IPMPAR(8) = M, THE NUMBER OF BASE-B DIGITS.

!     IPMPAR(9) = EMIN, THE SMALLEST EXPONENT E.

!     IPMPAR(10) = EMAX, THE LARGEST EXPONENT E.

!-----------------------------------------------------------------------

IMPLICIT NONE
INTEGER, INTENT(IN) :: i
INTEGER             :: fn_val

SELECT CASE(i)
  CASE( 1)
    fn_val = RADIX(i)
  CASE( 2)
    fn_val = DIGITS(i)
  CASE( 3)
    fn_val = HUGE(i)
  CASE( 4)
    fn_val = RADIX(1.0)
  CASE( 5)
    fn_val = DIGITS(1.0)
  CASE( 6)
    fn_val = MINEXPONENT(1.0)
  CASE( 7)
    fn_val = MAXEXPONENT(1.0)
  CASE( 8)
    fn_val = DIGITS(1.0D0)
  CASE( 9)
    fn_val = MINEXPONENT(1.0D0)
  CASE(10)
    fn_val = MAXEXPONENT(1.0D0)
  CASE DEFAULT
    RETURN
END SELECT

RETURN
END FUNCTION ipmpar

FUNCTION spmpar (i) RESULT(fn_val)
!-----------------------------------------------------------------------

!     SPMPAR PROVIDES THE SINGLE PRECISION MACHINE CONSTANTS FOR
!     THE COMPUTER BEING USED. IT IS ASSUMED THAT THE ARGUMENT
!     I IS AN INTEGER HAVING ONE OF THE VALUES 1, 2, OR 3. IF THE
!     SINGLE PRECISION ARITHMETIC BEING USED HAS M BASE B DIGITS AND
!     ITS SMALLEST AND LARGEST EXPONENTS ARE EMIN AND EMAX, THEN

!        SPMPAR(1) = B**(1 - M), THE MACHINE PRECISION,

!        SPMPAR(2) = B**(EMIN - 1), THE SMALLEST MAGNITUDE,

!        SPMPAR(3) = B**EMAX*(1 - B**(-M)), THE LARGEST MAGNITUDE.
!-----------------------------------------------------------------------

IMPLICIT NONE
INTEGER, INTENT(IN) :: i
double precision    :: fn_val

! Local variable
double precision                :: one = 1.0

SELECT CASE (i)
  CASE (1)
    fn_val = EPSILON(one)
  CASE (2)
    fn_val = TINY(one)
  CASE (3)
    fn_val = HUGE(one)
END SELECT

RETURN
END FUNCTION spmpar

FUNCTION dpmpar (i) RESULT(fn_val)
!-----------------------------------------------------------------------

!     DPMPAR PROVIDES THE DOUBLE PRECISION MACHINE CONSTANTS FOR
!     THE COMPUTER BEING USED. IT IS ASSUMED THAT THE ARGUMENT
!     I IS AN INTEGER HAVING ONE OF THE VALUES 1, 2, OR 3. IF THE
!     DOUBLE PRECISION ARITHMETIC BEING USED HAS M BASE B DIGITS AND
!     ITS SMALLEST AND LARGEST EXPONENTS ARE EMIN AND EMAX, THEN

!        DPMPAR(1) = B**(1 - M), THE MACHINE PRECISION,

!        DPMPAR(2) = B**(EMIN - 1), THE SMALLEST MAGNITUDE,

!        DPMPAR(3) = B**EMAX*(1 - B**(-M)), THE LARGEST MAGNITUDE.
!-----------------------------------------------------------------------

IMPLICIT NONE
INTEGER, INTENT(IN) :: i
double precision           :: fn_val

! Local variable
double precision    :: one = 1.0

SELECT CASE (i)
  CASE (1)
    fn_val = EPSILON(one)
  CASE (2)
    fn_val = TINY(one)
  CASE (3)
    fn_val = HUGE(one)
END SELECT

RETURN
END FUNCTION dpmpar

FUNCTION epsln () RESULT(fn_val)
!--------------------------------------------------------------------
!     THE EVALUATION OF LN(EPS) WHERE EPS IS THE SMALLEST NUMBER
!     SUCH THAT 1.0 + EPS .GT. 1.0 .  L IS A DUMMY ARGUMENT.
!--------------------------------------------------------------------
IMPLICIT NONE
double precision                :: fn_val

! Local variable
double precision                :: one = 1.0

fn_val = LOG( EPSILON(one) )
RETURN
END FUNCTION epsln

FUNCTION exparg (l) RESULT(fn_val)
!--------------------------------------------------------------------
!     IF L = 0 THEN  EXPARG(L) = THE LARGEST POSITIVE W FOR WHICH
!     EXP(W) CAN BE COMPUTED.
!
!     IF L IS NONZERO THEN  EXPARG(L) = THE LARGEST NEGATIVE W FOR
!     WHICH THE COMPUTED VALUE OF EXP(W) IS NONZERO.
!
!     NOTE... ONLY AN APPROXIMATE VALUE FOR EXPARG(L) IS NEEDED.
!--------------------------------------------------------------------
IMPLICIT NONE
INTEGER, INTENT(IN) :: l
double precision                :: fn_val

! Local variable
double precision                :: one = 1.0

IF (l == 0) THEN
  fn_val = LOG( HUGE(one) )
ELSE
  fn_val = LOG( TINY(one) )
END IF
RETURN
END FUNCTION exparg

FUNCTION depsln () RESULT(fn_val)
!--------------------------------------------------------------------
!     THE EVALUATION OF LN(EPS) WHERE EPS IS THE SMALLEST NUMBER
!     SUCH THAT 1.D0 + EPS .GT. 1.D0 .  L IS A DUMMY ARGUMENT.
!--------------------------------------------------------------------
IMPLICIT NONE
double precision           :: fn_val

! Local variable
double precision    :: one = 1.0

fn_val = LOG( EPSILON(one) )
RETURN
END FUNCTION depsln

FUNCTION dxparg (l) RESULT(fn_val)
!--------------------------------------------------------------------
!     IF L = 0 THEN  DXPARG(L) = THE LARGEST POSITIVE W FOR WHICH
!     DEXP(W) CAN BE COMPUTED.
!
!     IF L IS NONZERO THEN  DXPARG(L) = THE LARGEST NEGATIVE W FOR
!     WHICH THE COMPUTED VALUE OF DEXP(W) IS NONZERO.
!
!     NOTE... ONLY AN APPROXIMATE VALUE FOR DXPARG(L) IS NEEDED.
!--------------------------------------------------------------------
IMPLICIT NONE
INTEGER, INTENT(IN) :: l
double precision           :: fn_val

! Local variable
double precision    :: one = 1.0

IF (l == 0) THEN
  fn_val = LOG( HUGE(one) )
ELSE
  fn_val = LOG( TINY(one) )
END IF
RETURN
END FUNCTION dxparg

!----------------------------------------------------------------------
end module funmod2

max_stars_repo_name: vishalbelsare/amica

max_forks_repo_name: sccn/amica


text:
Movies in the Park is a free, outdoor movie series sponsored by Davis Sunset Rotary and Woodland Healthcare  Davis Satellite. The program was formerly run by the Citys Community Services Department, but was cut from the budget in 2011.

The movies start at sunset.

Oriented towards children, with entertainment and food for sale before and during the show (or feel free to bring your own picnic).

 Fall 2014
  August 23: Monsters University
  September 6: Despicable Me 2
  September 13: Frozen
  September 20: The Lego Movie

 Fall 2013
  September 7: Monsters Inc.
  September 14: The Avengers
  September 21: How to Train Your Dragon
  October 5: Up

 Fall 2012
  September 8: http://www.imdb.com/title/tt1323594/ Despicable Me (2010  Steve Carell, Jason Segel)
  September 15: http://www.imdb.com/title/tt0032138/ The Wizard of Oz (1939  Judy Garland, Frank Morgan)
  September 29: http://www.imdb.com/title/tt0088763/ Back to the Future (1985  Michael J. Fox, Christopher Lloyd)
  October 6: http://www.imdb.com/title/tt0126029/ Shrek (2001  Mike Myers, Eddie Murphy)

 Fall 2011
  September 24: http://www.imdb.com/title/tt0114709/ Toy Story (1995  Tom Hanks, Tim Allen)
  October 8: http://www.imdb.com/title/tt0082971/ Raiders of the Lost Ark (1981  Harrison Ford, Karen Allen)
  October 15: http://www.imdb.com/title/tt0241527/ Harry Potter and the Sorcerers Stone (2001  Daniel Radcliffe, Emma Watson)

 Fall 2009
  October 3: http://www.imdb.com/title/tt0351283/ Madagascar (2005  Ben Stiller, Chris Rock)
  October 10: http://www.imdb.com/title/tt0366548/ Happy Feet (2006  Robin Williams, Hugh Jackman)
  October 17: http://www.imdb.com/title/tt0107614/ Mrs. Doubtfire (1993  Robin Williams, Sally Field)

 Fall 2008
  September 13: http://www.imdb.com/title/tt0094737/ Big (1988  Tom Hanks)
  September 27: http://www.imdb.com/title/tt0097351/ Field of Dreams (1989  Kevin Costner)
  October 11: http://www.imdb.com/title/tt0298148/ Shrek 2 (2004  Mike Myers, Eddie Murphy, Cameron Diaz, Julie Andrews, Antonio Banderas, John Cleese)

 Spring 2008
  May 17: http://www.imdb.com/title/tt0128853/ Youve Got Mail (1998  Tom Hanks, Meg Ryan)

 Spring 2007
  May 19: http://www.imdb.com/title/tt0108160/ Sleepless in Seattle (1993  Tom Hanks, Meg Ryan, Bill Pullman)

 Fall 2006
  Sep 16: http://www.imdb.com/title/tt0087332/ Ghost Busters (1984  Dan Ackroyd, Bill Murray, Signorney Weaver)
  Sep 30: http://www.imdb.com/title/tt0088763/ Back to the Future (1985  Michael J. Fox, Christopher Lloyd)
  Oct 14: http://www.imdb.com/title/tt0059742/ The Sound of Music (1965  Julie Andrews)

 Spring 2006
  May 6: http://www.imdb.com/title/tt0093779/ The Princess Bride (1987, Cary Elwes & Robin Wright Penn)
  May 13: http://www.imdb.com/title/tt0067992/ Willy Wonka & the Chocolate Factory (1971 version, with Gene Wilder)
  May 20: http://www.imdb.com/title/tt0112431/ Babe, the Gallant Pig (1995)

20060507 18:42:10 nbsp I went to see the Princess bride last night.  They had a giant inflatable screen set up, which they projected the movie on.  One good idea is that they segregated the lawn into 3 sections  those with blankets up front, those with beach chairs in the middle, and those with tall chairs in the back.  There were, of course, a ton of kids there, but there were also a lot of couples, people with dogs, and adults.  The kids were mostly well behaved.  There was also several food booths there: the Hotdogger, Kathmandu Kitchen, Baskin Robbins, and Woodstocks (I think).  Overall, a fun experience! Users/AlexPomeranz

20060507 18:43:00 nbsp Go to Movies in the Park for a cheap date and a good time.  Be forewarned: the mosquitoes are out by sunset, and they are ravenous. Users/AllisonEriksen

20080926 09:18:27 nbsp Definitely fun for a cheap (potentially free) date idea. The sound could be a little louder maybe, but I was towards the back. There is subtitles though. All in all, an enjoyable experience. Users/Lala

max_stars_repo_name: voflo/Search

max_issues_repo_name: voflo/Search

max_forks_repo_name: voflo/Search


text:
      SUBROUTINE PEG_WRITEALL_HEADER( FPDBSP, SPDBSP, SAMPLE,
     &		    		   CVECT, PERPVE, PERPVN,
     &				   CONNR, ENDRAD )
      IMPLICIT NONE
C ********************************************************************
C *                                                                  *
C * This software is an unpublished work containing confidential and *
C * proprietary information of Oliver Smart. Use, disclosure,    *
C * reproduction and transfer of this work without the express       *
C * written consent of Oliver Smart are prohibited. This notice  *
C * must be attached to all copies or extracts of the software.      *
C *                                                                  *
C * (c) 2000 Oliver Smart *
C *                                                                  *
C ********************************************************************
C
C s/r to perform connolly type surface calc within hole
C
C Modification history:
C
C Date  Author          Modification
C 11/00 O.S.S.		First version
C
C This s/r writes out the cvect etc that are are needed for the
C forpeg calculation

C pdb format output file 'atoms' are sphere centres
C default to none by setting FPDBSP to 'NONE'
      CHARACTER*200             FPDBSP
      INTEGER                   SPDBSP

C a sampling distance - the distance between planes
      DOUBLE PRECISION          SAMPLE

C a vector in the direction of the channel
      DOUBLE PRECISION          CVECT(3)

C unit vectors in plane normal to cvect
C needed to a number of routines - originally h2dmap but now conn
C and addend
C these are normal - first is east direction (x on plane)
C                    and second is north     (y on plane)
C return unchanged!!!
      DOUBLE PRECISION		PERPVE(3), PERPVN(3)

C option CONN introduced 1/00 -
C CONNR(1) is the connolly surface probe radius (default 1.15Angs)
C          the option is turned off by setting this radius negative
C CONNR(2) is the grid size to be used in the calculation - default .85 angs
      DOUBLE PRECISION		CONNR(2)
! the radius at which an end is reached
      DOUBLE PRECISION		ENDRAD

C internal variables ***********
C end of decs ******************

! only output sphpdb file if it is open
! this is indicated by is name not being none
      IF (FPDBSP.NE.'NONE') THEN
        WRITE( SPDBSP, '(A, F12.6)') 'SAMPLE', SAMPLE
        WRITE( SPDBSP, '(A,3F12.6)') 'CVECT ', CVECT
        WRITE( SPDBSP, '(A,3F12.6)') 'PERPVE', PERPVE
        WRITE( SPDBSP, '(A,3F12.6)') 'PERPVN', PERPVN
        WRITE( SPDBSP, '(A,2F12.6)') 'CONNR ', CONNR
        WRITE( SPDBSP, '(A,2F12.6)') 'ENDRAD', ENDRAD
      ENDIF
      RETURN
      END