function GTStringQuoteForDcl(string) result(result)

            character(*), intent(in):: string
            character(STRLEN):: result
        end function

    character(string) function JoinChar(carray, expr) result(result)
        character(*)     , intent(in)           :: carray(:)
        character(*)     , intent(in), optional :: expr

        character(2)     ,parameter :: default = ', '
        character(string)           :: delimiter
        integer                     :: dellen, i
    continue
        if ( present(expr) ) then
           delimiter = expr
           dellen = len(expr)
        else
           delimiter = default
           dellen = len(default)
        endif
        if (size(carray) <= 0) then
            result = ""
            return
        endif
        result = trim(carray(1))
        do, i = 2, size(carray)
            result = trim(result) // delimiter(1:dellen) // trim(carray(i))
        enddo
    end function

    character(string) function LChar(ch) result(result)
      character(len = *), intent(in):: ch
    continue
      result = ch
      call toLower(result)
    end function LChar

    subroutine Split_CC(str, carray, sep, limit)

        implicit none
        character(*), intent(in):: str
        character(*), pointer:: carray(:)
        character(*), intent(in):: sep
        integer(INTK), intent(in), optional:: limit
        integer(INTK) :: num, cur, i, limitnum
        character(STRING) :: substr
        logical :: end
    continue
        if (present(limit)) then
           if (limit > 0) then
              limitnum = limit
           else
              limitnum = 0
           end if
        else
           limitnum = 0
        end if


        if (len(trim(sep)) == 0) then
           num = 1
           substr = str
           ! 重複して無駄だが carray を allocate するため, 何分割するか
           ! 調べ, num に格納する.
           do
              cur = index(trim(substr), ' ')
              if (cur == 0) exit
              num = num + 1
              substr = adjustl(substr(cur + len(sep) :len(substr)))
           end do

           if (limitnum /= 0 .and. num > limitnum) num = limitnum
           allocate(carray(num))

           substr = str
           end = .false.
           do i = 1, num
              cur = index(trim(substr), ' ')
              if (cur == 0 .or. i == num) end = .true.
              if (end) then
                 carray(i) = substr
                 exit
              else
                 carray(i) = substr(1:cur - 1)
              end if
              substr = adjustl(substr(cur + len(sep) :len(substr)))
           end do

        else
           num = 1
           substr = str
           ! 重複して無駄だが carray を allocate するため, 何分割するか
           ! 調べ, num に格納する.
           do
              cur = index(substr, trim(sep))
              if (cur == 0) exit
              num = num + 1
              substr = substr(cur + len(sep) :len(substr))
           end do

           if (limitnum /= 0 .and. num > limitnum) num = limitnum
           allocate(carray(num))

           substr = str
           end = .false.
           do i = 1, num
              cur = index(substr, trim(sep))
              if (cur == 0 .or. i == num) end = .true.
              if (end) then
                 carray(i) = substr
                 exit
              else
                 carray(i) = substr(1:cur - 1)
              end if
              substr = substr(cur + len(sep) :len(substr))
           end do
        end if

        return

    end subroutine Split_CC

    logical function StrHead_CC(whole, head) result(result)
        character(len = *), intent(in):: whole
        character(len = *), intent(in):: head
    continue
        result = (len(whole) >= len(head))
        if (.not. result) return
        result = (whole(1:len(head)) == head)
    end function

    character(string) function UChar(ch) result(result)
      character(len = *), intent(in):: ch
    continue
      result = ch
      call toUpper(result)
    end function UChar

    subroutine strv2dp(dble_ptr, string)

        double precision, pointer:: dble_ptr(:)
        type(VSTRING), intent(in):: string
        type(STRING_LIST):: vslist
        integer:: i, nvalues
    continue
        call Split(vslist, string, ", ")
        nvalues = len(vslist)
        allocate(dble_ptr(nvalues))
        do, i = 1, nvalues
            dble_ptr(i) = stod(shift(vslist))
        enddo
        call dispose(vslist)
    end subroutine

    subroutine str2ip(int_ptr, string)
        integer, pointer:: int_ptr(:)
        character(len = *), intent(in):: string
        integer:: i, j, idx, nvalues
    continue
        nvalues = 1
        i = 1
        do
            idx = index(string(i: ), ',')
            if (idx == 0) exit
            i = i + idx - 1 + 1 
            nvalues = nvalues + 1
        enddo
        allocate(int_ptr(nvalues))
        i = 1
        j = 1
        do
            idx = index(string(i: ), ',')
            if (idx == 0) then
                int_ptr(j) = stoi(string(i: ))
                exit
            endif
            int_ptr(j) = stod(string(i: i+idx-2))
            i = i + idx - 1 + 1 
            j = j + 1
        enddo
    end subroutine

    subroutine strv2ip(int_ptr, string)

        integer, pointer:: int_ptr(:)
        type(VSTRING), intent(in):: string
        type(STRING_LIST):: vslist
        integer:: nvalues, i
    continue
        call Split(vslist, string, ", ")
        nvalues = len(vslist)
        allocate(int_ptr(nvalues))
        do, i = 1, nvalues
            int_ptr(i) = stoi(shift(vslist))
        enddo
        call dispose(vslist)
    end subroutine

    subroutine str2dp(real_ptr, string)
        double precision, pointer:: real_ptr(:)
        character(len = *), intent(in):: string
        integer:: i, j, idx, nvalues
    continue
        nvalues = 1
        i = 1
        do
            idx = index(string(i: ), ',')
            if (idx == 0) exit
            i = i + idx - 1 + 1 
            nvalues = nvalues + 1
        enddo
        allocate(real_ptr(nvalues))
        i = 1
        j = 1
        do
            idx = index(string(i: ), ',')
            if (idx == 0) then
                real_ptr(j) = stod(string(i: ))
                exit
            endif
            real_ptr(j) = stod(string(i: i+idx-2))
            i = i + idx - 1 + 1 
            j = j + 1
        enddo
    end subroutine

    subroutine strv2rp(real_ptr, string)

        real, pointer:: real_ptr(:)
        type(VSTRING), intent(in):: string
        type(STRING_LIST):: vslist
        integer:: i, nvalues
    continue
        call Split(vslist, string, ", ")
        nvalues = len(vslist)
        allocate(real_ptr(nvalues))
        do, i = 1, nvalues
            real_ptr(i) = stod(shift(vslist))
        enddo
        call dispose(vslist)
    end subroutine

    subroutine str2rp(real_ptr, string)
        real, pointer:: real_ptr(:)
        character(len = *), intent(in):: string
        integer:: i, j, idx, nvalues
    continue
        nvalues = 1
        i = 1
        do
            idx = index(string(i: ), ',')
            if (idx == 0) exit
            i = i + idx - 1 + 1 
            nvalues = nvalues + 1
        enddo
        allocate(real_ptr(nvalues))
        i = 1
        j = 1
        do
            idx = index(string(i: ), ',')
            if (idx == 0) then
                real_ptr(j) = stod(string(i: ))
                exit
            endif
            real_ptr(j) = stod(string(i: i+idx-2))
            i = i + idx - 1 + 1 
            j = j + 1
        enddo
    end subroutine

    integer function index_ofs(string, start, substr) result(result)
        character(len = *), intent(in):: string
        integer, intent(in):: start
        character(len = *), intent(in):: substr
        intrinsic index
        if (start < 1) then
            result = 0
            return
        endif
        result = index(string(start: ), substr)
        if (result == 0) return
        result = start + result - 1
    end function

    function replace(string, from, to) result(result)

    implicit none
        character(len = strlen):: result
        character(len = *), intent(in):: string, from, to
        integer:: i, isa, isb, iea, ieb
    continue
        result = string
        i = index(result, from)
        if (i == 0) return
        isa = i + len(from)
        isb = i + len(to)
        if (len(to) < len(from)) then
            iea = len(result)
            ieb = len(result) + len(to) - len(from)
        else
            iea = len(result) + len(from) - len(to)
            ieb = len(result)
        endif
        if (len(to) /= len(from)) result(isb:ieb) = result(isa:iea)
        result(i:i+len(to)-1) = to
    end function

    double precision function atod_scalar(string) result(result)
        character(len = *), intent(in):: string
        integer:: ios
        character(len = 80):: buffer
        integer:: ipoint, iexp
        intrinsic scan
    continue
        buffer = string
        ! もし整定数をいれてしまった場合は小数点を附加
        if (index(buffer, '.') == 0) then
            iexp = scan(buffer, "eEdD")
            if (iexp /= 0) then
                buffer(iexp+1: len(buffer)) = buffer(iexp: len(buffer)-1)
                ipoint = iexp
            else
                ipoint = len_trim(buffer) + 1
            endif
            buffer(ipoint: ipoint) = '.'
        endif
        read(unit=buffer, fmt="(g80.10)", iostat=ios) result
        if (ios /= 0) result = 0.0
    end function

    double precision function stod_scalar(string) result(result)
        type(VSTRING), intent(in):: string
        character(len = 80):: buffer
    continue
        buffer = string
        result = atod_scalar(buffer)
    end function

    integer function stoi_scalar(string) result(result)
        type(VSTRING), intent(in):: string
        integer:: ios
        character(len = 80):: buffer
    continue
        buffer = string
        read(unit=buffer, fmt="(i80)", iostat=ios) result
        if (ios /= 0) result = 0
    end function

    integer function atoi_scalar(string, default) result(result)
        character(len = *), intent(in):: string
        integer, intent(in), optional:: default
        integer:: ios
    continue
        read(unit=string, fmt="(i80)", iostat=ios) result
        if (ios /= 0) then
            if (present(default)) then
                result = default
            else
                result = 0
            endif
        endif
    end function

    logical function str2bool(string) result(result)
        character(len = *), intent(in):: string
    continue
        select case(string)
        case ("", "0", "0.0", "0.0D0", "0.0d0", ".false.", ".FALSE.",  "f", "F", "false", "FALSE")
            result = .false.
        case default
            result = .true.
        end select
    end function

    logical function strieq_cc(string_a, string_b) result(result)
        character(len = *), intent(in):: string_a
        character(len = *), intent(in):: string_b
        character(len = string):: abuf
        character(len = string):: bbuf
