ISO_varying_string.f90

Go to the documentation of this file.

 
 
module iso_varying_string
 
! No implicit typing
 
  IMPLICIT NONE
 
! Parameter definitions
 
  INTEGER, parameter, private :: GET_BUFFER_LEN = 256
 
! Type definitions
 
  TYPE, public :: varying_string
     private
     character(LEN=1), dimension(:), allocatable :: chars
  end TYPE varying_string
 
! Interface blocks
 
  interface assignment(=)
     module procedure op_assign_ch_vs
     module procedure op_assign_vs_ch
  end interface assignment(=)
 
  interface operator(//)
     module procedure op_concat_vs_vs
     module procedure op_concat_ch_vs
     module procedure op_concat_vs_ch
  end interface operator(//)
 
  interface operator(==)
     module procedure op_eq_vs_vs
     module procedure op_eq_ch_vs
     module procedure op_eq_vs_ch
  end interface operator(==)
 
  interface operator(/=)
     module procedure op_ne_vs_vs
     module procedure op_ne_ch_vs
     module procedure op_ne_vs_ch
  end interface operator (/=)
  
  interface operator(<)
     module procedure op_lt_vs_vs
     module procedure op_lt_ch_vs
     module procedure op_lt_vs_ch
  end interface operator (<)
  
  interface operator(<=)
     module procedure op_le_vs_vs
     module procedure op_le_ch_vs
     module procedure op_le_vs_ch
  end interface operator (<=)
  
  interface operator(>=)
     module procedure op_ge_vs_vs
     module procedure op_ge_ch_vs
     module procedure op_ge_vs_ch
  end interface operator (>=)
 
  interface operator(>)
     module procedure op_gt_vs_vs
     module procedure op_gt_ch_vs
     module procedure op_gt_vs_ch
  end interface operator (>)
  
  interface adjustl
     module procedure adjustl_
  end interface adjustl
 
  interface adjustr
     module procedure adjustr_
  end interface adjustr
 
  interface char
     module procedure char_auto
     module procedure char_fixed
  end interface char
 
  interface iachar
     module procedure iachar_
  end interface iachar
 
  interface ichar
     module procedure ichar_
  end interface ichar
 
  interface index
     module procedure index_vs_vs
     module procedure index_ch_vs
     module procedure index_vs_ch
  end interface index
 
  interface len
     module procedure len_
  end interface len
 
  interface len_trim
     module procedure len_trim_
  end interface len_trim
 
  interface lge
     module procedure lge_vs_vs
     module procedure lge_ch_vs
     module procedure lge_vs_ch
  end interface lge
  
  interface lgt
     module procedure lgt_vs_vs
     module procedure lgt_ch_vs
     module procedure lgt_vs_ch
  end interface lgt
 
  interface lle
     module procedure lle_vs_vs
     module procedure lle_ch_vs
     module procedure lle_vs_ch
  end interface lle
 
  interface llt
     module procedure llt_vs_vs
     module procedure llt_ch_vs
     module procedure llt_vs_ch
  end interface llt
 
  interface repeat
     module procedure repeat_
  end interface repeat
 
  interface scan
     module procedure scan_vs_vs
     module procedure scan_ch_vs
     module procedure scan_vs_ch
  end interface scan
 
  interface trim
     module procedure trim_
  end interface trim
 
  interface verify
     module procedure verify_vs_vs
     module procedure verify_ch_vs
     module procedure verify_vs_ch
  end interface verify
 
  interface var_str
     module procedure var_str_
  end interface var_str
 
  interface get
     module procedure get_
     module procedure get_unit
     module procedure get_set_vs
     module procedure get_set_ch
     module procedure get_unit_set_vs
     module procedure get_unit_set_ch
  end interface get
 
  interface put
     module procedure put_vs
     module procedure put_ch
     module procedure put_unit_vs
     module procedure put_unit_ch
  end interface put
 
  interface put_line
     module procedure put_line_vs
     module procedure put_line_ch
     module procedure put_line_unit_vs
     module procedure put_line_unit_ch
  end interface put_line
 
  interface extract
     module procedure extract_vs
     module procedure extract_ch
  end interface extract
 
  interface insert
     module procedure insert_vs_vs
     module procedure insert_ch_vs
     module procedure insert_vs_ch
     module procedure insert_ch_ch
  end interface insert
 
  interface remove
     module procedure remove_vs
     module procedure remove_ch
  end interface remove
 
  interface replace
     module procedure replace_vs_vs_auto
     module procedure replace_ch_vs_auto
     module procedure replace_vs_ch_auto
     module procedure replace_ch_ch_auto
     module procedure replace_vs_vs_fixed
     module procedure replace_ch_vs_fixed
     module procedure replace_vs_ch_fixed
     module procedure replace_ch_ch_fixed
     module procedure replace_vs_vs_vs_target
     module procedure replace_ch_vs_vs_target
     module procedure replace_vs_ch_vs_target
     module procedure replace_ch_ch_vs_target
     module procedure replace_vs_vs_ch_target
     module procedure replace_ch_vs_ch_target
     module procedure replace_vs_ch_ch_target
     module procedure replace_ch_ch_ch_target
  end interface
 
  interface split
     module procedure split_vs
     module procedure split_ch
  end interface split
 
! Access specifiers
 
  public :: assignment(=)
  public :: operator(//)
  public :: operator(==)
  public :: operator(/=)
  public :: operator(<)
  public :: operator(<=)
  public :: operator(>=)
  public :: operator(>)
  public :: adjustl
  public :: adjustr
  public :: char
  public :: iachar
  public :: ichar
  public :: index
  public :: len
  public :: len_trim
  public :: lge
  public :: lgt
  public :: lle
  public :: llt
  public :: repeat
  public :: scan
  public :: trim
  public :: verify
  public :: var_str
  public :: get
  public :: put
  public :: put_line
  public :: extract
  public :: insert
  public :: remove
  public :: replace
  public :: split
 
  private :: op_assign_ch_vs
  private :: op_assign_vs_ch
  private :: op_concat_vs_vs
  private :: op_concat_ch_vs
  private :: op_concat_vs_ch
  private :: op_eq_vs_vs
  private :: op_eq_ch_vs
  private :: op_eq_vs_ch
  private :: op_ne_vs_vs
  private :: op_ne_ch_vs
  private :: op_ne_vs_ch
  private :: op_lt_vs_vs
  private :: op_lt_ch_vs
  private :: op_lt_vs_ch
  private :: op_le_vs_vs
  private :: op_le_ch_vs
  private :: op_le_vs_ch
  private :: op_ge_vs_vs
  private :: op_ge_ch_vs
  private :: op_ge_vs_ch
  private :: op_gt_vs_vs
  private :: op_gt_ch_vs
  private :: op_gt_vs_ch
  private :: adjustl_
  private :: adjustr_
  private :: char_auto
  private :: char_fixed
  private :: iachar_
  private :: ichar_
  private :: index_vs_vs
  private :: index_ch_vs
  private :: index_vs_ch
  private :: len_
  private :: len_trim_
  private :: lge_vs_vs
  private :: lge_ch_vs
  private :: lge_vs_ch
  private :: lgt_vs_vs
  private :: lgt_ch_vs
  private :: lgt_vs_ch
  private :: lle_vs_vs
  private :: lle_ch_vs
  private :: lle_vs_ch
  private :: llt_vs_vs
  private :: llt_ch_vs
  private :: llt_vs_ch
  private :: repeat_
  private :: scan_vs_vs
  private :: scan_ch_vs
  private :: scan_vs_ch
  private :: trim_
  private :: verify_vs_vs
  private :: verify_ch_vs
  private :: verify_vs_ch
  private :: var_str_
  private :: get_
  private :: get_unit
  private :: get_set_vs
  private :: get_set_ch
  private :: get_unit_set_vs
  private :: get_unit_set_ch
  private :: put_vs
  private :: put_ch
  private :: put_unit_vs
  private :: put_unit_ch
  private :: put_line_vs
  private :: put_line_ch
  private :: put_line_unit_vs
  private :: put_line_unit_ch
  private :: extract_vs
  private :: extract_ch
  private :: insert_vs_vs
  private :: insert_ch_vs
  private :: insert_vs_ch
  private :: insert_ch_ch
  private :: remove_vs
  private :: remove_ch
  private :: replace_vs_vs_auto
  private :: replace_ch_vs_auto
  private :: replace_vs_ch_auto
  private :: replace_ch_ch_auto
  private :: replace_vs_vs_fixed
  private :: replace_ch_vs_fixed
  private :: replace_vs_ch_fixed
  private :: replace_ch_ch_fixed
  private :: replace_vs_vs_vs_target
  private :: replace_ch_vs_vs_target
  private :: replace_vs_ch_vs_target
  private :: replace_ch_ch_vs_target
  private :: replace_vs_vs_ch_target
  private :: replace_ch_vs_ch_target
  private :: replace_vs_ch_ch_target
  private :: replace_ch_ch_ch_target
  private :: split_vs
  private :: split_ch
 
! Procedures
 
contains
 
!    
 
  elemental SUBROUTINE op_assign_ch_vs (var, exp)
 
    character(LEN= ), INTENT(out)    :: var
    TYPE(varying_string), INTENT(in) :: exp
 
! Assign a varying string to a character string
 
    var = char(exp)
 
! Finish
 
    return
 
  end SUBROUTINE op_assign_ch_vs
 
!    
 
  elemental SUBROUTINE op_assign_vs_ch (var, exp)
 
    TYPE(varying_string), INTENT(out) :: var
    character(LEN= ), INTENT(in)      :: exp
 
! Assign a character string to a varying string
 
    var = var_str(exp)
 
! Finish
 
    return
 
  end SUBROUTINE op_assign_vs_ch
 
!    
 
  elemental function op_concat_vs_vs (string_a, string_b) result (concat_string)
 
    TYPE(varying_string), INTENT(in) :: string_a
    TYPE(varying_string), INTENT(in) :: string_b
    TYPE(varying_string)             :: concat_string
 
    INTEGER                          :: len_string_a
 
! Concatenate two varying strings
 
    len_string_a = len(string_a)
 
    ALLOCATE(concat_string%chars(len_string_a+len(string_b)))
 
    concat_string%chars(:len_string_a) = string_a%chars
    concat_string%chars(len_string_a+1:) = string_b%chars
 
! Finish
 
    return
 
  end function op_concat_vs_vs
 
!    
 
  elemental function op_concat_ch_vs (string_a, string_b) result (concat_string)
 
    character(LEN= ), INTENT(in)     :: string_a
    TYPE(varying_string), INTENT(in) :: string_b
    TYPE(varying_string)             :: concat_string
 
! Concatenate a character string and a varying 
! string
 
    concat_string = op_concat_vs_vs(var_str(string_a), string_b)
 
! Finish
 
    return
 
  end function op_concat_ch_vs
 
!    
 
  elemental function op_concat_vs_ch (string_a, string_b) result (concat_string)
 
    TYPE(varying_string), INTENT(in) :: string_a
    character(LEN= ), INTENT(in)     :: string_b
    TYPE(varying_string)             :: concat_string
 
! Concatenate a varying string and a character
! string
 
    concat_string = op_concat_vs_vs(string_a, var_str(string_b))
 
! Finish
 
    return
 
  end function op_concat_vs_ch
 
!    
 
  elemental function op_eq_vs_vs (string_a, string_b) result (op_eq)
 
    TYPE(varying_string), INTENT(in) :: string_a
    TYPE(varying_string), INTENT(in) :: string_b
    LOGICAL                          :: op_eq
 
! Compare (==) two varying strings
 
    op_eq = char(string_a) == char(string_b)
 
! Finish
 
    return
 
  end function op_eq_vs_vs
 
!    
 
  elemental function op_eq_ch_vs (string_a, string_b) result (op_eq)
 
    character(LEN= ), INTENT(in)     :: string_a
    TYPE(varying_string), INTENT(in) :: string_b
    LOGICAL                          :: op_eq
 
! Compare (==) a character string and a varying 
! string
 
    op_eq = string_a == char(string_b)
 
! Finish
 
    return
 
  end function op_eq_ch_vs
 
!    
 
  elemental function op_eq_vs_ch (string_a, string_b) result (op_eq)
 
    TYPE(varying_string), INTENT(in) :: string_a
    character(LEN= ), INTENT(in)     :: string_b
    LOGICAL                          :: op_eq
 
! Compare (==) a varying string and a character
! string
 
    op_eq = char(string_a) == string_b
 
! Finish
 
    return
 
  end function op_eq_vs_ch
 
!    
 
  elemental function op_ne_vs_vs (string_a, string_b) result (op_ne)
 
    TYPE(varying_string), INTENT(in) :: string_a
    TYPE(varying_string), INTENT(in) :: string_b
    LOGICAL                          :: op_ne
 
! Compare (/=) two varying strings
 
    op_ne = char(string_a) /= char(string_b)
 
! Finish
 
    return
 
  end function op_ne_vs_vs
 
!    
 
  elemental function op_ne_ch_vs (string_a, string_b) result (op_ne)
 
    character(LEN= ), INTENT(in)     :: string_a
    TYPE(varying_string), INTENT(in) :: string_b
    LOGICAL                          :: op_ne
 
! Compare (/=) a character string and a varying
! string
 
    op_ne = string_a /= char(string_b)
 
! Finish
 
    return
 
  end function op_ne_ch_vs
 
!    
 
  elemental function op_ne_vs_ch (string_a, string_b) result (op_ne)
 
    TYPE(varying_string), INTENT(in) :: string_a
    character(LEN= ), INTENT(in)     :: string_b
    LOGICAL                          :: op_ne
 
! Compare (/=) a varying string and a character
! string
 
    op_ne = char(string_a) /= string_b
 
! Finish
 
    return
 
  end function op_ne_vs_ch
 
!    
 
  elemental function op_lt_vs_vs (string_a, string_b) result (op_lt)
 
    TYPE(varying_string), INTENT(in) :: string_a
    TYPE(varying_string), INTENT(in) :: string_b
    LOGICAL                          :: op_lt
 
! Compare (<) two varying strings
 
    op_lt = char(string_a) < char(string_b)
 
! Finish
 
    return
 
  end function op_lt_vs_vs
 
!    
 
  elemental function op_lt_ch_vs (string_a, string_b) result (op_lt)
 
    character(LEN= ), INTENT(in)     :: string_a
    TYPE(varying_string), INTENT(in) :: string_b
    LOGICAL                          :: op_lt
 
! Compare (<) a character string and a varying
! string
 
    op_lt = string_a < char(string_b)
 
! Finish
 
    return
 
  end function op_lt_ch_vs
 
!    
 
  elemental function op_lt_vs_ch (string_a, string_b) result (op_lt)
 
    TYPE(varying_string), INTENT(in) :: string_a
    character(LEN= ), INTENT(in)     :: string_b
    LOGICAL                          :: op_lt
 
! Compare (<) a varying string and a character 
! string
 
    op_lt = char(string_a) < string_b
 
! Finish
 
    return
 
  end function op_lt_vs_ch
 
!    
 
  elemental function op_le_vs_vs (string_a, string_b) result (op_le)
 
    TYPE(varying_string), INTENT(in) :: string_a
    TYPE(varying_string), INTENT(in) :: string_b
    LOGICAL                          :: op_le
 
! Compare (<=) two varying strings
 
    op_le = char(string_a) <= char(string_b)
 
! Finish
 
    return
 
  end function op_le_vs_vs
 
!    
 
  elemental function op_le_ch_vs (string_a, string_b) result (op_le)
 
    character(LEN= ), INTENT(in)     :: string_a
    TYPE(varying_string), INTENT(in) :: string_b
    LOGICAL                          :: op_le
 
! Compare (<=) a character string and a varying 
! string
 
    op_le = string_a <= char(string_b)
 
! Finish
 
    return
 
  end function op_le_ch_vs
 
!    
 
  elemental function op_le_vs_ch (string_a, string_b) result (op_le)
 
    TYPE(varying_string), INTENT(in) :: string_a
    character(LEN= ), INTENT(in)     :: string_b
    LOGICAL                          :: op_le
 
! Compare (<=) a varying string and a character 
! string
 
    op_le = char(string_a) <= string_b
 
! Finish
 
    return
 
  end function op_le_vs_ch
 
!    
 
  elemental function op_ge_vs_vs (string_a, string_b) result (op_ge)
 
    TYPE(varying_string), INTENT(in) :: string_a
    TYPE(varying_string), INTENT(in) :: string_b
    LOGICAL                          :: op_ge
 
! Compare (>=) two varying strings
 
    op_ge = char(string_a) >= char(string_b)
 
! Finish
 
    return
 
  end function op_ge_vs_vs
 
!    
 
  elemental function op_ge_ch_vs (string_a, string_b) result (op_ge)
 
    character(LEN= ), INTENT(in)     :: string_a
    TYPE(varying_string), INTENT(in) :: string_b
    LOGICAL                          :: op_ge
 
! Compare (>=) a character string and a varying
! string
 
    op_ge = string_a >= char(string_b)
 
! Finish
 
    return
 
  end function op_ge_ch_vs
 
!    
 
  elemental function op_ge_vs_ch (string_a, string_b) result (op_ge)
 
    TYPE(varying_string), INTENT(in) :: string_a
    character(LEN= ), INTENT(in)     :: string_b
    LOGICAL                          :: op_ge
 
! Compare (>=) a varying string and a character
! string
 
    op_ge = char(string_a) >= string_b
 
! Finish
 
    return
 
  end function op_ge_vs_ch
 
!    
 
  elemental function op_gt_vs_vs (string_a, string_b) result (op_gt)
 
    TYPE(varying_string), INTENT(in) :: string_a
    TYPE(varying_string), INTENT(in) :: string_b
    LOGICAL                          :: op_gt
 
! Compare (>) two varying strings
 
    op_gt = char(string_a) > char(string_b)
 
! Finish
 
    return
 
  end function op_gt_vs_vs
 
!    
 
  elemental function op_gt_ch_vs (string_a, string_b) result (op_gt)
 
    character(LEN= ), INTENT(in)     :: string_a
    TYPE(varying_string), INTENT(in) :: string_b
    LOGICAL                          :: op_gt
 
! Compare (>) a character string and a varying
! string
 
    op_gt = string_a > char(string_b)
 
! Finish
 
    return
 
  end function op_gt_ch_vs
 
!    
 
  elemental function op_gt_vs_ch (string_a, string_b) result (op_gt)
 
    TYPE(varying_string), INTENT(in) :: string_a
    character(LEN= ), INTENT(in)     :: string_b
    LOGICAL                          :: op_gt
 
! Compare (>) a varying string and a character
! string
 
    op_gt = char(string_a) > string_b
 
! Finish
 
    return
 
  end function op_gt_vs_ch
 
!    
 
  elemental function adjustl_ (string) result (adjustl_string)
 
    TYPE(varying_string), INTENT(in) :: string
    TYPE(varying_string)             :: adjustl_string
 
! Adjust the varying string to the left
 
    adjustl_string = adjustl(char(string))
 
! Finish
 
    return
 
  end function adjustl_
 
!    
 
  elemental function adjustr_ (string) result (adjustr_string)
 
    TYPE(varying_string), INTENT(in) :: string
    TYPE(varying_string)             :: adjustr_string
 
! Adjust the varying string to the right
 
    adjustr_string = adjustr(char(string))
 
! Finish
 
    return
 
  end function adjustr_
 
!    
 
  pure function char_auto (string) result (char_string)
 
    TYPE(varying_string), INTENT(in) :: string
    character(LEN=len(string))       :: char_string
 
    INTEGER                          :: i_char
 
! Convert a varying string into a character string
! (automatic length)
    
    forall(i_char = 1:len(string))
       char_string(i_char:i_char) = string%chars(i_char)
    end forall
 
! Finish
 
    return
 
  end function char_auto
 
!    
 
  pure function char_fixed (string, length) result (char_string)
 
    TYPE(varying_string), INTENT(in) :: string
    INTEGER, INTENT(in)              :: length
    character(LEN=length)            :: char_string
 
! Convert a varying string into a character string
! (fixed length)
 
    char_string = char(string)
 
! Finish
 
    return
 
  end function char_fixed
 
!    
 
  elemental function iachar_ (c) result (i)
 
    TYPE(varying_string), INTENT(in) :: c
    INTEGER                          :: i
 
! Get the position in the ISO 646 collating sequence
! of a varying string character
 
    i = ichar(char(c))
 
! Finish
 
    return
 
  end function iachar_
 
!    
 
  elemental function ichar_ (c) result (i)
 
    TYPE(varying_string), INTENT(in) :: c
    INTEGER                          :: i
 
! Get the position in the processor collating 
! sequence of a varying string character
 
    i = ichar(char(c))
 
! Finish
 
    return
 
  end function ichar_
 
!    
 
  elemental function index_vs_vs (string, substring, back) result (i_substring)
 
    TYPE(varying_string), INTENT(in) :: string
    TYPE(varying_string), INTENT(in) :: substring
    LOGICAL, INTENT(in), optional    :: back
    INTEGER                          :: i_substring
 
! Get the index of a varying substring within a
! varying string
 
    i_substring = index(char(string), char(substring), back)
 
! Finish
 
    return
 
  end function index_vs_vs
 
!    
 
  elemental function index_ch_vs (string, substring, back) result (i_substring)
 
    character(LEN= ), INTENT(in)     :: string
    TYPE(varying_string), INTENT(in) :: substring
    LOGICAL, INTENT(in), optional    :: back
    INTEGER                          :: i_substring
 
! Get the index of a varying substring within a
! character string
 
    i_substring = index(string, char(substring), back)
 
! Finish
 
    return
 
  end function index_ch_vs
 
!    
 
  elemental function index_vs_ch (string, substring, back) result (i_substring)
 
    TYPE(varying_string), INTENT(in) :: string
    character(LEN= ), INTENT(in)     :: substring
    LOGICAL, INTENT(in), optional    :: back
    INTEGER                          :: i_substring
 
! Get the index of a character substring within a
! varying string
 
    i_substring = index(char(string), substring, back)
 
! Finish
 
    return
 
  end function index_vs_ch
 
!    
 
  elemental function len_ (string) result (length)
 
    TYPE(varying_string), INTENT(in) :: string
    INTEGER                          :: length
 
! Get the length of a varying string
 
    if(ALLOCATED(string%chars)) then
       length = SIZE(string%chars)
    else
       length = 0
    end if
 
! Finish
 
    return
 
  end function len_
 
!    
 
  elemental function len_trim_ (string) result (length)
 
    TYPE(varying_string), INTENT(in) :: string
    INTEGER                          :: length
 
! Get the trimmed length of a varying string
 
    if(ALLOCATED(string%chars)) then
       length = len_trim(char(string))
    else
       length = 0
    end if
 
! Finish
 
    return
 
  end function len_trim_
 
!    
 
  elemental function lge_vs_vs (string_a, string_b) result (comp)
 
    TYPE(varying_string), INTENT(in) :: string_a
    TYPE(varying_string), INTENT(in) :: string_b
    LOGICAL                          :: comp
 
! Compare (LGE) two varying strings
 
    comp = (char(string_a) >= char(string_b))
 
! Finish
 
    return
 
  end function lge_vs_vs
 
!    
 
  elemental function lge_ch_vs (string_a, string_b) result (comp)
 
    character(LEN= ), INTENT(in)     :: string_a
    TYPE(varying_string), INTENT(in) :: string_b
    LOGICAL                          :: comp
 
! Compare (LGE) a character string and a varying
! string
 
    comp = (string_a >= char(string_b))
 
! Finish
 
    return
 
  end function lge_ch_vs
 
!    
 
  elemental function lge_vs_ch (string_a, string_b) result (comp)
 
    TYPE(varying_string), INTENT(in) :: string_a
    character(LEN= ), INTENT(in)     :: string_b
    LOGICAL                          :: comp
 
! Compare (LGE) a varying string and a character
! string
 
    comp = (char(string_a) >= string_b)
 
! Finish
 
    return
 
  end function lge_vs_ch
 
!    
 
  elemental function lgt_vs_vs (string_a, string_b) result (comp)
 
    TYPE(varying_string), INTENT(in) :: string_a
    TYPE(varying_string), INTENT(in) :: string_b
    LOGICAL                          :: comp
 
! Compare (LGT) two varying strings
 
    comp = (char(string_a) > char(string_b))
 
! Finish
 
    return
 
  end function lgt_vs_vs
 
!    
 
  elemental function lgt_ch_vs (string_a, string_b) result (comp)
 
    character(LEN= ), INTENT(in)     :: string_a
    TYPE(varying_string), INTENT(in) :: string_b
    LOGICAL                          :: comp
 
! Compare (LGT) a character string and a varying
! string
 
    comp = (string_a > char(string_b))
 
! Finish
 
    return
 
  end function lgt_ch_vs
 
!    
 
  elemental function lgt_vs_ch (string_a, string_b) result (comp)
 
    TYPE(varying_string), INTENT(in) :: string_a
    character(LEN= ), INTENT(in)     :: string_b
    LOGICAL                          :: comp
 
! Compare (LGT) a varying string and a character
! string
 
    comp = (char(string_a) > string_b)
 
! Finish
 
    return
 
  end function lgt_vs_ch
 
!    
 
  elemental function lle_vs_vs (string_a, string_b) result (comp)
 
    TYPE(varying_string), INTENT(in) :: string_a
    TYPE(varying_string), INTENT(in) :: string_b
    LOGICAL                          :: comp
 
! Compare (LLE) two varying strings
 
    comp = (char(string_a) <= char(string_b))
 
! Finish
 
    return
 
  end function lle_vs_vs
 
!    
 
  elemental function lle_ch_vs (string_a, string_b) result (comp)
 
    character(LEN= ), INTENT(in)     :: string_a
    TYPE(varying_string), INTENT(in) :: string_b
    LOGICAL                          :: comp
 
! Compare (LLE) a character string and a varying
! string
 
    comp = (string_a <= char(string_b))
 
! Finish
 
    return
 
  end function lle_ch_vs
 
!    
 
  elemental function lle_vs_ch (string_a, string_b) result (comp)
 
    TYPE(varying_string), INTENT(in) :: string_a
    character(LEN= ), INTENT(in)     :: string_b
    LOGICAL                          :: comp
 
! Compare (LLE) a varying string and a character
! string
 
    comp = (char(string_a) <= string_b)
 
! Finish
 
    return
 
  end function lle_vs_ch
 
!    
 
  elemental function llt_vs_vs (string_a, string_b) result (comp)
 
    TYPE(varying_string), INTENT(in) :: string_a
    TYPE(varying_string), INTENT(in) :: string_b
    LOGICAL                          :: comp
 
! Compare (LLT) two varying strings
 
    comp = (char(string_a) < char(string_b))
 
! Finish
 
    return
 
  end function llt_vs_vs
 
!    
 
  elemental function llt_ch_vs (string_a, string_b) result (comp)
 
    character(LEN= ), INTENT(in)     :: string_a
    TYPE(varying_string), INTENT(in) :: string_b
    LOGICAL                          :: comp
 
! Compare (LLT) a character string and a varying
! string
 
    comp = (string_a < char(string_b))
 
! Finish
 
    return
 
  end function llt_ch_vs
 
!    
 
  elemental function llt_vs_ch (string_a, string_b) result (comp)
 
    TYPE(varying_string), INTENT(in) :: string_a
    character(LEN= ), INTENT(in)     :: string_b
    LOGICAL                          :: comp
 
! Compare (LLT) a varying string and a character
! string
 
    comp = (char(string_a) < string_b)
 
! Finish
 
    return
 
  end function llt_vs_ch
 
!    
 
  elemental function repeat_ (string, ncopies) result (repeat_string)
 
    TYPE(varying_string), INTENT(in) :: string
    INTEGER, INTENT(in)              :: ncopies
    TYPE(varying_string)             :: repeat_string
 
! Concatenate several copies of a varying string
 
    repeat_string = var_str(repeat(char(string), ncopies))
 
! Finish
 
    return
 
  end function repeat_
 
!    
 
  elemental function scan_vs_vs (string, set, back) result (i)
 
    TYPE(varying_string), INTENT(in) :: string
    TYPE(varying_string), INTENT(in) :: set
    LOGICAL, INTENT(in), optional    :: back
    INTEGER                          :: i
 
! Scan a varying string for occurrences of 
! characters in a varying-string set
 
    i = scan(char(string), char(set), back)
 
! Finish
 
    return
 
  end function scan_vs_vs
    
!    
 
  elemental function scan_ch_vs (string, set, back) result (i)
 
    character(LEN= ), INTENT(in)     :: string
    TYPE(varying_string), INTENT(in) :: set
    LOGICAL, INTENT(in), optional    :: back
    INTEGER                          :: i
 
! Scan a character string for occurrences of 
! characters in a varying-string set
 
    i = scan(string, char(set), back)
 
! Finish
 
    return
 
  end function scan_ch_vs
    
!    
 
  elemental function scan_vs_ch (string, set, back) result (i)
 
    TYPE(varying_string), INTENT(in) :: string
    character(LEN= ), INTENT(in)     :: set
    LOGICAL, INTENT(in), optional    :: back
    INTEGER                          :: i
 
! Scan a varying string for occurrences of 
! characters in a character-string set
 
    i = scan(char(string), set, back)
 
! Finish
 
    return
 
  end function scan_vs_ch
    
!    
 
  elemental function trim_ (string) result (trim_string)
 
    TYPE(varying_string), INTENT(in) :: string
    TYPE(varying_string)             :: trim_string
 
! Remove trailing blanks from a varying string
 
    trim_string = trim(char(string))
 
! Finish
 
    return
 
  end function trim_
 
!    
 
  elemental function verify_vs_vs (string, set, back) result (i)
 
    TYPE(varying_string), INTENT(in) :: string
    TYPE(varying_string), INTENT(in) :: set
    LOGICAL, INTENT(in), optional    :: back
    INTEGER                          :: i
 
! Verify a varying string for occurrences of
! characters in a varying-string set
 
    i = verify(char(string), char(set), back)
 
! Finish
 
    return
 
  end function verify_vs_vs
 
!    
 
  elemental function verify_ch_vs (string, set, back) result (i)
 
    character(LEN= ), INTENT(in)     :: string
    TYPE(varying_string), INTENT(in) :: set
    LOGICAL, INTENT(in), optional    :: back
    INTEGER                          :: i
 
! Verify a character string for occurrences of 
! characters in a varying-string set
 
    i = verify(string, char(set), back)
 
! Finish
 
    return
 
  end function verify_ch_vs
 
!    
 
  elemental function verify_vs_ch (string, set, back) result (i)
 
    TYPE(varying_string), INTENT(in) :: string
    character(LEN= ), INTENT(in)     :: set
    LOGICAL, INTENT(in), optional    :: back
    INTEGER                          :: i
 
! Verify a varying string for occurrences of 
! characters in a character-string set
 
    i = verify(char(string), set, back)
 
! Finish
 
    return
 
  end function verify_vs_ch
 
!    
 
  elemental function var_str_ (char) result (string)
 
    character(LEN= ), INTENT(in) :: char
    TYPE(varying_string)         :: string
 
    INTEGER                      :: length
    INTEGER                      :: i_char
 
! Convert a character string to a varying string
 
    length = len(char)
 
    ALLOCATE(string%chars(length))
 
    forall(i_char = 1:length)
       string%chars(i_char) = char(i_char:i_char)
    end forall
 
! Finish
 
    return
 
  end function var_str_
 
!    
 
  SUBROUTINE get_ (string, maxlen, iostat)
 
    TYPE(varying_string), INTENT(out) :: string
    INTEGER, INTENT(in), optional     :: maxlen
    INTEGER, INTENT(out), optional    :: iostat
 
    INTEGER                           :: n_chars_remain
    INTEGER                           :: n_chars_read
    character(LEN=GET_BUFFER_LEN)     :: buffer
    INTEGER                           :: local_iostat
 
! Read from the default unit into a varying string
 
    string = ""
 
    if(PRESENT(maxlen)) then
       n_chars_remain = maxlen
    else
       n_chars_remain = huge(1)
    end if
 
    read_loop : do
 
       if(n_chars_remain <= 0) return
 
       n_chars_read = min(n_chars_remain, get_buffer_len)
 
       if(PRESENT(iostat)) then
          read(unit= , fmt="(A)", advance="NO", &
               iostat=iostat, size=n_chars_read) buffer(:n_chars_read)
          if(iostat < 0) exit read_loop
          if(iostat > 0) return
       else
          read(unit= , fmt="(A)", advance="NO", &
               iostat=local_iostat, size=n_chars_read) buffer(:n_chars_read)
          if(local_iostat < 0) exit read_loop
       end if
 
       string = string//buffer(:n_chars_read)
       n_chars_remain = n_chars_remain - n_chars_read
 
    end do read_loop
 
    string = string//buffer(:n_chars_read)
 
! Finish (end-of-record)
 
    return
 
  end SUBROUTINE get_
 
!    
 
  SUBROUTINE get_unit (unit, string, maxlen, iostat)
 
    INTEGER, INTENT(in)               :: unit
    TYPE(varying_string), INTENT(out) :: string
    INTEGER, INTENT(in), optional     :: maxlen
    INTEGER, INTENT(out), optional    :: iostat
 
    INTEGER                           :: n_chars_remain
    INTEGER                           :: n_chars_read
    character(LEN=GET_BUFFER_LEN)     :: buffer
    INTEGER                           :: local_iostat
 
! Read from the specified unit into a varying string
 
    string = ""
 
    if(PRESENT(maxlen)) then
       n_chars_remain = maxlen
    else
       n_chars_remain = huge(1)
    end if
 
    read_loop : do
 
       if(n_chars_remain <= 0) return
 
       n_chars_read = min(n_chars_remain, get_buffer_len)
 
       if(PRESENT(iostat)) then
          read(unit=unit, fmt="(A)", advance="NO", &
               iostat=iostat, size=n_chars_read) buffer(:n_chars_read)
          if(iostat < 0) exit read_loop
          if(iostat > 0) return
       else
          read(unit=unit, fmt="(A)", advance="NO", &
               iostat=local_iostat, size=n_chars_read) buffer(:n_chars_read)
          if(local_iostat < 0) exit read_loop
       end if
 
       string = string//buffer(:n_chars_read)
       n_chars_remain = n_chars_remain - n_chars_read
 
    end do read_loop
 
    string = string//buffer(:n_chars_read)
 
! Finish (end-of-record)
 
    return
 
  end SUBROUTINE get_unit
 
!    
 
  SUBROUTINE get_set_vs (string, set, separator, maxlen, iostat)
 
    TYPE(varying_string), INTENT(out)           :: string
    TYPE(varying_string), INTENT(in)            :: set
    TYPE(varying_string), INTENT(out), optional :: separator
    INTEGER, INTENT(in), optional               :: maxlen
    INTEGER, INTENT(out), optional              :: iostat
 
! Read from the default unit into a varying string,
! with a custom varying-string separator
 
    call get(string, char(set), separator, maxlen, iostat)
 
! Finish
 
    return
 
  end SUBROUTINE get_set_vs
 
!    
 
  SUBROUTINE get_set_ch (string, set, separator, maxlen, iostat)
 
    TYPE(varying_string), INTENT(out)           :: string
    character(LEN= ), INTENT(in)                :: set
    TYPE(varying_string), INTENT(out), optional :: separator
    INTEGER, INTENT(in), optional               :: maxlen
    INTEGER, INTENT(out), optional              :: iostat
 
    INTEGER                                     :: n_chars_remain
    character(LEN=1)                            :: buffer
    INTEGER                                     :: i_set
    INTEGER                                     :: local_iostat
 
! Read from the default unit into a varying string,
! with a custom character-string separator
 
    string = ""
 
    if(PRESENT(maxlen)) then
       n_chars_remain = maxlen
    else
       n_chars_remain = huge(1)
    end if
 
    if(PRESENT(separator)) separator = ""
 
    read_loop : do
 
       if(n_chars_remain <= 0) return
 
       if(PRESENT(iostat)) then
          read(unit= , fmt="(A1)", advance="NO", iostat=iostat) buffer
          if(iostat /= 0) exit read_loop
       else
          read(unit= , fmt="(A1)", advance="NO", iostat=local_iostat) buffer
          if(local_iostat /= 0) exit read_loop
       end if
 
       i_set = scan(buffer, set)
 
       if(i_set == 1) then
          if(PRESENT(separator)) separator = buffer
          exit read_loop
       end if
 
       string = string//buffer
       n_chars_remain = n_chars_remain - 1
 
    end do read_loop
 
! Finish
 
    return
 
  end SUBROUTINE get_set_ch
 
!    
 
  SUBROUTINE get_unit_set_vs (unit, string, set, separator, maxlen, iostat)
 
    INTEGER, INTENT(in)                         :: unit
    TYPE(varying_string), INTENT(out)           :: string
    TYPE(varying_string), INTENT(in)            :: set
    TYPE(varying_string), INTENT(out), optional :: separator
    INTEGER, INTENT(in), optional               :: maxlen
    INTEGER, INTENT(out), optional              :: iostat
 
! Read from the specified unit into a varying string,
! with a custom varying-string separator
 
    call get(unit, string, char(set), separator, maxlen, iostat)
 
! Finish
 
    return
 
  end SUBROUTINE get_unit_set_vs
 
!    
 
  SUBROUTINE get_unit_set_ch (unit, string, set, separator, maxlen, iostat)
 
    INTEGER, INTENT(in)                         :: unit
    TYPE(varying_string), INTENT(out)           :: string
    character(LEN= ), INTENT(in)                :: set
    TYPE(varying_string), INTENT(out), optional :: separator
    INTEGER, INTENT(in), optional               :: maxlen
    INTEGER, INTENT(out), optional              :: iostat
 
    INTEGER                                     :: n_chars_remain
    character(LEN=1)                            :: buffer
    INTEGER                                     :: i_set
    INTEGER                                     :: local_iostat
 
! Read from the default unit into a varying string,
! with a custom character-string separator
 
    string = ""
 
    if(PRESENT(maxlen)) then
       n_chars_remain = maxlen
    else
       n_chars_remain = huge(1)
    end if
 
    if(PRESENT(separator)) separator = ""
 
    read_loop : do
 
       if(n_chars_remain <= 0) return
 
       if(PRESENT(iostat)) then
          read(unit=unit, fmt="(A1)", advance="NO", iostat=iostat) buffer
          if(iostat /= 0) exit read_loop
       else
          read(unit=unit, fmt="(A1)", advance="NO", iostat=local_iostat) buffer
          if(local_iostat /= 0) exit read_loop
       end if
 
       i_set = scan(buffer, set)
 
       if(i_set == 1) then
          if(PRESENT(separator)) separator = buffer
          exit read_loop
       end if
 
       string = string//buffer
       n_chars_remain = n_chars_remain - 1
 
    end do read_loop
 
! Finish
 
    return
 
  end SUBROUTINE get_unit_set_ch
 
!    
 
  SUBROUTINE put_vs (string, iostat)
 
    TYPE(varying_string), INTENT(in) :: string
    INTEGER, INTENT(out), optional   :: iostat
 
! Append a varying string to the current record of 
! the default unit
 
    call put(char(string), iostat)
 
! Finish
 
  end SUBROUTINE put_vs
    
!    
 
  SUBROUTINE put_ch (string, iostat)
 
    character(LEN= ), INTENT(in)   :: string
    INTEGER, INTENT(out), optional :: iostat
 
! Append a character string to the current record of 
! the default unit
 
    if(PRESENT(iostat)) then
       write(unit= , fmt="(A)", advance="NO", iostat=iostat) string
    else
       write(unit= , fmt="(A)", advance="NO") string
    end if
 
! Finish
 
  end SUBROUTINE put_ch
 
!    
 
  SUBROUTINE put_unit_vs (unit, string, iostat)
 
    INTEGER, INTENT(in)              :: unit
    TYPE(varying_string), INTENT(in) :: string
    INTEGER, INTENT(out), optional   :: iostat
 
! Append a varying string to the current record of 
! the specified unit
 
    call put(unit, char(string), iostat)
 
! Finish
 
    return
 
  end SUBROUTINE put_unit_vs
 
!    
 
  SUBROUTINE put_unit_ch (unit, string, iostat)
 
    INTEGER, INTENT(in)            :: unit
    character(LEN= ), INTENT(in)   :: string
    INTEGER, INTENT(out), optional :: iostat
 
! Append a character string to the current record of 
! the specified unit
 
    if(PRESENT(iostat)) then
       write(unit=unit, fmt="(A)", advance="NO", iostat=iostat) string
    else
       write(unit=unit, fmt="(A)", advance="NO") string
    end if
 
! Finish
 
    return
 
  end SUBROUTINE put_unit_ch
 
!    
 
  SUBROUTINE put_line_vs (string, iostat)
 
    TYPE(varying_string), INTENT(in) :: string
    INTEGER, INTENT(out), optional   :: iostat
 
! Append a varying string to the current record of 
! the default unit, terminating the record
 
    call put_line(char(string), iostat)
 
! Finish
 
    return
 
  end SUBROUTINE put_line_vs
 
!    
 
  SUBROUTINE put_line_ch (string, iostat)
 
    character(LEN= ), INTENT(in)   :: string
    INTEGER, INTENT(out), optional :: iostat
 
! Append a varying string to the current record of 
! the default unit, terminating the record
 
    if(PRESENT(iostat)) then
       write(unit= , fmt="(A,/)", advance="NO", iostat=iostat) string
    else
       write(unit= , fmt="(A,/)", advance="NO") string
    end if
 
! Finish
 
    return
 
  end SUBROUTINE put_line_ch
 
!    
 
  SUBROUTINE put_line_unit_vs (unit, string, iostat)
 
    INTEGER, INTENT(in)              :: unit
    TYPE(varying_string), INTENT(in) :: string
    INTEGER, INTENT(out), optional   :: iostat
 
! Append a varying string to the current record of 
! the specified unit, terminating the record
 
    call put_line(unit, char(string), iostat)
 
! Finish
 
    return
 
  end SUBROUTINE put_line_unit_vs
 
!    
 
  SUBROUTINE put_line_unit_ch (unit, string, iostat)
 
    INTEGER, INTENT(in)            :: unit
    character(LEN= ), INTENT(in)   :: string
    INTEGER, INTENT(out), optional :: iostat
 
! Append a varying string to the current record of 
! the specified unit, terminating the record
 
    if(PRESENT(iostat)) then
       write(unit=unit, fmt="(A,/)", advance="NO", iostat=iostat) string
    else
       write(unit=unit, fmt="(A,/)", advance="NO") string
    end if
 
! Finish
 
    return
 
  end SUBROUTINE put_line_unit_ch
 
!    
 
  elemental function extract_vs (string, start, finish) result (ext_string)
 
    TYPE(varying_string), INTENT(in) :: string
    INTEGER, INTENT(in), optional    :: start
    INTEGER, INTENT(in), optional    :: finish
    TYPE(varying_string)             :: ext_string
 
! Extract a varying substring from a varying string
 
    ext_string = extract(char(string), start, finish)
 
! Finish
 
    return
 
  end function extract_vs
 
!    
 
  elemental function extract_ch (string, start, finish) result (ext_string)
 
    character(LEN= ), INTENT(in)  :: string
    INTEGER, INTENT(in), optional :: start
    INTEGER, INTENT(in), optional :: finish
    TYPE(varying_string)          :: ext_string
 
    INTEGER                       :: start_
    INTEGER                       :: finish_
 
! Extract a varying substring from a character string
 
    if(PRESENT(start)) then
       start_ = max(1, start)
    else
       start_ = 1
    end if
 
    if(PRESENT(finish)) then
       finish_ = min(len(string), finish)
    else
       finish_ = len(string)
    end if
 
    ext_string = var_str(string(start_:finish_))
 
! Finish
 
    return
 
  end function extract_ch
 
!    
 
  elemental function insert_vs_vs (string, start, substring) result (ins_string)
 
    TYPE(varying_string), INTENT(in) :: string
    INTEGER, INTENT(in)              :: start
    TYPE(varying_string), INTENT(in) :: substring
    TYPE(varying_string)             :: ins_string
 
! Insert a varying substring into a varying string
 
    ins_string = insert(char(string), start, char(substring))
 
! Finish
 
    return
 
  end function insert_vs_vs
 
!    
 
  elemental function insert_ch_vs (string, start, substring) result (ins_string)
 
    character(LEN= ), INTENT(in)     :: string
    INTEGER, INTENT(in)              :: start
    TYPE(varying_string), INTENT(in) :: substring
    TYPE(varying_string)             :: ins_string
 
! Insert a varying substring into a character string
 
    ins_string = insert(string, start, char(substring))
 
! Finish
 
    return
 
  end function insert_ch_vs
 
!    
 
  elemental function insert_vs_ch (string, start, substring) result (ins_string)
 
    TYPE(varying_string), INTENT(in) :: string
    INTEGER, INTENT(in)              :: start
    character(LEN= ), INTENT(in)     :: substring
    TYPE(varying_string)             :: ins_string
 
! Insert a character substring into a varying string
 
    ins_string = insert(char(string), start, substring)
 
! Finish
 
    return
 
  end function insert_vs_ch
 
!    
 
  elemental function insert_ch_ch (string, start, substring) result (ins_string)
 
    character(LEN= ), INTENT(in) :: string
    INTEGER, INTENT(in)          :: start
    character(LEN= ), INTENT(in) :: substring
    TYPE(varying_string)         :: ins_string
 
    INTEGER                      :: start_
 
! Insert a character substring into a character
! string
 
    start_ = max(1, min(start, len(string)+1))
 
    ins_string = var_str(string(:start_-1)//substring//string(start_:))
 
! Finish
 
    return
 
  end function insert_ch_ch
 
!    
 
  elemental function remove_vs (string, start, finish) result (rem_string)
 
    TYPE(varying_string), INTENT(in) :: string
    INTEGER, INTENT(in), optional    :: start
    INTEGER, INTENT(in), optional    :: finish
    TYPE(varying_string)             :: rem_string
 
! Remove a substring from a varying string
 
    rem_string = remove(char(string), start, finish)
 
! Finish
 
    return
 
  end function remove_vs
 
!    
 
  elemental function remove_ch (string, start, finish) result (rem_string)
 
    character(LEN= ), INTENT(in)  :: string
    INTEGER, INTENT(in), optional :: start
    INTEGER, INTENT(in), optional :: finish
    TYPE(varying_string)          :: rem_string
 
    INTEGER                       :: start_
    INTEGER                       :: finish_
 
! Remove a substring from a character string
 
    if(PRESENT(start)) then
       start_ = max(1, start)
    else
       start_ = 1
    end if
 
    if(PRESENT(finish)) then
       finish_ = min(len(string), finish)
    else
       finish_ = len(string)
    end if
 
    if(finish_ >= start_) then
       rem_string = var_str(string(:start_-1)//string(finish_+1:))
    else
       rem_string = string
    end if
 
! Finish
 
    return
 
  end function remove_ch
 
!    
 
  elemental function replace_vs_vs_auto (string, start, substring) result (rep_string)
 
    TYPE(varying_string), INTENT(in) :: string
    INTEGER, INTENT(in)              :: start
    TYPE(varying_string), INTENT(in) :: substring
    TYPE(varying_string)             :: rep_string
 
! Replace part of a varying string with a varying
! substring
 
    rep_string = replace(char(string), start, max(start, 1)+len(substring)-1, char(substring))
 
! Finish
 
    return
 
  end function replace_vs_vs_auto
 
!    
 
  elemental function replace_ch_vs_auto (string, start, substring) result (rep_string)
 
    character(LEN= ), INTENT(in)     :: string
    INTEGER, INTENT(in)              :: start
    TYPE(varying_string), INTENT(in) :: substring
    TYPE(varying_string)             :: rep_string
 
! Replace part of a character string with a varying
! substring
 
    rep_string = replace(string, start, max(start, 1)+len(substring)-1, char(substring))
 
! Finish
 
    return
 
  end function replace_ch_vs_auto
 
!    
 
  elemental function replace_vs_ch_auto (string, start, substring) result (rep_string)
 
    TYPE(varying_string), INTENT(in) :: string
    INTEGER, INTENT(in)              :: start
    character(LEN= ), INTENT(in)     :: substring
    TYPE(varying_string)             :: rep_string
 
! Replace part of a varying string with a character
! substring
 
    rep_string = replace(char(string), start, max(start, 1)+len(substring)-1, substring)
 
! Finish
 
    return
 
  end function replace_vs_ch_auto
 
!    
 
  elemental function replace_ch_ch_auto (string, start, substring) result (rep_string)
 
    character(LEN= ), INTENT(in) :: string
    INTEGER, INTENT(in)          :: start
    character(LEN= ), INTENT(in) :: substring
    TYPE(varying_string)         :: rep_string
 
! Replace part of a character string with a character
! substring
 
    rep_string = replace(string, start, max(start, 1)+len(substring)-1, substring)
 
! Finish
 
    return
 
  end function replace_ch_ch_auto
 
!    
 
  elemental function replace_vs_vs_fixed (string, start, finish, substring) result (rep_string)
 
    TYPE(varying_string), INTENT(in) :: string
    INTEGER, INTENT(in)              :: start
    INTEGER, INTENT(in)              :: finish
    TYPE(varying_string), INTENT(in) :: substring
    TYPE(varying_string)             :: rep_string
 
! Replace part of a varying string with a varying
! substring
 
    rep_string = replace(char(string), start, finish, char(substring))
 
! Finish
 
    return
 
  end function replace_vs_vs_fixed
 
!    
 
!    
 
  elemental function replace_ch_vs_fixed (string, start, finish, substring) result (rep_string)
 
    character(LEN= ), INTENT(in)     :: string
    INTEGER, INTENT(in)              :: start
    INTEGER, INTENT(in)              :: finish
    TYPE(varying_string), INTENT(in) :: substring
    TYPE(varying_string)             :: rep_string
 
! Replace part of a character string with a varying
! substring
 
    rep_string = replace(string, start, finish, char(substring))
 
! Finish
 
    return
 
  end function replace_ch_vs_fixed
 
!    
 
  elemental function replace_vs_ch_fixed (string, start, finish, substring) result (rep_string)
 
    TYPE(varying_string), INTENT(in) :: string
    INTEGER, INTENT(in)              :: start
    INTEGER, INTENT(in)              :: finish
    character(LEN= ), INTENT(in)     :: substring
    TYPE(varying_string)             :: rep_string
 
! Replace part of a varying string with a character
! substring
 
    rep_string = replace(char(string), start, finish, substring)
 
! Finish
 
    return
 
  end function replace_vs_ch_fixed
 
!    
 
  elemental function replace_ch_ch_fixed (string, start, finish, substring) result (rep_string)
 
    character(LEN= ), INTENT(in) :: string
    INTEGER, INTENT(in)          :: start
    INTEGER, INTENT(in)          :: finish
    character(LEN= ), INTENT(in) :: substring
    TYPE(varying_string)         :: rep_string
 
    INTEGER                      :: start_
    INTEGER                      :: finish_
 
! Replace part of a character string with a character
! substring
 
    start_ = max(1, start)
    finish_ = min(len(string), finish)
 
    if(finish_ < start_) then
       rep_string = insert(string, start_, substring)
    else
       rep_string = var_str(string(:start_-1)//substring//string(finish_+1:))
    end if
 
! Finish
 
    return
 
  end function replace_ch_ch_fixed
 
!    
 
  elemental function replace_vs_vs_vs_target (string, target, substring, every, back) result (rep_string)
 
    TYPE(varying_string), INTENT(in) :: string
    TYPE(varying_string), INTENT(in) :: target
    TYPE(varying_string), INTENT(in) :: substring
    LOGICAL, INTENT(in), optional    :: every
    LOGICAL, INTENT(in), optional    :: back
    TYPE(varying_string)             :: rep_string
 
! Replace part of a varying string with a varying
! substring, at a location matching a varying-
! string target
 
    rep_string = replace(char(string), char(target), char(substring), every, back)
 
! Finish
 
    return
 
  end function replace_vs_vs_vs_target
 
!    
 
  elemental function replace_ch_vs_vs_target (string, target, substring, every, back) result (rep_string)
 
    character(LEN= ), INTENT(in)     :: string
    TYPE(varying_string), INTENT(in) :: target
    TYPE(varying_string), INTENT(in) :: substring
    LOGICAL, INTENT(in), optional    :: every
    LOGICAL, INTENT(in), optional    :: back
    TYPE(varying_string)             :: rep_string
 
! Replace part of a character string with a varying
! substring, at a location matching a varying-
! string target
 
    rep_string = replace(string, char(target), char(substring), every, back)
 
! Finish
 
    return
 
  end function replace_ch_vs_vs_target
 
!    
 
  elemental function replace_vs_ch_vs_target (string, target, substring, every, back) result (rep_string)
 
    TYPE(varying_string), INTENT(in) :: string
    character(LEN= ), INTENT(in)     :: target
    TYPE(varying_string), INTENT(in) :: substring
    LOGICAL, INTENT(in), optional    :: every
    LOGICAL, INTENT(in), optional    :: back
    TYPE(varying_string)             :: rep_string
 
! Replace part of a character string with a varying
! substring, at a location matching a character-
! string target
 
    rep_string = replace(char(string), target, char(substring), every, back)
 
! Finish
 
    return
 
  end function replace_vs_ch_vs_target
 
!    
 
  elemental function replace_ch_ch_vs_target (string, target, substring, every, back) result (rep_string)
 
    character(LEN= ), INTENT(in)     :: string
    character(LEN= ), INTENT(in)     :: target
    TYPE(varying_string), INTENT(in) :: substring
    LOGICAL, INTENT(in), optional    :: every
    LOGICAL, INTENT(in), optional    :: back
    TYPE(varying_string)             :: rep_string
 
! Replace part of a character string with a varying
! substring, at a location matching a character-
! string target
 
    rep_string = replace(string, target, char(substring), every, back)
 
! Finish
 
    return
 
  end function replace_ch_ch_vs_target
 
!    
 
  elemental function replace_vs_vs_ch_target (string, target, substring, every, back) result (rep_string)
 
    TYPE(varying_string), INTENT(in) :: string
    TYPE(varying_string), INTENT(in) :: target
    character(LEN= ), INTENT(in)     :: substring
    LOGICAL, INTENT(in), optional    :: every
    LOGICAL, INTENT(in), optional    :: back
    TYPE(varying_string)             :: rep_string
 
! Replace part of a varying string with a character
! substring, at a location matching a varying-
! string target
 
    rep_string = replace(char(string), char(target), substring, every, back)
 
! Finish
 
    return
 
  end function replace_vs_vs_ch_target
 
!    
 
  elemental function replace_ch_vs_ch_target (string, target, substring, every, back) result (rep_string)
 
    character(LEN= ), INTENT(in)     :: string
    TYPE(varying_string), INTENT(in) :: target
    character(LEN= ), INTENT(in)     :: substring
    LOGICAL, INTENT(in), optional    :: every
    LOGICAL, INTENT(in), optional    :: back
    TYPE(varying_string)             :: rep_string
 
! Replace part of a character string with a character
! substring, at a location matching a varying-
! string target
 
    rep_string = replace(string, char(target), substring, every, back)
 
! Finish
 
    return
 
  end function replace_ch_vs_ch_target
 
!    
 
  elemental function replace_vs_ch_ch_target (string, target, substring, every, back) result (rep_string)
 
    TYPE(varying_string), INTENT(in) :: string
    character(LEN= ), INTENT(in)     :: target
    character(LEN= ), INTENT(in)     :: substring
    LOGICAL, INTENT(in), optional    :: every
    LOGICAL, INTENT(in), optional    :: back
    TYPE(varying_string)             :: rep_string
 
! Replace part of a varying string with a character
! substring, at a location matching a character-
! string target
 
    rep_string = replace(char(string), target, substring, every, back)
 
! Finish
 
    return
 
  end function replace_vs_ch_ch_target
 
!    
 
  elemental function replace_ch_ch_ch_target (string, target, substring, every, back) result (rep_string)
 
    character(LEN= ), INTENT(in)  :: string
    character(LEN= ), INTENT(in)  :: target
    character(LEN= ), INTENT(in)  :: substring
    LOGICAL, INTENT(in), optional :: every
    LOGICAL, INTENT(in), optional :: back
    TYPE(varying_string)          :: rep_string
 
    LOGICAL                       :: every_
    LOGICAL                       :: back_
    TYPE(varying_string)          :: work_string
    INTEGER                       :: length_target
    INTEGER                       :: i_target
 
! Handle special cases when LEN(target) == 0. Such
! instances are prohibited by the standard, but
! since this function is elemental, no error can be
! thrown. Therefore, it makes sense to handle them 
! in a sensible manner
 
    if(len(target) == 0) then
       if(len(string) /= 0) then
          rep_string = string
       else
          rep_string = substring
       end if
       return
    end if
 
! Replace part of a character string with a character
! substring, at a location matching a character-
! string target
 
    if(PRESENT(every)) then
       every_ = every
    else
       every_ = .false.
    end if
 
    if(PRESENT(back)) then
       back_ = back
    else
       back_ = .false.
    end if
 
    rep_string = ""
 
    work_string = string
 
    length_target = len(target)
 
    replace_loop : do
 
       i_target = index(work_string, target, back_)
 
       if(i_target == 0) exit replace_loop
 
       if(back_) then
          rep_string = substring//extract(work_string, start=i_target+length_target)//rep_string
          work_string = extract(work_string, finish=i_target-1)
       else
          rep_string = rep_string//extract(work_string, finish=i_target-1)//substring
          work_string = extract(work_string, start=i_target+length_target)
       end if
 
       if(.NOT. every_) exit replace_loop
 
    end do replace_loop
 
    if(back_) then
       rep_string = work_string//rep_string
    else
       rep_string = rep_string//work_string
    end if
 
! Finish
 
    return
 
  end function replace_ch_ch_ch_target
 
!    
 
  elemental SUBROUTINE split_vs (string, word, set, separator, back)
 
    TYPE(varying_string), INTENT(inout)         :: string
    TYPE(varying_string), INTENT(out)           :: word
    TYPE(varying_string), INTENT(in)            :: set
    TYPE(varying_string), INTENT(out), optional :: separator
    LOGICAL, INTENT(in), optional               :: back
 
! Split a varying string into two verying strings
 
    call split_ch(string, word, char(set), separator, back)
 
! Finish
 
    return
 
  end SUBROUTINE split_vs
 
!    
 
  elemental SUBROUTINE split_ch (string, word, set, separator, back)
 
    TYPE(varying_string), INTENT(inout)         :: string
    TYPE(varying_string), INTENT(out)           :: word
    character(LEN= ), INTENT(in)                :: set
    TYPE(varying_string), INTENT(out), optional :: separator
    LOGICAL, INTENT(in), optional               :: back
 
    LOGICAL                                     :: back_
    INTEGER                                     :: i_separator
 
! Split a varying string into two verying strings
 
    if(PRESENT(back)) then
       back_ = back
    else
       back_ = .false.
    end if
 
    i_separator = scan(string, set, back_)
 
    if(i_separator /= 0) then
 
       if(back_) then
          word = extract(string, start=i_separator+1)
          if(PRESENT(separator)) separator = extract(string, start=i_separator, finish=i_separator)
          string = extract(string, finish=i_separator-1)
       else
          word = extract(string, finish=i_separator-1)
          if(PRESENT(separator)) separator = extract(string, start=i_separator, finish=i_separator)
          string = extract(string, start=i_separator+1)
       end if
 
    else
 
       word = string
       if(PRESENT(separator)) separator = ""
       string = ""
 
    end if
 
! Finish
 
    return
 
  end SUBROUTINE split_ch
 
end module iso_varying_string