stdlib_string_type#

See also the specification page: stdlib_string_type.

stdlib_string_type (module)#

Implementation of a string type to hold an arbitrary sequence of characters.

This module provides string type compatible with all Fortran instrinsic character procedures as well as overloaded operators for working with character variables.

A string type can be easily constructed by creating a new instance from a character variable or literal by invoking its constructor or by assigning it to a string type. Generally, the string type behaves similar to a deferred length character in most regards but adds memory access safety.

The specification of this module is available in stdlib_string_type.

Types

string_type (type)#

string_type (type)

String type holding an arbitrary sequence of characters.

Interfaces

len (interface)#

len (interface)

Returns the length of the character sequence represented by the string.

This method is elemental and returns a default integer scalar value.

Procedures:

len_trim (interface)#

len_trim (interface)

Returns the length of the character sequence without trailing spaces represented by the string.

This method is elemental and returns a default integer scalar value.

Procedures:

trim (interface)#

trim (interface)

Returns the character sequence hold by the string without trailing spaces.

This method is elemental and returns a scalar character value.

Procedures:

adjustl (interface)#

adjustl (interface)

Left-adjust the character sequence represented by the string. The length of the character sequence remains unchanged.

This method is elemental and returns a scalar character value.

Procedures:

adjustr (interface)#

adjustr (interface)

Right-adjust the character sequence represented by the string. The length of the character sequence remains unchanged.

This method is elemental and returns a scalar character value.

Procedures:

repeat (interface)#

repeat (interface)

Repeats the character sequence hold by the string by the number of specified copies.

This method is elemental and returns a scalar character value.

Procedures:

to_lower (interface)#

to_lower (interface)

Returns the lowercase version of the character sequence hold by the input string

This method is Elemental and returns a new string_type instance which holds this lowercase character sequence

Procedures:

to_upper (interface)#

to_upper (interface)

Returns the uppercase version of the character sequence hold by the input string

This method is Elemental and returns a new string_type instance which holds this uppercase character sequence

Procedures:

to_title (interface)#

to_title (interface)

Returns the titlecase version of the character sequence hold by the input string

This method is Elemental and returns a new string_type instance which holds this titlecase character sequence

Procedures:

to_sentence (interface)#

to_sentence (interface)

Returns the sentencecase version of the character sequence hold by the input string

This method is elemental and returns a new string_type instance which holds this sentencecase character sequence

Procedures:

reverse (interface)#

reverse (interface)

Reverses the character sequence hold by the input string

This method is elemental and returns a new string_type instance which holds this reverse character sequence

Procedures:

char (interface)#

char (interface)

Return the character sequence represented by the string.

This method is elemental and returns a scalar character value.

Procedures:

ichar (interface)#

ichar (interface)

Character-to-integer conversion function.

This method is elemental and returns a default integer scalar value.

Procedures:

iachar (interface)#

iachar (interface)

Code in ASCII collating sequence.

This method is elemental and returns a default integer scalar value.

Procedures:

index (interface)#

index (interface)

Position of a substring within a string.

Returns the position of the start of the leftmost or rightmost occurrence of string substring in string, counting from one. If substring is not present in string, zero is returned.

This method is elemental and returns a default integer scalar value.

Procedures:

scan (interface)#

scan (interface)

Scan a string for the presence of a set of characters. Scans a string for any of the characters in a set of characters.

If back is either absent or false, this function returns the position of the leftmost character of string that is in set. If back is true, the rightmost position is returned. If no character of set is found in string, the result is zero.

This method is elemental and returns a default integer scalar value.

Procedures:

verify (interface)#

verify (interface)

Scan a string for the absence of a set of characters. Verifies that all the characters in string belong to the set of characters in set.

If back is either absent or false, this function returns the position of the leftmost character of string that is not in set. If back is true, the rightmost position is returned. If all characters of string are found in set, the result is zero.

This method is elemental and returns a default integer scalar value.

Procedures:

move (interface)#

move (interface)

Moves the allocated character scalar from ‘from’ to ‘to’ Specifications: stdlib_string_type

Procedures:

lgt (interface)#

lgt (interface)

Lexically compare the order of two character sequences being greater, The left-hand side, the right-hand side or both character sequences can be represented by a string.

This method is elemental and returns a default logical scalar value.

Procedures:

llt (interface)#

llt (interface)

Lexically compare the order of two character sequences being less, The left-hand side, the right-hand side or both character sequences can be represented by a string.

