J3/02-157

Date:  9-Mar-2002
To:    J3 meeting #160
From:  Stan Whitlock
Subj:  Request for interpretation from Larry Meadows

Larry raised the question below.  At J3 meeting #160, I decided that
this should be interp #97.  Sunsequently it was pointed out that this
duplicates interp #6, which passed at J3 meeting 158 (see 01-305r1)
and is awaiting a J3 letter ballot.  Therefore no new interp will be
raised for this issue.

----------------------------------------------------------------------

QUESTION: Are dummy functions returning assumed-length character
          legal?

Consider the following program:

        character*5 f
        external f
          call ss3(f)
        end
        subroutine ss3(ff)
        character*(*) ff, a*10
        external ff
          a = ff()//'99999999'
          print *, '<', a, '>'
        end
        function f()
        character*(*) f
          f = '123'
        end

The issue is the call to the dummy function 'ff' in subroutine 'ss3'.
Some compilers issue an error message. Others print the result:
 <123  99999>

There appear to be two relevant, contradictory passages in the F95
standard. Refer to section 5.1.1.5. <> means italics, [] means
obsolescent font.

The third constraint says "A function name shall not be declared with
an asterisk <char-len-param-value> [unless it is the name of the
result of an external function or the name of a dummy function.]

Before note 5.6 on the next page, the third bullet says:
(3) [In an external function, the name of the function result may be
specified with a character length parameter value of *; in this case,
any scoping unit invoking the function shall declare the function
name with a character length parameter value other than * or access
such a definition by host or use association. When the function is
invoked, the length of the result variable in the function is assumed
from the value of this type parameter.]

According to the standard, the use in the example program is legal,
because 'ff' is the name of a dummy function. But it seems clear that
the standard intended that the length of the variable returned by
a character function be known at compile time; it is not known in the
case where the function is a dummy function.