I have a simple question regarding allocating a character array that
can represent a line in an input file. I am writing a small function
that can read a line from an input file, strip the Fortran 90 style
comments (Exclamation mark) and return the string.

Currently, I had fixed the output string to be of len = 1000. So, the
function that I had written is only limited to 1000 characters. I
want the returned string’s length to be dynamic and equal to the
actual length of the line in the input file (minus comments).
Something like TRIM(input_file_length). Could some point me to a way
of doing this ?

!-------------------------------------------------------------------------------
! nextline(funit) -- defaulted to public
! Return the next line from a file unit without any Fortran 90 style
comments.

function nextline ( funit ) result ( outstring )
use, intrinsic :: ISO_FORTRAN_ENV, only: OUTPUT_UNIT
implicit none

Ragu gmail.com> wrote:

First, please note that you are *NOT* talking about an array. A string
and an array are different things. You can have an array of characters,
but that's not the usual Fortran idiom (and thus a lot of string
intrinsics and other things won't work or won't do what you might want).
What you have is a scalar (not array) Fortran string. Yes, it makes a
difference - quite a big one as it tirns out.

That being said...

There are two separate problems here. One is solvable with a bit of
work. The other really needs f2003.

The one that is solvable with a bit of work is that you need to read the
line in first in order to find out how long it is. That means that you
can't read directly into the character variable in question...

On Sep 10, 4:20 pm, nos...@see.signature (Richard Maine) wrote:

On Sep 10, 5:20 pm, nos...@see.signature (Richard Maine) wrote:

Ragu gmail.com> wrote:

"String termination character" isn't the right concept here. Fortran
doesn't have one. In fact, it would be a contradiction in terms in
Fortran. If it was a character then it could be in a string, and not
necessarily at the end. Neither do all record structures.

See the size= specifier for the READ statement. You'll have to be doing
nonadvancing I/O for that, but that's not a particularly big deal. Some
compilers have related nonportable things (I think the Q edit
descriptor, or something like that).

Ragu wrote:

GaryScott sbcglobal.net> wrote:

I think you are confusing a few things here.

First, they certainly aren't implemented as a derived type, insomuch as
that's a Fortran thing and there aren't currently any Fortran compilers
written in Fortran. (There have been in the past, and I'd think f2003 a
suitable language to write one in today, in fact that's an idea I've
toyed with, but there aren't any right now).

Second, the answer depends partly on context. Fundamentally, an
allocatable string needs a pointer to the dynamically allocated body and
an indication of the length. For an allocatable string standing...

Richard Maine wrote:

I work regularly with a legacy F77 program that has author-written
DMA. (I'm not the author.)
The program structure permits a stack sort of allocation.
At the beginning you allocate one humongous array...

George McBane wrote:

George McBane gvsu.edu> wrote:

...

...