This method is elemental and returns a default logical scalar value.

Procedures:

lge (interface)#

lge (interface)

Lexically compare the order of two character sequences being greater equal, The left-hand side, the right-hand side or both character sequences can be represented by a string.

This method is elemental and returns a default logical scalar value.

Procedures:

lle (interface)#

lle (interface)

Lexically compare the order of two character sequences being less equal, The left-hand side, the right-hand side or both character sequences can be represented by a string.

This method is elemental and returns a default logical scalar value.

Procedures:

assignment(=) (interface)#

assignment(=) (interface)

Assign a character sequence to a string.

Procedures:

operator(>) (interface)#

operator(>) (interface)

Compare two character sequences for being greater, the left-hand side, the right-hand side or both character sequences can be represented by a string.

This operator is elemental and returns a default logical scalar value.

Procedures:

operator(<) (interface)#

operator(<) (interface)

Compare two character sequences for being less, the left-hand side, the right-hand side or both character sequences can be represented by a string.

This operator is elemental and returns a default logical scalar value.

Procedures:

operator(>=) (interface)#

operator(>=) (interface)

Compare two character sequences for being greater than, the left-hand side, the right-hand side or both character sequences can be represented by a string.

This operator is elemental and returns a default logical scalar value.

Procedures:

operator(<=) (interface)#

operator(<=) (interface)

Compare two character sequences for being less than, the left-hand side, the right-hand side or both character sequences can be represented by a string.

This operator is elemental and returns a default logical scalar value.

Procedures:

operator(==) (interface)#

operator(==) (interface)

Compare two character sequences for equality, the left-hand side, the right-hand side or both character sequences can be represented by a string.

This operator is elemental and returns a default logical scalar value.

Procedures:

operator(/=) (interface)#

operator(/=) (interface)

Compare two character sequences for inequality, the left-hand side, the right-hand side or both character sequences can be represented by a string.

This operator is elemental and returns a default logical scalar value.

Procedures:

