 |
» |
|
|
|
Provides an additional external or module subprogram entry
point. SyntaxENTRY entry-name [([dummy-arg-list]) |
- entry-name
is the name of the entry point (subroutine or function)
defined by the ENTRY
statement. It must differ from the original subroutine or function
name, and from other ENTRY
statement entry-names specified in the
subprogram in which it appears. - dummy-arg-list
is a comma-separated list of dummy arguments for
the subroutine or function defined by the ENTRY
statement. The same rules and restrictions apply as for subroutine
dummy arguments or function dummy arguments, as appropriate. - result-name
is the result variable for a function defined by
an ENTRY statement.
result-name is optional; if not specified,
the result variable is entry-name. The RESULT
(result-name)
clause can only be specified when the ENTRY
statement is included in a function subprogram.
DescriptionWhen an ENTRY
statement appears in a function subprogram, it effectively provides
an additional FUNCTION
statement in the subprogram: execution starts from the ENTRY
statement when the entry-name is invoked
(by being used). Similarly, an ENTRY
statement in a subroutine subprogram effectively provides an additional
SUBROUTINE statement
in the subprogram, and execution starts from the ENTRY
statement when the entry-name is called. The following restrictions apply to the ENTRY
statement: The ENTRY
statement can appear in an external subprogram or a module subprogram;
it may not appear in an internal subprogram. If the ENTRY
statement appears in a function subprogram, it defines an additional
function; if it appears in a subroutine subprogram, it defines an
additional subroutine. The entry points thus defined can be referenced
in the same way as for a normal function name or subroutine name,
as appropriate. Execution starts at the ENTRY
statement, and continues in the normal manner, ignoring any ENTRY
statements subsequently encountered, until a RETURN
statement or the end of the procedure is reached. The RESULT
(result-name)
clause can only be specified when the ENTRY
statement is included in a function subprogram. If specified, result-name
must differ from entry-name, and entry-name
must not appear in any specification statement in the scoping unit
of the function subprogram; entry-name
assumes all the attributes of result-name.
The RESULT clause
in an ENTRY statement
has the same syntax and semantics as in a FUNCTION
statement. If the ENTRY
statement appears in a function, the result variable is that specified
in the FUNCTION
statement; if none is specified, the result variable is entry-name. If the characteristics of the result variable specified
in the ENTRY
statement are the same as those of the result variable specified
in the FUNCTION
statement, then the result variable is the same, even though the
names are different. If the characteristics are different, then
the result variables must be: Nonpointer scalars of intrinsic type If any is of character type, they must all be of
character type and must all have the same length. If any is of noncharacter
type, they must all be of noncharacter type.
The result variable may not appear in a COMMON,
DATA, or EQUIVALENCE
statement. Also, the result variable may not have the ALLOCATABLE,
INTENT, OPTIONAL,
PARAMETER, or
SAVE attribute. If RECURSIVE
is specified on the FUNCTION
statement at the start of a function subprogram, and RESULT
is specified on an ENTRY
statement within the subprogram, then the interface of the function
defined by the ENTRY
statement is explicit within the function subprogram; the function
can thus be invoked recursively. (Note that the keyword RECURSIVE
is not given on the ENTRY
statement, but only on the FUNCTION
statement.) If RECURSIVE
is specified on the SUBROUTINE
statement at the start of a subroutine subprogram, the interface
of the subroutine defined by an ENTRY
statement within the subprogram is explicit within the subprogram;
the subroutine can thus be called recursively. A dummy argument in an ENTRY
statement must not appear in an executable statement preceding the
ENTRY statement,
unless it also appears in a FUNCTION,
SUBROUTINE, or
ENTRY statement
preceding the executable statement. If a dummy argument in a subprogram—that
is, as specified in a FUNCTION
or SUBROUTINE
statement at the start of the subprogram or in any ENTRY
statements within the subprogram—is used in an executable
statement, then the statement may only be executed if the dummy
argument appears in the dummy argument list of the procedure name
actually referenced in the current call. The same restrictions apply
when you use a dummy argument in a specification expression to specify
an array bound or character length. A procedure defined by an ENTRY
statement may be given an explicit interface by use of an INTERFACE
block. The procedure header in the interface body must be a FUNCTION
statement for an entry to a function subprogram, and a SUBROUTINE
statement for an entry to a subroutine subprogram.
The ENTRY
statement was often used in FORTRAN 77 programs in situations where
a set of subroutines or functions had slightly different dummy argument
lists but entailed computations involving identical data and code.
In Fortran 90 the use of the ENTRY
statement in such situations can be replaced by the use of optional
arguments. ExamplesThe following example defines a subroutine subprogram with
two dummy arguments. The subprogram also contains an ENTRY
statement that takes only the first dummy argument specified in
the SUBROUTINE
statement. SUBROUTINE Full_Name (first_name, surname)
CHARACTER(20) :: first_name, surname
...
ENTRY Part_Name (first_name) |
The following example creates a stack. It shows the use of
ENTRY to group
the definition of a data structure together with the code that accesses
it, a technique known as encapsulation. (This example could alternatively
be programmed as a module, which would be preferable in that it
does not rely on storage association.) SUBROUTINE manipulate_stack
IMPLICIT NONE
INTEGER size, top /0/, value
PARAMETER (size = 100)
INTEGER, DIMENSION(size) :: stack
SAVE stack, top
ENTRY push(value) ! Push value onto the stack
IF (top == size) STOP "Stack Overflow"
top = top + 1
stack(top) = value
RETURN
ENTRY pop(value) ! Pop top of stack and place in value
IF (top == 0) STOP "Stack Underflow"
value = stack(top)
top = top - 1
RETURN
END SUBROUTINE manipulate_stack |
Here are examples of CALL
statements associated with the preceding example: CALL push(10)
CALL push(15)
CALL pop(I)
CALL pop(J) |
Related statementsFUNCTION,
SUBROUTINE, and
CALL Related conceptsFor information about external procedures, see “External procedures”. |
Printable version
