This file lists recent changes to the GNU Fortran compiler. Copyright (C) 1995, 1996 Free Software Foundation, Inc. You may copy, distribute, and modify it freely as long as you preserve this copyright notice and permission notice.
Changes made to recent versions of GNU Fortran are listed below, with the most recent version first.
The changes are generally listed in order:
This order is not strict---for example, some items involve a combination of these elements.
DO
loops that
have one or more references to the iteration variable,
or to aliases of it, in their control expressions.
For example, DO 10 J=2,J now is compiled correctly.
The x87 coprocessor stack was being
mismanaged in cases involving assigned GOTO
and ASSIGN
.
DTime
intrinsic so as not to truncate
results to integer values (on some systems).
SIGNAL
intrinsic so it offers portable
support for 64-bit systems (such as Digital Alphas
running GNU/Linux).
NAMELIST
on 64-bit
machines such as Alphas.
g77
version of libf2c
so it no longer
produces a spurious I/O recursion diagnostic at run time
when an I/O operation (such as READ *,I) is interrupted
in a manner that causes the program to be terminated
via the f_exit routine (such as via C-c).
g77
crash triggered by CASE
statement with
an omitted lower or upper bound.
g77
crash compiling references to CPU_Time
intrinsic.
g77
crash
(or apparently infinite run-time)
when compiling certain complicated expressions
involving COMPLEX
arithmetic
(especially multiplication).
g77
crash on statements such as
PRINT *, (REAL(Z(I)),I=1,2), where
Z is DOUBLE COMPLEX
.
g++
crash.
INTEGER
expression.
g77
-g option so procedures that
use ENTRY can be stepped through, line by line,
in gdb
.
gcc
back end for
Intel x86 architecture.
REAL
argument to intrinsics
Second
and CPU_Time
.
Int2
and Int8
.
tempnam
, if available, to open scratch files
(as in OPEN(STATUS='SCRATCH')
so that the TMPDIR
environment variable,
if present, is used.
gcc
keyword restrict
to
__restrict__
, to avoid rejecting valid, existing,
C programs.
Support for restrict
is now more like support
for complex
.
libf2c
so it is more likely that the printing of the
active format string is limited to the string,
with no trailing garbage being printed.
(Unlike f2c
, g77
did not append
a null byte to its compiled form of every
format string specified via a FORMAT
statement.
However, f2c
would exhibit the problem
anyway for a statement like PRINT '(I)garbage', 1
by printing (I)garbage as the format string.)
libf2c
for statements like PRINT '(I1', 42.
libf2c
.
libf2c
as of 1997-09-23.
This fixes a formatted-I/O bug that afflicted
64-bit systems with 32-bit integers
(such as Digital Alpha running GNU/Linux).
gcc
(C, C++,
Fortran, and so on).
EQUIVALENCE
with a
DATA
statement that follows
the first executable statement (or is
treated as an executable-context statement
as a result of using the -fpedantic
option).
gcc
back end issues a warning about such a case.
This bug afflicted all code compiled by
version 2.7.2.2.f.2 of gcc
(C, C++,
Fortran, and so on).
DATA
or similar to initialize a COMPLEX
variable or
array to zero.
AND
, OR
,
or XOR
intrinsics.
COMMON
or EQUIVALENCE
variable
as the target of an ASSIGN
or assigned-GOTO
statement.
SAVE
or the -fno-automatic option
is in effect.
This avoids a compiler crash in some cases.
DOUBLE PRECISION
optimally on Pentium and
Pentium Pro architectures (586 and 686 in gcc
).
The default is to issue such warnings, which are
new as of this version of g77
.
The default is to issue such diagnostics and flag the compilation as unsuccessful. With this option, the diagnostics are issued as warnings, or, if -Wno-globals is specified, are not issued at all.
This option also disables inlining of global procedures, to avoid compiler crashes resulting from coding errors that these diagnostics normally would identify.
g77
rejected a
second initialization specification immediately
following the first's closing / without
an intervening comma in a DATA
statement,
and the second specification was an implied-DO list.
gcc
back end so
certain complicated expressions involving COMPLEX
arithmetic (especially multiplication) don't appear to
take forever to compile.
gcc
back end.
gcc
fixes that seem useful in
g77
's version of gcc
.
(See gcc/ChangeLog for details---compare it
to that file in the vanilla gcc-2.7.2.3.tar.gz
distribution.)
libU77
routines that accept file and other names
to strip trailing blanks from them, for consistency
with other implementations.
Blanks may be forcibly appended to such names by
appending a single null character (CHAR(0))
to the significant trailing blanks.
CHMOD
intrinsic to work with file names
that have embedded blanks, commas, and so on.
SIGNAL
intrinsic so it accepts an
optional third Status argument.
IDATE()
intrinsic subroutine (VXT form)
so it accepts arguments in the correct order.
Documentation fixed accordingly, and for
GMTIME()
and LTIME()
as well.
libU77
intrinsics to
support existing code more directly.
Such changes include allowing both subroutine and
function forms of many routines, changing MCLOCK()
and TIME()
to return INTEGER(KIND=1)
values,
introducing MCLOCK8()
and TIME8()
to
return INTEGER(KIND=2)
values,
and placing functions that are intended to perform
side effects in a new intrinsic group, badu77
.
libU77
so it is more portable.
g77
and gcc
now do a somewhat better
job detecting and diagnosing arrays that are too
large to handle before these cause diagnostics
during the assembler or linker phase, a compiler
crash, or generation of incorrect code.
restrict
keyword in gcc
front end.
gcc
version 2.7.2.3
(modified by g77
into version 2.7.2.3.f.1),
and remove
support for prior versions of gcc
.
gcc
back
end into g77
's, so GNAT users do not need
to apply GNAT's patches to build both GNAT and g77
from the same source tree.
make
rules and related code so that
generation of Info documentation doesn't require
compilation using gcc
.
Now, any ANSI C compiler should be adequate to
produce the g77
documentation (in particular,
the tables of intrinsics) from scratch.
INT2
and INT8
intrinsics.
CPU_TIME
intrinsic.
ALARM
intrinsic.
CTIME
intrinsic now accepts any INTEGER
argument, not just INTEGER(KIND=2)
.
gcc
specs file.
make
rule g77-cross, used only for
cross-compiling.
libf2c
build procedure to re-archive library
if previous attempt to archive was interrupted.
gcc
to unroll loops only during the last
invocation (of as many as two invocations) of loop
optimization.
g77
driver to recognize -fsyntax-only
as an option that inhibits linking, just like -c or
-S, and to recognize and properly handle the
-nostdlib, -M, -MM, -nodefaultlibs,
and -Xlinker options.
libf2c
as of 1997-08-16.
libf2c
to consistently and clearly diagnose
recursive I/O (at run time).
g77
driver now prints version information (such as produced
by g77 -v) to stderr
instead of stdout
.
ratfor
command, available
separately.
gcc
determines what kind of
system is being configured and what kinds are supported.
For example, GNU Linux/Alpha ELF systems now are directly
supported.
libf2c
that come
from netlib.bell-labs.com
; give any such files
that aren't quite accurate in g77
's version of
libf2c
the suffix .netlib.
INTEGER(KIND=0)
for future use.
This option specifies that non-decimal-radix
constants using the prefixed-radix form (such as Z'1234')
are to be interpreted as INTEGER
constants.
Specify -ftypeless-boz to cause such
constants to be interpreted as typeless.
(Version 0.5.19 introduced -fno-typeless-boz and its inverse.)
Some programs might use names that clash with
intrinsic names defined (and now enabled) by these
options or by the new libU77
intrinsics.
Users of such programs might need to compile them
differently (using, for example, -ff90-intrinsics-disable)
or, better yet, insert appropriate EXTERNAL
statements specifying that these names are not intended
to be names of intrinsics.
libf2c
, which should result in improved
I/O performance, especially over NFS.
Note: If you have code that depends on the behavior
of libf2c
when built with ALWAYS_FLUSH defined,
you will have to modify libf2c
accordingly before
building it from this and future versions of g77
.
libU77
has been
added to the version of libf2c
distributed with
and built as part of g77
.
g77
now knows about the routines in this library
as intrinsics.
If you used one of these deleted options, you should
re-read the pertinent documentation to determine which
options, if any, are appropriate for compiling your
code with this version of g77
.
(Enabling all the -fugly-* options is unlikely to be feasible, or sensible, in the future, so users should learn to specify only those -fugly-* options they really need for a particular source file.)
g77
front end and
the gcc
back end to better support Alpha (AXP)
machines.
This includes providing at least one bug-fix to the
gcc
back end for Alphas.
LOC()
intrinsic and %LOC()
construct now return
values of integer type that is the same width (holds
the same number of bits) as the pointer type on the
machine.
On most machines, this won't make a difference, whereas
on Alphas, the type these constructs return is
INTEGER*8
instead of the more common INTEGER*4
.
COMPLEX
arithmetic in the g77
front
end, to avoid bugs in complex
support in the
gcc
back end.
New option -fno-emulate-complex
causes g77
to revert the 0.5.19 behavior.
g77
command driver so that g77 -o foo.f
no longer deletes foo.f before issuing other
diagnostics, and so the -x option is properly
handled.
gcc
back end.
This works as it does for gcc
itself---program units
may be inlined for invocations that follow them in the same
program unit, as long as the appropriate compile-time
options are specified.
COMMON
areas when any of
these are defined (assigned to) by Fortran code.
This can result in faster and/or smaller programs when compiling with optimization enabled, though on some systems this effect is observed only when -fforce-addr also is specified.
New options -falias-check, -fargument-alias,
-fargument-noalias,
and -fno-argument-noalias-global control the
way g77
handles potential aliasing.
CONJG()
and DCONJG()
intrinsics now
are compiled in-line.
g77
compiler has been changed back to
assume libf2c
has no aliasing problems in
its implementations of the COMPLEX
(and
DOUBLE COMPLEX
) intrinsics.
The libf2c
has been changed to have no such
problems.
As a result, 0.5.20 is expected to offer improved performance over 0.5.19.1, perhaps as good as 0.5.19 in most or all cases, due to this change alone.
Note: This change requires version 0.5.20 of
libf2c
, at least, when linking code produced
by any versions of g77
other than 0.5.19.1.
Use g77 -v to determine the version numbers
of the libF77
, libI77
, and libU77
components of the libf2c
library.
(If these version numbers are not printed---in
particular, if the linker complains about unresolved
references to names like g77__fvers__---that
strongly suggests your installation has an obsolete
version of libf2c
.)
g77
uses a separate memory location
to hold assigned statement labels.)
FORMAT
and ENTRY
statements now are allowed to
precede IMPLICIT NONE
statements.
SELECT CASE
on
CHARACTER
type, instead of crashing, at compile time.
libf2c
archive
(libf2c.a) so that members are added to it
only when truly necessary, so the user that installs
an already-built g77
doesn't need to have write
access to the build tree (whereas the user doing the
build might not have access to install new software
on the system).
gcc
version 2.7.2.2
(modified by g77
into version 2.7.2.2.f.2),
and remove
support for prior versions of gcc
.
libf2c
as of 1997-02-08, and
fix up some of the build procedures.
g77
,
fixing minor bugs (such as deletion of any file
named f771 in the parent directory of gcc/
).
INTEGER*8
available in
libf2c
and f2c.h so that f2c
users
may make full use of its features via the g77
version of f2c.h and the INTEGER*8
support routines in the g77
version of libf2c
.
g77
driver and libf2c
so that g77 -v
yields version information on the library.
SNGL
and FLOAT
intrinsics now are
specific intrinsics, instead of synonyms for the
generic intrinsic REAL
.
REALPART
, IMAGPART
,
COMPLEX
,
LONG
, and SHORT
.
REALPART
, IMAGPART
,
and COMPLEX
intrinsics.
An old group, dcp, has been removed.
DOUBLE COMPLEX
(or any
complex type other than COMPLEX
), unless
-ff90 option specifies Fortran 90 interpretation
or new -fugly-complex option, in conjunction with
-fnot-f90, specifies f2c
interpretation.
(Hence the menu item M for the node Diagnostics in the top-level menu of the Info documentation.)
These bugs occurred when assigning the result of an operation to a complex variable (or array element) that also served as an input to that operation.
The operations affected by this bug were: CONJG(),
DCONJG(), CCOS(), CDCOS(),
CLOG(), CDLOG(), CSIN(), CDSIN(),
CSQRT(), CDSQRT(), complex division, and
raising a DOUBLE COMPLEX
operand to an INTEGER
power.
(The related generic and Z-prefixed intrinsics,
such as ZSIN(), also were affected.)
For example, C = CSQRT(C), Z = Z/C, and Z = Z**I
(where C is COMPLEX
and Z is
DOUBLE COMPLEX
) have been fixed.
FORMAT
statement parsing so negative values for
specifiers such as P (e.g. FORMAT(-1PF8.1))
are correctly processed as negative.
SIGNAL
intrinsic so it once again accepts a
procedure as its second argument.
COMMON
and EQUIVALENCE
members at debug time.
DO
loops.
f77
and f2c
.
INTEGER
constants.
f77
programs.
CHARACTER
arrays having
names such as READ, WRITE, GOTO, and
REALFUNCTIONFOO.
EQUIVALENCE
areas so certain cases
of valid Fortran programs are not misdiagnosed as improperly
extending the area backwards.
gcc
version 2.7.2.1.
libf2c
as of 1996-09-26, and
fix up some of the build procedures.
libf2c
that might return non-zero
status codes for some operations previously assumed to always
return zero.
This change not only affects how IOSTAT=
variables
are set by list-directed I/O, it also affects whether
END=
and ERR=
labels are reached by these
operations.
FTELL
and FSEEK
procedures in libf2c
.
fseek_()
in libf2c
to be more portable
(though, in practice, there might be no systems where this
matters) and to catch invalid whence arguments.
gcc
has not been patched
using the patch file provided in the gcc/f/gbe/
subdirectory.
g77
command, to conform to GNU coding guidelines.
Also add printing of g77
version number when
the --verbose (-v) option is used.
EQUIVALENCE
areas to one based on the alphabetically sorted first name
in the list of names for entities placed at the beginning
of the areas.
INTEGER*1
,
INTEGER*2
, INTEGER*8
,
and their LOGICAL
equivalents.
(This support works on most, maybe all, gcc
targets.)
Thanks to Scott Snyder (snyder@d0sgif.fnal.gov) for providing the patch for this!
Among the missing elements from the support for these features are full intrinsic support and constants.
BYTE
and
WORD
type-declaration statements.
BYTE
corresponds to INTEGER*1
,
while WORD
corresponds to INTEGER*2
.
Thanks to Scott Snyder (snyder@d0sgif.fnal.gov) for providing the patch for this!
INTEGER*8
,
for example.
A new option, -fzeros, is introduced to enable the traditional treatment of zeros as any other value.
g77
incorrectly
interpreted REAL(Z) as returning a REAL
result, instead of as a DOUBLE PRECISION
result.
(Here, Z is DOUBLE COMPLEX
.)
With -fno-f90 in force, the interpretation remains
unchanged, since this appears to be how at least some
F77 code using the DOUBLE COMPLEX
extension expected
it to work.
Essentially, REAL(Z) in F90 is the same as DBLE(Z), while in extended F77, it appears to be the same as REAL(REAL(Z)).
INTEGER
and the right-hand operand
was negative, was erroneously evaluated.
DATA
implied-DO
constructs
(these involved an errant diagnostic and a crash, both on good
code, one involving subsequent statement-function definition).
INCLUDE
files after processing them, so compiling source
files with lots of INCLUDE
statements does not result in
being unable to open INCLUDE
files after all the available
file descriptors are used up.
gcc
back end (GBE).
These options are -fmove-all-movables, -freduce-all-givs,
and -frerun-loop-opt, which are enabled, by default,
for Fortran compilations.
These optimizations are intended to help toon Fortran programs.
gcc
also is patched to make it easier to manage installations,
especially useful if it turns out a g77
change to the
GBE has a bug.
The g77
-modified version number is the gcc
version number with the string .f.n appended,
where f identifies the version as enhanced for
Fortran, and n is 1 for the first Fortran
patch for that version of gcc
, 2 for the
second, and so on.
So, this introduces version 2.7.2.f.1 of gcc
.
DO
loops, instead of these being rejected unless -fpedantic
or -fugly specified.
SAVE
of a local variable or array, even after
it has been given an initial value via DATA
, for example.
g77
documentation, which
supercedes gcc/f/CREDITS, gcc/f/DOC, and
gcc/f/PROJECTS.
These files will be removed in a future release.
The files gcc/f/BUGS, gcc/f/INSTALL, and
gcc/f/NEWS now are automatically built from
the texinfo source when distributions are made.
This effort was inspired by a first pass at translating g77-0.5.16/f/DOC that was contributed to Craig by David Ronis (ronis@onsager.chem.mcgill.ca).
DO
loops work to follow
the F90 standard.
In particular, calculation of the iteration count is
still done by converting the start, end, and increment
parameters to the type of the DO
variable, but
the result of the calculation is always converted to
the default INTEGER
type.
(This should have no effect on existing code compiled
by g77
, but code written to assume that use
of a wider type for the DO
variable
will result in an iteration count being fully calculated
using that wider type (wider
than default INTEGER
) must be rewritten.)
gcc
version 2.7.2.
libf2c
as of 1996-03-23, and
fix up some of the build procedures.
Note that the email addresses related to f2c
have changed---the distribution site now is
named netlib.bell-labs.com
, and the
maintainer's new address is dmg@bell-labs.com.
All users of version 0.5.16 should ensure that they have not removed /dev/null or replaced it with an ordinary file (e.g. by comparing the output of ls -l /dev/null with ls -l /dev/zero. If the output isn't basically the same, contact your system administrator about restoring /dev/null to its proper status).
This bug is particularly insidious because removing /dev/null as a special file can go undetected for quite a while, aside from various applications and programs exhibiting sudden, strange behaviors.
I sincerely apologize for not realizing the
implications of the fact that when g77 -v runs the ld
command
with -o /dev/null that ld
tries to remove the executable
it is supposed to build (especially if it reports unresolved
references, which it should in this case)!
ASSIGN
'ed variables so they can be SAVE
'd or dummy arguments,
and issue clearer error message in cases where target of ASSIGN
or ASSIGN
ed GOTO
/FORMAT
is too small (which should
never happen).
libf2c
build procedures work on more systems again by
eliminating unnecessary invocations of ld -r -x and mv.
IMPLICIT NONE
.
INTEGER
constant for the right-hand operator (e.g. I**32767).
g77
(the fini
utility in particular) is properly built using the host compiler.
g77
) in ways that
are surprising to many programmers.
ERF()
and ERFC()
as generic intrinsics mapping to existing
ERF
/DERF
and ERFC
/DERFC
specific intrinsics.
Note: You should
specify INTRINSIC ERF,ERFC in any code where you might use
these as generic intrinsics, to improve likelihood of diagnostics
(instead of subtle run-time bugs) when using a compiler that
doesn't support these as intrinsics (e.g. f2c
).
DO
with non-INTEGER
index variable; issue that under
-Wsurprising instead.
.EQ.
/.NE.
on LOGICAL
operands.
LOGICAL
operands.
DO
loops on some
machines.
gcc
version 2.7.1.
libf2c
as of 1995-11-15.
EQUIVALENCE
statements
not involving COMMON
.
libf2c
from code compiled with -fno-f2c by making these
procedures known to g77
as intrinsics (not affected by -fno-f2c).
This is known to fix code invoking ERF()
, ERFC()
,
DERF()
, and DERFC()
.
libf2c
to include netlib patches through 1995-08-16, and
#define
WANT_LEAD_0 to 1 to make g77
-compiled code more
consistent with other Fortran implementations by outputting
leading zeros in formatted and list-directed output.
f2c
plus gcc
(but apparently only when using
gcc-2.7.0 or later).
COMPLEX
and
DOUBLE COMPLEX
FUNCTION
s and doing COMPLEX
and
DOUBLE COMPLEX
divides, when the result
of the invocation or divide is assigned directly to a variable
that overlaps one or more of the arguments to the invocation or divide.
gcc
back end does not support the necessary
mechanics (and the gcc
front end rejects the equivalent
construct, as it turns out).
DOUBLE COMPLEX
constant to an INTEGER
constant power.
DATA
,
for example).
g77
driver.
Provide for easy selection of whether to install copy of g77
as f77
to replace the broken code.
gcc
driver (affects g77
thereby) to not
gratuitously invoke the
f771
program (e.g. when -E is specified).
INCLUDE
statement.
gcc
/g77
when
compiling Fortran files.
These options include -p, -pg, -aux-info, -P,
correct setting of version-number macros for preprocessing, full
recognition of -O0, and
automatic insertion of configuration-specific linker specs.
libf2c
:
ABORT
, DERF
, DERFC
, ERF
, ERFC
, EXIT
,
FLUSH
, GETARG
, GETENV
, IARGC
,
SIGNAL
, and SYSTEM
.
Note that ABORT
, EXIT
, FLUSH
, SIGNAL
, and
SYSTEM
are intrinsic subroutines, not functions (since they
have side effects), so to get the return values from SIGNAL
and SYSTEM
, append a final argument specifying an INTEGER
variable or array element (e.g. CALL SYSTEM('rm foo',ISTAT)).
LOC()
intrinsic out of the vxt group to the new
unix group.
g77
so that g77 -v by itself (or with
certain other options, including -B, -b, -i,
-nostdlib, and -V) reports lots more useful
version info, and so that long-form options gcc
accepts are
understood by g77
as well (even in truncated, unambiguous forms).
g77
option --driver=name to specify driver when
default, gcc
, isn't appropriate.
gcc
, with info such as
In function `foo': and In file included from...:.
gcc
's -fident and -fno-ident options.
DATA
implied-DO
iteration
variables, even though, strictly speaking, these are not uses
of the variables themselves.
g77
might someday start warning about these)---applies
to gcc
versions 2.7.0 and later, since earlier versions didn't
warn about unused dummy arguments.
g77
using the native (non-gcc
) compiler on certain machines
(but definitely not all machines nor all non-gcc
compilers).
Please
do not report bugs showing problems compilers have with
macros defined in gcc/f/target.h and used in places like
gcc/f/expr.c.
INTEGER
, REAL
, or LOGICAL
size
is not 32 bits,
since g77
is known to not work well for such cases (to be
fixed in Version 0.6---see Actual Bugs We Haven't Fixed Yet).
libf2c
with -g0, not -g2, in effect
(by default), to produce
smaller library without lots of debugging clutter.
g77
and the back end (such as for DO
loops).
REAL
when
the -ff2c option is in force (which it is by default) so that
f2c
compatibility is indeed provided.
gcc
back end is to be fixed to do this even better, and it
turned out to slow down some code in some cases after all.
COMMON
and EQUIVALENCE
areas with any members given initial
values (e.g. via DATA
), uninitialized members now always
initialized to binary zeros (though this is not required by
the standard, and might not be done in future versions
of g77
).
Previously, in some COMMON
/EQUIVALENCE
areas
(essentially those with members of more than one type), the
uninitialized members were initialized to spaces, to
cater to CHARACTER
types, but it seems no existing code expects
that, while much existing code expects binary zeros.
DO
loops
for cases
where the loop should not execute at all.
(This bug affected cases
where the difference between the begin and end values was less
than the step count, though probably not for floating-point cases.)
DATA
implied-DO
list.
MVBITS()
intrinsic.
DCMPLX()
with a single INTEGER
argument.
INCLUDE
statement, plus gcc
's
header.gcc facility for handling systems like MS-DOS.
INCLUDE
statement to be continued across multiple lines,
even allow it to coexist with other statements on the same line.
libf2c
through 1995-03-15---this
fixes a bug involving infinite loops reading EOF with empty list-directed
I/O list.
g77
-specific auto-configuration scripts, code,
and so on,
except for temporary substitutes for bsearch() and strtoul(), as
too many configure/build problems were reported in these areas.
People will have to fix their systems' problems themselves, or at
least somewhere other than g77
, which expects a working ANSI C
environment (and, for now, a GNU C compiler to compile g77
itself).
CHARACTER
and Hollerith constants to be interpreted a la GNU C.
Note that
this behavior is somewhat different from f2c
's, which supports only
a limited subset of backslash (escape) sequences.
PARAMETER
), and also allows character<->numeric conversion in
those contexts---turn off via -fno-ugly-init.
SAVE
d, i.e. made
automatic or static.
IMPLICIT NONE
.)
gcc
(i.e. unless -O not specified, since -Wuninitialized
requires -O), and implies -Wunused as well.
EXTERNAL
names (since they are assumed to refer to block data
program units, to make use of libraries more reliable).
%LOC()
and LOC()
of character arguments.
f2c
's IMAG()
generic intrinsic.
ICHAR()
, IACHAR()
, and LEN()
of
character expressions that are valid in assignments but
not normally as actual arguments.
f2c
-style & in column 1 to mean continuation line.
NAMELIST
, EXTERNAL
, INTRINSIC
, and VOLATILE
in BLOCK DATA
, even though these are not allowed by the standard.
RETURN
in main program unit.
INTEGER
(padded on right with spaces if constant
too small, otherwise fully intact if constant wider the INTEGER
type) instead of by value.
Warning: f2c
differs on the
interpretation of CALL FOO(1HX), which it treats exactly the
same as CALL FOO('X'), but which the standard and g77
treat
as CALL FOO(%REF('X ')) (padded with as many spaces as necessary
to widen to INTEGER
), essentially.
INTEGER
value.
INTEGER
constant.
%DESCR()
of a non-CHARACTER
expression now passes a pointer to
the expression plus a length for the expression just as if
it were a CHARACTER
expression.
For example, CALL FOO(%DESCR(D)), where
D is REAL*8
, is the same as CALL FOO(D,%VAL(8))).
DO
loops.
g77
man page.
INTEGER
.
SQRT()
and DSQRT()
,
also when -ffast-math
specified, enable better code generation for SIN()
and COS()
.