operator(//) (interface)#

operator(//) (interface)

Concatenate two character sequences, the left-hand side, the right-hand side or both character sequences can be represented by a string.

This operator is elemental and returns a scalar character value.

Procedures:

write(formatted) (interface)#

write(formatted) (interface)

Write the character sequence hold by the string to a connected formatted unit.

Procedures:

write(unformatted) (interface)#

write(unformatted) (interface)

Write the character sequence hold by the string to a connected unformatted unit.

Procedures:

read(formatted) (interface)#

read(formatted) (interface)

Read a character sequence from a connected formatted unit into the string.

Procedures:

read(unformatted) (interface)#

read(unformatted) (interface)

Read a character sequence from a connected unformatted unit into the string.

Procedures:

Procedures

len_string (function)#

elemental function len_string(string) -> length

Returns the length of the character sequence represented by the string.

Arguments:
stringtype(string_type), intent(in)
Returns:
lengthinteger

len_trim_string (function)#

elemental function len_trim_string(string) -> length

Returns the length of the character sequence without trailing spaces represented by the string.

Arguments:
stringtype(string_type), intent(in)
Returns:
lengthinteger

ichar_string (function)#

elemental function ichar_string(string) -> ich

Character-to-integer conversion function.

Arguments:
stringtype(string_type), intent(in)
Returns:
ichinteger

iachar_string (function)#

elemental function iachar_string(string) -> ich

Code in ASCII collating sequence.

Arguments:
stringtype(string_type), intent(in)
Returns:
ichinteger

char_string (function)#

pure function char_string(string) -> character_string

Return the character sequence represented by the string.

Arguments:
stringtype(string_type), intent(in)
Returns:
character_stringcharacter(len=len)

char_string_pos (function)#

elemental function char_string_pos(string, pos) -> character_string

Return the character sequence represented by the string.

Arguments:
stringtype(string_type), intent(in)
posinteger, intent(in)
Returns:
character_stringcharacter(len=1)

char_string_range (function)#

pure function char_string_range(string, start, last) -> character_string

Return the character sequence represented by the string.

Arguments:
stringtype(string_type), intent(in)
startinteger, intent(in)
lastinteger, intent(in)
Returns:
character_stringcharacter(len=last)

trim_string (function)#

elemental function trim_string(string) -> trimmed_string

Returns the character sequence hold by the string without trailing spaces.

Arguments:
stringtype(string_type), intent(in)
Returns:
trimmed_stringtype(string_type)

adjustl_string (function)#

elemental function adjustl_string(string) -> adjusted_string

Left-adjust the character sequence represented by the string. The length of the character sequence remains unchanged.

Arguments:
stringtype(string_type), intent(in)
Returns:
adjusted_stringtype(string_type)

adjustr_string (function)#

elemental function adjustr_string(string) -> adjusted_string

Right-adjust the character sequence represented by the string. The length of the character sequence remains unchanged.

Arguments:
stringtype(string_type), intent(in)
Returns:
adjusted_stringtype(string_type)

repeat_string (function)#

elemental function repeat_string(string, ncopies) -> repeated_string

Repeats the character sequence hold by the string by the number of specified copies.

Arguments:
stringtype(string_type), intent(in)
ncopiesinteger, intent(in)
Returns:
repeated_stringtype(string_type)

to_lower_string (function)#

elemental function to_lower_string(string) -> lowercase_string

Convert the character sequence hold by the input string to lower case

Arguments:
stringtype(string_type), intent(in)
Returns:
lowercase_stringtype(string_type)

to_upper_string (function)#

elemental function to_upper_string(string) -> uppercase_string

Convert the character sequence hold by the input string to upper case

Arguments:
stringtype(string_type), intent(in)
Returns:
uppercase_stringtype(string_type)

to_title_string (function)#

elemental function to_title_string(string) -> titlecase_string

Convert the character sequence hold by the input string to title case

Arguments:
stringtype(string_type), intent(in)
Returns:
titlecase_stringtype(string_type)

to_sentence_string (function)#

elemental function to_sentence_string(string) -> sentence_string

Convert the character sequence hold by the input string to sentence case

Arguments:
stringtype(string_type), intent(in)
Returns:
sentence_stringtype(string_type)

reverse_string (function)#

elemental function reverse_string(string) -> reversed_string

Reverse the character sequence hold by the input string

Arguments:
stringtype(string_type), intent(in)
Returns:
reversed_stringtype(string_type)

index_string_string (function)#

elemental function index_string_string(string, substring, back) -> pos

Position of a sequence of character within a character sequence. In this version both character sequences are represented by a string.

Arguments:
stringtype(string_type), intent(in)
substringtype(string_type), intent(in)
backlogical, intent(in), optional
Returns:
posinteger

index_string_char (function)#

elemental function index_string_char(string, substring, back) -> pos

Position of a sequence of character within a character sequence. In this version the main character sequence is represented by a string.

Arguments:
stringtype(string_type), intent(in)
substringcharacter(len=*), intent(in)
backlogical, intent(in), optional
Returns:
posinteger

index_char_string (function)#

elemental function index_char_string(string, substring, back) -> pos

Position of a sequence of character within a character sequence. In this version the sub character sequence is represented by a string.

Arguments:
stringcharacter(len=*), intent(in)
substringtype(string_type), intent(in)
backlogical, intent(in), optional
Returns:
posinteger

scan_string_string (function)#

elemental function scan_string_string(string, set, back) -> pos

Scan a character sequence for any of the characters in a set of characters. In this version both the character sequence and the character set are represented by a string.

Arguments:
stringtype(string_type), intent(in)
settype(string_type), intent(in)
backlogical, intent(in), optional
Returns:
posinteger

scan_string_char (function)#

elemental function scan_string_char(string, set, back) -> pos

Scan a character sequence for any of the characters in a set of characters. In this version the character sequences is represented by a string.

Arguments:
stringtype(string_type), intent(in)
setcharacter(len=*), intent(in)
backlogical, intent(in), optional
Returns:
posinteger

scan_char_string (function)#

elemental function scan_char_string(string, set, back) -> pos

Scan a character sequence for any of the characters in a set of characters. In this version the set of characters is represented by a string.

Arguments:
stringcharacter(len=*), intent(in)
settype(string_type), intent(in)
backlogical, intent(in), optional
Returns:
posinteger

verify_string_string (function)#

elemental function verify_string_string(string, set, back) -> pos

Verify a character sequence for the absence any of the characters in a set of characters. In this version both the character sequence and the character set are represented by a string.

Arguments:
stringtype(string_type), intent(in)
settype(string_type), intent(in)
backlogical, intent(in), optional
Returns:
posinteger

verify_string_char (function)#

elemental function verify_string_char(string, set, back) -> pos

Verify a character sequence for the absence any of the characters in a set of characters. In this version the character sequences is represented by a string.

Arguments:
stringtype(string_type), intent(in)
setcharacter(len=*), intent(in)
backlogical, intent(in), optional
Returns:
posinteger

verify_char_string (function)#

elemental function verify_char_string(string, set, back) -> pos

Verify a character sequence for the absence any of the characters in a set of characters. In this version the set of characters is represented by a string.

Arguments:
stringcharacter(len=*), intent(in)
settype(string_type), intent(in)
backlogical, intent(in), optional
Returns:
posinteger

gt_string_string (function)#

elemental function gt_string_string(lhs, rhs) -> is_gt

Compare two character sequences for being greater. In this version both character sequences are by a string.

Arguments:
lhstype(string_type), intent(in)
rhstype(string_type), intent(in)
Returns:
is_gtlogical

gt_string_char (function)#

elemental function gt_string_char(lhs, rhs) -> is_gt

Compare two character sequences for being greater. In this version the left-hand side character sequences is by a string.

Arguments:
lhstype(string_type), intent(in)
rhscharacter(len=*), intent(in)
Returns:
is_gtlogical

gt_char_string (function)#

elemental function gt_char_string(lhs, rhs) -> is_gt

Compare two character sequences for being greater. In this version the right-hand side character sequences is by a string.

Arguments:
lhscharacter(len=*), intent(in)
rhstype(string_type), intent(in)
Returns:
is_gtlogical

lt_string_string (function)#

elemental function lt_string_string(lhs, rhs) -> is_lt

Compare two character sequences for being less. In this version both character sequences are by a string.

Arguments:
lhstype(string_type), intent(in)
rhstype(string_type), intent(in)
Returns:
is_ltlogical

lt_string_char (function)#

elemental function lt_string_char(lhs, rhs) -> is_lt

Compare two character sequences for being less. In this version the left-hand side character sequences is by a string.

Arguments:
lhstype(string_type), intent(in)
rhscharacter(len=*), intent(in)
Returns:
is_ltlogical

lt_char_string (function)#

elemental function lt_char_string(lhs, rhs) -> is_lt

Compare two character sequences for being less. In this version the right-hand side character sequences is by a string.

Arguments:
lhscharacter(len=*), intent(in)
rhstype(string_type), intent(in)
Returns:
is_ltlogical

ge_string_string (function)#

elemental function ge_string_string(lhs, rhs) -> is_ge

Compare two character sequences for being greater or equal. In this version both character sequences are by a string.

Arguments:
lhstype(string_type), intent(in)
rhstype(string_type), intent(in)
Returns:
is_gelogical

ge_string_char (function)#

elemental function ge_string_char(lhs, rhs) -> is_ge

Compare two character sequences for being greater or equal. In this version the left-hand side character sequences is by a string.

Arguments:
lhstype(string_type), intent(in)
rhscharacter(len=*), intent(in)
Returns:
is_gelogical

ge_char_string (function)#

elemental function ge_char_string(lhs, rhs) -> is_ge

Compare two character sequences for being greater or equal In this version the right-hand side character sequences is by a string.

Arguments:
lhscharacter(len=*), intent(in)
rhstype(string_type), intent(in)
Returns:
is_gelogical

le_string_string (function)#

elemental function le_string_string(lhs, rhs) -> is_le

Compare two character sequences for being less or equal. In this version both character sequences are by a string.

Arguments:
lhstype(string_type), intent(in)
rhstype(string_type), intent(in)
Returns:
is_lelogical

le_string_char (function)#

elemental function le_string_char(lhs, rhs) -> is_le

Compare two character sequences for being less or equal. In this version the left-hand side character sequences is by a string.

Arguments:
lhstype(string_type), intent(in)
rhscharacter(len=*), intent(in)
Returns:
is_lelogical

le_char_string (function)#

elemental function le_char_string(lhs, rhs) -> is_le

Compare two character sequences for being less or equal In this version the right-hand side character sequences is by a string.

Arguments:
lhscharacter(len=*), intent(in)
rhstype(string_type), intent(in)
Returns:
is_lelogical

eq_string_string (function)#

elemental function eq_string_string(lhs, rhs) -> is_eq

Compare two character sequences for equality. In this version both character sequences are by a string.

Arguments:
lhstype(string_type), intent(in)
rhstype(string_type), intent(in)
Returns:
is_eqlogical

eq_string_char (function)#

elemental function eq_string_char(lhs, rhs) -> is_eq

Compare two character sequences for equality. In this version the left-hand side character sequences is by a string.

Arguments:
lhstype(string_type), intent(in)
rhscharacter(len=*), intent(in)
Returns:
is_eqlogical

eq_char_string (function)#

elemental function eq_char_string(lhs, rhs) -> is_eq

Compare two character sequences for equality. In this version the right-hand side character sequences is by a string.

Arguments:
lhscharacter(len=*), intent(in)
rhstype(string_type), intent(in)
Returns:
is_eqlogical

ne_string_string (function)#

elemental function ne_string_string(lhs, rhs) -> is_ne

Compare two character sequences for inequality. In this version both character sequences are by a string.

Arguments:
lhstype(string_type), intent(in)
rhstype(string_type), intent(in)
Returns:
is_nelogical

ne_string_char (function)#

elemental function ne_string_char(lhs, rhs) -> is_ne

Compare two character sequences for inequality. In this version the left-hand side character sequences is by a string.

Arguments:
lhstype(string_type), intent(in)
rhscharacter(len=*), intent(in)
Returns:
is_nelogical

ne_char_string (function)#

elemental function ne_char_string(lhs, rhs) -> is_ne

Compare two character sequences for inequality. In this version the right-hand side character sequences is by a string.

Arguments:
lhscharacter(len=*), intent(in)
rhstype(string_type), intent(in)
Returns:
is_nelogical

lgt_string_string (function)#

elemental function lgt_string_string(lhs, rhs) -> is_lgt

Lexically compare two character sequences for being greater. In this version both character sequences are by a string.

Arguments:
lhstype(string_type), intent(in)
rhstype(string_type), intent(in)
Returns:
is_lgtlogical

lgt_string_char (function)#

elemental function lgt_string_char(lhs, rhs) -> is_lgt

Lexically compare two character sequences for being greater. In this version the left-hand side character sequences is by a string.

Arguments:
lhstype(string_type), intent(in)
rhscharacter(len=*), intent(in)
Returns:
is_lgtlogical

lgt_char_string (function)#

elemental function lgt_char_string(lhs, rhs) -> is_lgt

Lexically compare two character sequences for being greater. In this version the right-hand side character sequences is by a string.

Arguments:
lhscharacter(len=*), intent(in)
rhstype(string_type), intent(in)
Returns:
is_lgtlogical

llt_string_string (function)#

elemental function llt_string_string(lhs, rhs) -> is_llt

Lexically compare two character sequences for being less. In this version both character sequences are by a string.

Arguments:
lhstype(string_type), intent(in)
rhstype(string_type), intent(in)
Returns:
is_lltlogical

llt_string_char (function)#

elemental function llt_string_char(lhs, rhs) -> is_llt

Lexically compare two character sequences for being less. In this version the left-hand side character sequences is by a string.

Arguments:
lhstype(string_type), intent(in)
rhscharacter(len=*), intent(in)
Returns:
is_lltlogical

llt_char_string (function)#

elemental function llt_char_string(lhs, rhs) -> is_llt

Lexically compare two character sequences for being less. In this version the right-hand side character sequences is by a string.

Arguments:
lhscharacter(len=*), intent(in)
rhstype(string_type), intent(in)
Returns:
is_lltlogical

lge_string_string (function)#

elemental function lge_string_string(lhs, rhs) -> is_lge

Lexically compare two character sequences for being greater or equal. In this version both character sequences are by a string.

Arguments:
lhstype(string_type), intent(in)
rhstype(string_type), intent(in)
Returns:
is_lgelogical

lge_string_char (function)#

elemental function lge_string_char(lhs, rhs) -> is_lge

Lexically compare two character sequences for being greater or equal. In this version the left-hand side character sequences is by a string.

Arguments:
lhstype(string_type), intent(in)
rhscharacter(len=*), intent(in)
Returns:
is_lgelogical

lge_char_string (function)#

elemental function lge_char_string(lhs, rhs) -> is_lge

Lexically compare two character sequences for being greater or equal In this version the right-hand side character sequences is by a string.

Arguments:
lhscharacter(len=*), intent(in)
rhstype(string_type), intent(in)
Returns:
is_lgelogical

lle_string_string (function)#

elemental function lle_string_string(lhs, rhs) -> is_lle

Lexically compare two character sequences for being less or equal. In this version both character sequences are by a string.

Arguments:
lhstype(string_type), intent(in)
rhstype(string_type), intent(in)
Returns:
is_llelogical

lle_string_char (function)#

elemental function lle_string_char(lhs, rhs) -> is_lle

Lexically compare two character sequences for being less or equal. In this version the left-hand side character sequences is by a string.

Arguments:
lhstype(string_type), intent(in)
rhscharacter(len=*), intent(in)
Returns:
is_llelogical

lle_char_string (function)#

elemental function lle_char_string(lhs, rhs) -> is_lle

Lexically compare two character sequences for being less or equal In this version the right-hand side character sequences is by a string.

Arguments:
lhscharacter(len=*), intent(in)
rhstype(string_type), intent(in)
Returns:
is_llelogical

concat_string_string (function)#

elemental function concat_string_string(lhs, rhs) -> string

Concatenate two character sequences. In this version both character sequences are by a string.

Arguments:
lhstype(string_type), intent(in)
rhstype(string_type), intent(in)
Returns:
stringtype(string_type)

concat_string_char (function)#

elemental function concat_string_char(lhs, rhs) -> string

Concatenate two character sequences. In this version the left-hand side character sequences is by a string.

Arguments:
lhstype(string_type), intent(in)
rhscharacter(len=*), intent(in)
Returns:
stringtype(string_type)

concat_char_string (function)#

elemental function concat_char_string(lhs, rhs) -> string

Concatenate two character sequences. In this version the right-hand side character sequences is by a string.

Arguments:
lhscharacter(len=*), intent(in)
rhstype(string_type), intent(in)
Returns:
stringtype(string_type)

assign_string_char (subroutine)#

elemental subroutine assign_string_char(lhs, rhs)

Assign a character sequence to a string.

Arguments:
lhstype(string_type), intent(inout)
rhscharacter(len=*), intent(in)

move_string_string (subroutine)#

elemental subroutine move_string_string(from, to)

Moves the allocated character scalar from ‘from’ to ‘to’ No output

Arguments:
fromtype(string_type), target, intent(inout)
totype(string_type), target, intent(inout)

move_string_char (subroutine)#

pure subroutine move_string_char(from, to)

Moves the allocated character scalar from ‘from’ to ‘to’ No output

Arguments:
fromtype(string_type), intent(inout)
tocharacter(len=:), allocatable, intent(out)

move_char_string (subroutine)#

pure subroutine move_char_string(from, to)

Moves the allocated character scalar from ‘from’ to ‘to’ No output

Arguments:
fromcharacter(len=:), allocatable, intent(inout)
totype(string_type), intent(out)

move_char_char (subroutine)#

pure subroutine move_char_char(from, to)

Moves the allocated character scalar from ‘from’ to ‘to’ No output

Arguments:
fromcharacter(len=:), allocatable, intent(inout)
tocharacter(len=:), allocatable, intent(out)

write_unformatted (subroutine)#

subroutine write_unformatted(string, unit, iostat, iomsg)

Write the character sequence hold by the string to a connected unformatted unit.

Arguments:
stringtype(string_type), intent(in)
unitinteger, intent(in)
iostatinteger, intent(out)
iomsgcharacter(len=*), intent(inout)

write_formatted (subroutine)#

subroutine write_formatted(string, unit, iotype, v_list, iostat, iomsg)

Write the character sequence hold by the string to a connected formatted unit.

Arguments:
stringtype(string_type), intent(in)
unitinteger, intent(in)
iotypecharacter(len=*), intent(in)
v_listinteger, intent(in), dimension(:)
iostatinteger, intent(out)
iomsgcharacter(len=*), intent(inout)

read_unformatted (subroutine)#

subroutine read_unformatted(string, unit, iostat, iomsg)

Read a character sequence from a connected unformatted unit into the string.

Arguments:
stringtype(string_type), intent(inout)
unitinteger, intent(in)
iostatinteger, intent(out)
iomsgcharacter(len=*), intent(inout)

read_formatted (subroutine)#

subroutine read_formatted(string, unit, iotype, v_list, iostat, iomsg)

Read a character sequence from a connected formatted unit into the string.

Arguments:
stringtype(string_type), intent(inout)
unitinteger, intent(in)
iotypecharacter(len=*), intent(in)
v_listinteger, intent(in), dimension(:)
iostatinteger, intent(out)
iomsgcharacter(len=*), intent(inout)
On this page
Show Source