Adjustable and automatic arrays in Fortran require the implementation
g77 compiler) to "memorize" the expressions that
dimension the arrays each time the procedure is invoked.
This is so that subsequent changes to variables used in those
expressions, made during execution of the procedure, do not
have any effect on the dimensions of those arrays.
REAL ARRAY(5) DATA ARRAY/5*2/ CALL X(ARRAY, 5) END SUBROUTINE X(A, N) DIMENSION A(N) N = 20 PRINT *, N, A END
Here, the implementation should, when running the program, print something like:
20 2. 2. 2. 2. 2.
Note that this shows that while the value of
N was successfully
changed, the size of the
A array remained at 5 elements.
To support this,
g77 generates code that executes before any user
code (and before the internally generated computed
GOTO to handle
alternate entry points, as described below) that evaluates each
(nonconstant) expression in the list of subscripts for an
array, and saves the result of each such evaluation to be used when
determining the size of the array (instead of re-evaluating the
So, in the above example, when
X is first invoked, code is
executed that copies the value of
N to a temporary.
And that same temporary serves as the actual high bound for the single
dimension of the
A array (the low bound being the constant 1).
Since the user program cannot (legitimately) change the value
of the temporary during execution of the procedure, the size
of the array remains constant during each invocation.
For alternate entry points, the code
g77 generates takes into
account the possibility that a dummy adjustable array is not actually
passed to the actual entry point being invoked at that time.
In that case, the public procedure implementing the entry point
passes to the master private procedure implementing all the
code for the entry points a
NULL pointer where a pointer to that
adjustable array would be expected.
doesn't attempt to evaluate any of the expressions in the subscripts
for an array if the pointer to that array is
NULL at run time in
(Don't depend on this particular implementation
by writing code that purposely passes
NULL pointers where the
callee expects adjustable arrays, even if you know the callee
won't reference the arrays--nor should you pass
for any dummy arguments used in calculating the bounds of such
arrays or leave undefined any values used for that purpose in
COMMON--because the way
g77 implements these things might
change in the future!)