!!$        character(len = len(string_a)):: abuf
!!$        character(len = len(string_b)):: bbuf
        abuf = string_a
        bbuf = string_b
        call toUpper(abuf)
        call toUpper(bbuf)
        result = (abuf == bbuf)
    end function

    logical function strieq_sc(string_a, string_b) result(result)
        type(VSTRING), intent(in):: string_a
        character(len = *), intent(in):: string_b
        result = strieq_cc(string_a%body(1:string_a%len), string_b)
    end function

    function toArray4(c1, c2, c3, c4) result(result)
      character(*), intent(in) :: c1, c2, c3, c4
      character(STRING) :: result(4)

    continue
      result(1) = c1
      result(2) = c2
      result(3) = c3
      result(4) = c4
    end function

    function toArray5(c1, c2, c3, c4, c5) result(result)
      character(*), intent(in) :: c1, c2, c3, c4, c5
      character(STRING) :: result(5)

    continue
      result(1) = c1
      result(2) = c2
      result(3) = c3
      result(4) = c4
      result(5) = c5
    end function

    function toArray6(c1, c2, c3, c4, c5, c6) result(result)
      character(*), intent(in) :: c1, c2, c3, c4, c5, c6
      character(STRING) :: result(6)

    continue
      result(1) = c1
      result(2) = c2
      result(3) = c3
      result(4) = c4
      result(5) = c5
      result(6) = c6
    end function

    function toArray7(c1, c2, c3, c4, c5, c6, c7) result(result)
      character(*), intent(in) :: c1, c2, c3, c4, c5, c6, c7
      character(STRING) :: result(7)

    continue
      result(1) = c1
      result(2) = c2
      result(3) = c3
      result(4) = c4
      result(5) = c5
      result(6) = c6
      result(7) = c7
    end function

    function toArray8(c1, c2, c3, c4, c5, c6, c7, c8) result(result)
      character(*), intent(in) :: c1, c2, c3, c4, c5, c6, c7, c8
      character(STRING) :: result(8)

    continue
      result(1) = c1
      result(2) = c2
      result(3) = c3
      result(4) = c4
      result(5) = c5
      result(6) = c6
      result(7) = c7
      result(8) = c8
    end function

    function toArray3(c1, c2, c3) result(result)
      character(*), intent(in) :: c1, c2, c3
      character(STRING) :: result(3)

    continue
      result(1) = c1
      result(2) = c2
      result(3) = c3
    end function

    function toArray2(c1, c2) result(result)
      character(*), intent(in) :: c1, c2
      character(STRING) :: result(2)

    continue
      result(1) = c1
      result(2) = c2
    end function

    function toArray9(c1, c2, c3, c4, c5, c6, c7, c8, c9) result(result)
      character(*), intent(in) :: c1, c2, c3, c4, c5, c6, c7, c8, c9
      character(STRING) :: result(9)

    continue
      result(1) = c1
      result(2) = c2
      result(3) = c3
      result(4) = c4
      result(5) = c5
      result(6) = c6
      result(7) = c7
      result(8) = c8
      result(9) = c9
    end function

    character(token) function rtoa_scalar(x) result(result)
        real, intent(in):: x
        character(len = 16):: buffer
    continue
        write(unit=buffer, fmt="(g16.8)") x
        result = adjustl(buffer)
    end function

    character(token) function ltoa_scalar(l) result(result)
        logical, intent(in):: l
    continue
        if (l) then
           result = ".true."
        else
           result = ".false."
        end if
    end function

    character(token) function itoa_scalar(i) result(result)
        integer, intent(in):: i
        character(len = 32):: buffer
    continue
        write(unit=buffer, fmt="(i20)") i
        result = adjustl(buffer)
    end function

    character(string) function rtoa_array(rbuf) result(result)
        real, intent(in):: rbuf(:)
        integer:: i
    continue
        if (size(rbuf) <= 0) then
            result = ""
            return
        endif
        result = toChar(rbuf(1))
        do, i = 2, size(rbuf)
            result = trim(result) // ", " // trim(toChar(rbuf(i)))
        enddo
    end function

    character(STRING) function ltoa_array(lbuf) result(result)
        logical, intent(in):: lbuf(:)
        integer:: i
    continue
        if (size(lbuf) <= 0) then
            result = ""
            return
        endif
        result = toChar(lbuf(1))
        do, i = 2, size(lbuf)
            result = trim(result) // ", " // trim(toChar(lbuf(i)))
        enddo
    end function

    character(token) function dtoa_scalar(d) result(result)
        double precision, intent(in):: d
        character(len = 32):: buffer
    continue
        write(unit=buffer, fmt="(g32.24)") d
        result = adjustl(buffer)
    end function

    character(STRING) function dtoa_array(dbuf) result(result)
        double precision, intent(in):: dbuf(:)
        integer:: i
    continue
        if (size(dbuf) <= 0) then
            result = ""
            return
        endif
        result = toChar(dbuf(1))
        do, i = 2, size(dbuf)
            result = trim(result) // ", " // trim(toChar(dbuf(i)))
        enddo
    end function

    character(string) function itoa_array(ibuf) result(result)
        integer, intent(in):: ibuf(:)
        integer:: i
    continue
        if (size(ibuf) <= 0) then
            result = ""
            return
        endif
        result = toChar(ibuf(1))
        do, i = 2, size(ibuf)
            result = trim(result) // ", " // trim(toChar(ibuf(i)))
        enddo
    end function

    subroutine clower(ch)
      character(len = *), intent(inout):: ch
      integer:: i, lch, idx
    continue
      lch = len(ch)
      do, i = 1, lch
         idx = ichar(ch(i:i))
         if (65 <= idx .and. idx <= 90) then
            ch(i:i)=char(idx + 32)
         end if
      end do
    end subroutine

    subroutine cupper(ch)
      character(len = *), intent(inout):: ch
      integer:: i, lch, idx
    continue
      lch = len(ch)
      do, i = 1, lch
         idx = ichar(ch(i:i))
         if (97 <= idx .and. idx <= 122) then
            ch(i:i)=char(idx - 32)
         end if
      end do
    end subroutine